// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_RLZ_RLZ_H_
#define CHROME_BROWSER_RLZ_RLZ_H_
#include "build/build_config.h"
#if defined(ENABLE_RLZ)
#include <map>
#include <string>
#include "base/basictypes.h"
#include "base/memory/singleton.h"
#include "base/strings/string16.h"
#include "base/threading/sequenced_worker_pool.h"
#include "base/time/time.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "rlz/lib/rlz_lib.h"
class Profile;
namespace net {
class URLRequestContextGetter;
}
// RLZ is a library which is used to measure distribution scenarios.
// Its job is to record certain lifetime events in the registry and to send
// them encoded as a compact string at most twice. The sent data does
// not contain information that can be used to identify a user or to infer
// browsing habits. The API in this file is a wrapper around the open source
// RLZ library which can be found at http://code.google.com/p/rlz.
//
// For partner or bundled installs, the RLZ might send more information
// according to the terms disclosed in the EULA.
class RLZTracker : public content::NotificationObserver {
public:
// Initializes the RLZ library services for use in chrome. Schedules a delayed
// task that performs the ping and registers some events when 'first-run' is
// true.
//
// When |send_ping_immediately| is true, a financial ping should be sent
// immediately after a first search is recorded, without waiting for |delay|.
// However, we only want this behaviour on first run.
//
// If the chrome brand is organic (no partners) then the pings don't occur.
static bool InitRlzFromProfileDelayed(Profile* profile,
bool first_run,
bool send_ping_immediately,
base::TimeDelta delay);
// Records an RLZ event. Some events can be access point independent.
// Returns false it the event could not be recorded. Requires write access
// to the HKCU registry hive on windows.
static bool RecordProductEvent(rlz_lib::Product product,
rlz_lib::AccessPoint point,
rlz_lib::Event event_id);
// For the point parameter of RecordProductEvent.
static const rlz_lib::AccessPoint CHROME_OMNIBOX;
static const rlz_lib::AccessPoint CHROME_HOME_PAGE;
#if !defined(OS_IOS)
static const rlz_lib::AccessPoint CHROME_APP_LIST;
#endif
// Gets the HTTP header value that can be added to requests from the
// specific access point. The string returned is of the form:
//
// "X-Rlz-String: <access-point-rlz>\r\n"
//
static std::string GetAccessPointHttpHeader(rlz_lib::AccessPoint point);
// Gets the RLZ value of the access point.
// Returns false if the rlz string could not be obtained. In some cases
// an empty string can be returned which is not an error.
static bool GetAccessPointRlz(rlz_lib::AccessPoint point,
base::string16* rlz);
// Invoked during shutdown to clean up any state created by RLZTracker.
static void CleanupRlz();
#if defined(OS_CHROMEOS)
// Clears all product state. Should be called when turning RLZ off. On other
// platforms, this is done by product uninstaller.
static void ClearRlzState();
#endif
// This method is public for use by the Singleton class.
static RLZTracker* GetInstance();
// Enables zero delay for InitRlzFromProfileDelayed. For testing only.
static void EnableZeroDelayForTesting();
#if !defined(OS_IOS)
// Records that the app list search has been used.
static void RecordAppListSearch();
#endif
// The following methods are made protected so that they can be used for
// testing purposes. Production code should never need to call these.
protected:
RLZTracker();
virtual ~RLZTracker();
// Called by InitRlzFromProfileDelayed with values taken from |profile|.
static bool InitRlzDelayed(bool first_run,
bool send_ping_immediately,
base::TimeDelta delay,
bool is_google_default_search,
bool is_google_homepage,
bool is_google_in_startpages);
// Performs initialization of RLZ tracker that is purposefully delayed so
// that it does not interfere with chrome startup time.
virtual void DelayedInit();
// content::NotificationObserver implementation:
virtual void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE;
// Used by test code to override the default RLZTracker instance returned
// by GetInstance().
void set_tracker(RLZTracker* tracker) {
tracker_ = tracker;
}
// Sends the financial ping to the RLZ servers and invalidates the RLZ string
// cache since the response from the RLZ server may have changed then.
// Protected so that its accessible from tests.
void PingNowImpl();
private:
friend struct DefaultSingletonTraits<RLZTracker>;
friend class base::RefCountedThreadSafe<RLZTracker>;
// Implementation called from InitRlzDelayed() static method.
bool Init(bool first_run,
bool send_ping_immediately,
base::TimeDelta delay,
bool google_default_search,
bool google_default_homepage,
bool is_google_in_startpages);
// Implementation called from RecordProductEvent() static method.
bool RecordProductEventImpl(rlz_lib::Product product,
rlz_lib::AccessPoint point,
rlz_lib::Event event_id);
// Records FIRST_SEARCH event. Called from Observe() on blocking task runner.
void RecordFirstSearch(rlz_lib::AccessPoint point);
// Implementation called from GetAccessPointRlz() static method.
bool GetAccessPointRlzImpl(rlz_lib::AccessPoint point, base::string16* rlz);
// Schedules the delayed initialization. This method is virtual to allow
// tests to override how the scheduling is done.
virtual void ScheduleDelayedInit(base::TimeDelta delay);
// Schedules a call to rlz_lib::RecordProductEvent(). This method is virtual
// to allow tests to override how the scheduling is done.
virtual bool ScheduleRecordProductEvent(rlz_lib::Product product,
rlz_lib::AccessPoint point,
rlz_lib::Event event_id);
// Schedules a call to rlz_lib::RecordFirstSearch(). This method is virtual
// to allow tests to override how the scheduling is done.
virtual bool ScheduleRecordFirstSearch(rlz_lib::AccessPoint point);
// Schedules a call to rlz_lib::SendFinancialPing(). This method is virtual
// to allow tests to override how the scheduling is done.
virtual void ScheduleFinancialPing();
// Schedules a call to GetAccessPointRlz() on the I/O thread if the current
// thread is not already the I/O thread, otherwise does nothing. Returns
// true if the call was scheduled, and false otherwise. This method is
// virtual to allow tests to override how the scheduling is done.
virtual bool ScheduleGetAccessPointRlz(rlz_lib::AccessPoint point);
// Sends the financial ping to the RLZ servers. This method is virtual to
// allow tests to override.
virtual bool SendFinancialPing(const std::string& brand,
const base::string16& lang,
const base::string16& referral);
#if defined(OS_CHROMEOS)
// Implementation called from ClearRlzState static method.
void ClearRlzStateImpl();
// Schedules a call to ClearRlzStateImpl(). This method is virtual
// to allow tests to override how the scheduling is done.
virtual bool ScheduleClearRlzState();
#endif
// Returns a pointer to the bool corresponding to whether |point| has been
// used but not reported.
bool* GetAccessPointRecord(rlz_lib::AccessPoint point);
// Tracker used for testing purposes only. If this value is non-NULL, it
// will be returned from GetInstance() instead of the regular singleton.
static RLZTracker* tracker_;
// Configuation data for RLZ tracker. Set by call to Init().
bool first_run_;
bool send_ping_immediately_;
bool is_google_default_search_;
bool is_google_homepage_;
bool is_google_in_startpages_;
// Unique sequence token so that tasks posted by RLZTracker are executed
// sequentially in the blocking pool.
base::SequencedWorkerPool::SequenceToken worker_pool_token_;
// Keeps track if the RLZ tracker has already performed its delayed
// initialization.
bool already_ran_;
// Keeps a cache of RLZ access point strings, since they rarely change.
// The cache must be protected by a lock since it may be accessed from
// the UI thread for reading and the IO thread for reading and/or writing.
base::Lock cache_lock_;
std::map<rlz_lib::AccessPoint, base::string16> rlz_cache_;
// Keeps track of whether the omnibox, home page or app list have been used.
bool omnibox_used_;
bool homepage_used_;
bool app_list_used_;
// Main and (optionally) reactivation brand codes, assigned on UI thread.
std::string brand_;
std::string reactivation_brand_;
content::NotificationRegistrar registrar_;
// Minimum delay before sending financial ping after initialization.
base::TimeDelta min_init_delay_;
DISALLOW_COPY_AND_ASSIGN(RLZTracker);
};
#endif // defined(ENABLE_RLZ)
#endif // CHROME_BROWSER_RLZ_RLZ_H_