RLZ on ChromeOS-related polishing.

chrome/browser/rlz/rlz.h

 // 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/string16.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "base/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 (delayed by |delay| seconds) that performs the ping and
-  // registers some events when 'first-run' is true.
+  // 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, financial ping should be sent
+  // immediately after a first search is recorded, without waiting for the next
+  // restart of chrome. However, we only want this behaviour on first run.

[Roger Tawa OOO till Jul 10th, 2012/12/20 18:37:23]

We don't wait for "the next restart of chrome".  If |send_ping_immediately| is
false, the ping will always be sent out |delay| seconds later.  If
|send_ping_immediately| is true, the ping will be sent out at the earliest of:

- the first search is recorded
- |delay| seconds

Please keep the part of the comment that states that |delay| is specified in
seconds.

[Ivan Korotkov, 2012/12/21 10:42:02]

Done.

   //
   // If the chrome brand is organic (no partners) then the pings don't occur.
   static bool InitRlzFromProfileDelayed(Profile* profile,
                                         bool first_run,
-                                        int delay);
+                                        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;
@@ skipping 21 matching lines @@
   static void EnableZeroDelayForTesting();
 
   // 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,
-                             int delay,
+                             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,
@@ skipping 10 matching lines @@
   // 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,
-            int delay,
+            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, string16* rlz);
 
   // Schedules the delayed initialization. This method is virtual to allow
   // tests to override how the scheduling is done.
-  virtual void ScheduleDelayedInit(int delay);
+  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);
@@ skipping 46 matching lines @@
   bool omnibox_used_;
   bool homepage_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.
-  int min_delay_;
+  base::TimeDelta min_init_delay_;
 
   DISALLOW_COPY_AND_ASSIGN(RLZTracker);
 };
 
 #endif  // defined(ENABLE_RLZ)
 
 #endif  // CHROME_BROWSER_RLZ_RLZ_H_