Add RLZ Access points for the app launcher.

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)
@@ skipping 44 matching lines @@
   // 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,
@@ skipping 76 matching lines @@
 
 #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 or host page have been used.
+  // 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_