rlz: Change omnibox / homepage access points from C1/C2 to C5/C6 on mac

chrome/browser/rlz/rlz.cc

 // 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.
 //
 // This code glues the RLZ library DLL with Chrome. It allows Chrome to work
 // with or without the DLL being present. If the DLL is not present the
 // functions do nothing and just return false.
 
 #include "chrome/browser/rlz/rlz.h"
 
@@ skipping 43 matching lines @@
 bool IsBrandOrganic(const std::string& brand) {
   return brand.empty() || google_util::IsOrganic(brand);
 }
 
 void RecordProductEvents(bool first_run, bool google_default_search,
                          bool google_default_homepage, bool already_ran,
                          bool omnibox_used, bool homepage_used) {
   // Record the installation of chrome. We call this all the time but the rlz
   // lib should ingore all but the first one.
   rlz_lib::RecordProductEvent(rlz_lib::CHROME,
-                              rlz_lib::CHROME_OMNIBOX,
+                              RLZTracker::CHROME_OMNIBOX,
                               rlz_lib::INSTALL);
   rlz_lib::RecordProductEvent(rlz_lib::CHROME,
-                              rlz_lib::CHROME_HOME_PAGE,
+                              RLZTracker::CHROME_HOME_PAGE,
                               rlz_lib::INSTALL);
 
   if (!already_ran) {
     // Do the initial event recording if is the first run or if we have an
     // empty rlz which means we haven't got a chance to do it.
     char omnibox_rlz[rlz_lib::kMaxRlzLength + 1];
-    if (!rlz_lib::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, omnibox_rlz,
+    if (!rlz_lib::GetAccessPointRlz(RLZTracker::CHROME_OMNIBOX, omnibox_rlz,
                                     rlz_lib::kMaxRlzLength)) {
       omnibox_rlz[0] = 0;
     }
 
     // Record if google is the initial search provider and/or home page.
     if ((first_run || omnibox_rlz[0] == 0) && google_default_search) {
       rlz_lib::RecordProductEvent(rlz_lib::CHROME,
-                                  rlz_lib::CHROME_OMNIBOX,
+                                  RLZTracker::CHROME_OMNIBOX,
                                   rlz_lib::SET_TO_GOOGLE);
     }
 
     char homepage_rlz[rlz_lib::kMaxRlzLength + 1];
-    if (!rlz_lib::GetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE, homepage_rlz,
+    if (!rlz_lib::GetAccessPointRlz(RLZTracker::CHROME_HOME_PAGE, homepage_rlz,
                                     rlz_lib::kMaxRlzLength)) {
       homepage_rlz[0] = 0;
     }
 
     if ((first_run || homepage_rlz[0] == 0) && google_default_homepage) {
       rlz_lib::RecordProductEvent(rlz_lib::CHROME,
-                                  rlz_lib::CHROME_HOME_PAGE,
+                                  RLZTracker::CHROME_HOME_PAGE,
                                   rlz_lib::SET_TO_GOOGLE);
     }
   }
 
   // Record first user interaction with the omnibox. We call this all the
   // time but the rlz lib should ingore all but the first one.
   if (omnibox_used) {
     rlz_lib::RecordProductEvent(rlz_lib::CHROME,
-                                rlz_lib::CHROME_OMNIBOX,
+                                RLZTracker::CHROME_OMNIBOX,
                                 rlz_lib::FIRST_SEARCH);
   }
 
   // Record first user interaction with the home page. We call this all the
   // time but the rlz lib should ingore all but the first one.
   if (homepage_used) {
     rlz_lib::RecordProductEvent(rlz_lib::CHROME,
-                                rlz_lib::CHROME_HOME_PAGE,
+                                RLZTracker::CHROME_HOME_PAGE,
                                 rlz_lib::FIRST_SEARCH);
   }
 }
 
 bool SendFinancialPing(const std::string& brand,
                        const string16& lang,
                        const string16& referral) {
-  rlz_lib::AccessPoint points[] = {rlz_lib::CHROME_OMNIBOX,
-                                   rlz_lib::CHROME_HOME_PAGE,
+  rlz_lib::AccessPoint points[] = {RLZTracker::CHROME_OMNIBOX,
+                                   RLZTracker::CHROME_HOME_PAGE,
                                    rlz_lib::NO_ACCESS_POINT};
   std::string lang_ascii(UTF16ToASCII(lang));
   std::string referral_ascii(UTF16ToASCII(referral));
   return rlz_lib::SendFinancialPing(rlz_lib::CHROME, points, "chrome",
                                     brand.c_str(), referral_ascii.c_str(),
                                     lang_ascii.c_str(), false, true);
 }
 
 }  // namespace
 
+#if !defined(OS_MACOSX)
+// static
+const rlz_lib::AccessPoint RLZTracker::CHROME_OMNIBOX =
+    rlz_lib::CHROME_OMNIBOX;
+// static
+const rlz_lib::AccessPoint RLZTracker::CHROME_HOME_PAGE =
+    rlz_lib::CHROME_HOME_PAGE;
+#else
+// static
+const rlz_lib::AccessPoint RLZTracker::CHROME_OMNIBOX =
+    rlz_lib::CHROME_MAC_OMNIBOX;
+// static
+const rlz_lib::AccessPoint RLZTracker::CHROME_HOME_PAGE =
+    rlz_lib::CHROME_MAC_HOME_PAGE;
+#endif
+
 RLZTracker* RLZTracker::tracker_ = NULL;
 
 // static
 RLZTracker* RLZTracker::GetInstance() {
   return tracker_ ? tracker_ : Singleton<RLZTracker>::get();
 }
 
 RLZTracker::RLZTracker()
     : first_run_(false),
       send_ping_immediately_(false),
@@ skipping 121 matching lines @@
   if (google_util::GetBrand(&brand) && !IsBrandOrganic(brand) &&
       SendFinancialPing(brand, lang, referral)) {
     GoogleUpdateSettings::ClearReferral();
 
     {
       base::AutoLock lock(cache_lock_);
       rlz_cache_.clear();
     }
 
     // Prime the RLZ cache for the access points we are interested in.
-    GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, NULL);
-    GetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE, NULL);
+    GetAccessPointRlz(RLZTracker::CHROME_OMNIBOX, NULL);
+    GetAccessPointRlz(RLZTracker::CHROME_HOME_PAGE, NULL);

[Roger Tawa OOO till Jul 10th, 2012/07/03 18:11:09]

I don't think you need the namespace here and below in this file.

[Nico, 2012/07/03 18:18:08]

I think it's a bit clearer though, since the same symbol is in two different
contexts here (rlz_lib:: and RLZTracker::). Do you mind if I keep it?

   }
 
   std::string reactivation_brand;
   if (google_util::GetReactivationBrand(&reactivation_brand) &&
       !IsBrandOrganic(reactivation_brand)) {
     rlz_lib::SupplementaryBranding branding(reactivation_brand.c_str());
     SendFinancialPing(reactivation_brand, lang, referral);
   }
 }
 
 bool RLZTracker::SendFinancialPing(const std::string& brand,
                                    const string16& lang,
                                    const string16& referral) {
   return ::SendFinancialPing(brand, lang, referral);
 }
 
 void RLZTracker::Observe(int type,
                          const content::NotificationSource& source,
                          const content::NotificationDetails& details) {
   // Needs to be evaluated. See http://crbug.com/62328.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   rlz_lib::AccessPoint point;
   bool* record_used = NULL;
   bool call_record = false;
 
   switch (type) {
     case chrome::NOTIFICATION_OMNIBOX_OPENED_URL:
     case chrome::NOTIFICATION_INSTANT_CONTROLLER_UPDATED:
-      point = rlz_lib::CHROME_OMNIBOX;
+      point = RLZTracker::CHROME_OMNIBOX;
       record_used = &omnibox_used_;
       call_record = true;
 
       registrar_.Remove(this, chrome::NOTIFICATION_OMNIBOX_OPENED_URL,
                         content::NotificationService::AllSources());
       registrar_.Remove(this, chrome::NOTIFICATION_INSTANT_CONTROLLER_UPDATED,
                         content::NotificationService::AllSources());
       break;
     case content::NOTIFICATION_NAV_ENTRY_PENDING: {
       const NavigationEntry* entry =
           content::Details<content::NavigationEntry>(details).ptr();
       if (entry != NULL &&
           ((entry->GetTransitionType() &
             content::PAGE_TRANSITION_HOME_PAGE) != 0)) {
-        point = rlz_lib::CHROME_HOME_PAGE;
+        point = RLZTracker::CHROME_HOME_PAGE;
         record_used = &homepage_used_;
         call_record = true;
 
         registrar_.Remove(this, content::NOTIFICATION_NAV_ENTRY_PENDING,
                           content::NotificationService::AllSources());
       }
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 
   if (call_record) {
     // Try to record event now, else set the flag to try later when we
     // attempt the ping.
     if (!RecordProductEvent(rlz_lib::CHROME, point, rlz_lib::FIRST_SEARCH))
       *record_used = true;
-    else if (send_ping_immediately_ && point == rlz_lib::CHROME_OMNIBOX) {
+    else if (send_ping_immediately_ && point == RLZTracker::CHROME_OMNIBOX) {
       ScheduleDelayedInit(0);
     }
   }
 }
 
 bool RLZTracker::RecordProductEvent(rlz_lib::Product product,
                                     rlz_lib::AccessPoint point,
                                     rlz_lib::Event event_id) {
   bool ret = rlz_lib::RecordProductEvent(product, point, event_id);
 
@@ skipping 58 matching lines @@
       base::Bind(base::IgnoreResult(&RLZTracker::GetAccessPointRlz), point,
                  not_used));
   return true;
 }
 
 // static
 void RLZTracker::CleanupRlz() {
   GetInstance()->rlz_cache_.clear();
   GetInstance()->registrar_.RemoveAll();
 }