Add support for reactivating a chrome install that originally used an

chrome/browser/rlz/rlz.cc

 // Copyright (c) 2011 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 22 matching lines @@
 #include "chrome/common/env_vars.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 
 using content::BrowserThread;
 
 namespace {
 
+bool IsBrandOrganic(const std::string& brand) {
+  return brand.empty() || google_util::IsOrganic(brand);

[Glenn Wilson, 2011/12/02 21:35:02]

It's been a while, this is is pass-by-value, right?  Do you need any protection
for a null brand here?

[Roger Tawa OOO till Jul 10th, 2011/12/02 22:00:20]

Right, no need to check for null.

+}
+
 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,
                               rlz_lib::INSTALL);
   rlz_lib::RecordProductEvent(rlz_lib::CHROME,
                               rlz_lib::CHROME_HOME_PAGE,
@@ skipping 46 matching lines @@
 }
 
 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::NO_ACCESS_POINT};
   std::string lang_ascii(WideToASCII(lang));
   std::string referral_ascii(WideToASCII(referral));
-
-  // If chrome has been reactivated, send a ping for this brand as well.
-  // We ignore the return value of SendFinancialPing() since we'll try again
-  // later anyway. Callers of this function are only interested in whether
-  // the ping for the main brand succeeded or not.
-  std::string reactivation_brand;
-  if (google_util::GetReactivationBrand(&reactivation_brand)) {
-    string16 reactivation_brand16 = UTF8ToUTF16(reactivation_brand);
-    rlz_lib::SupplementaryBranding branding(reactivation_brand16.c_str());
-    rlz_lib::SendFinancialPing(rlz_lib::CHROME, points, "chrome",
-                               reactivation_brand.c_str(),
-                               referral_ascii.c_str(), lang_ascii.c_str(),
-                               false, NULL, true);
-  }
-
   return rlz_lib::SendFinancialPing(rlz_lib::CHROME, points, "chrome",
                                     brand.c_str(), referral_ascii.c_str(),
                                     lang_ascii.c_str(), false, NULL, true);
 }
 
 }  // namespace
 
 RLZTracker* RLZTracker::tracker_ = NULL;
 
 // static
@@ skipping 68 matching lines @@
   // The RLZTracker is a singleton object that outlives any runnable tasks
   // that will be queued up.
   BrowserThread::PostDelayedTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&RLZTracker::DelayedInit, base::Unretained(this)),
       delay);
 }
 
 void RLZTracker::DelayedInit() {
+  bool schedule_ping = false;
+
   // For organic brandcodes do not use rlz at all. Empty brandcode usually
   // means a chromium install. This is ok.
   std::string brand;
-  if (!google_util::GetBrand(&brand) || brand.empty() ||
-      google_util::IsOrganic(brand))
-    return;
-
-  RecordProductEvents(first_run_, google_default_search_,
-                      google_default_homepage_, already_ran_,
-                      omnibox_used_, homepage_used_);
+  if (google_util::GetBrand(&brand) && !IsBrandOrganic(brand)) {
+    RecordProductEvents(first_run_, google_default_search_,
+                        google_default_homepage_, already_ran_,
+                        omnibox_used_, homepage_used_);
+    schedule_ping = true;
+  }
 
   // If chrome has been reactivated, record the events for this brand
   // as well.
   std::string reactivation_brand;
-  if (google_util::GetReactivationBrand(&reactivation_brand)) {
+  if (google_util::GetReactivationBrand(&reactivation_brand) &&
+      !IsBrandOrganic(reactivation_brand)) {
     string16 reactivation_brand16 = UTF8ToUTF16(reactivation_brand);
     rlz_lib::SupplementaryBranding branding(reactivation_brand16.c_str());
     RecordProductEvents(first_run_, google_default_search_,
                         google_default_homepage_, already_ran_,
                         omnibox_used_, homepage_used_);
+    schedule_ping = true;
   }
 
   already_ran_ = true;
 
-  ScheduleFinancialPing();
+  if (schedule_ping)
+    ScheduleFinancialPing();
 }
 
 void RLZTracker::ScheduleFinancialPing() {
+  // Investigate why _beginthread() is used here, and not chrome's threading
+  // API.  Tracked in bug http://crbug.com/106213
   _beginthread(PingNow, 0, this);
 }
 
 // static
 void _cdecl RLZTracker::PingNow(void* arg) {
   RLZTracker* tracker = reinterpret_cast<RLZTracker*>(arg);
   tracker->PingNowImpl();
 }
 
 void RLZTracker::PingNowImpl() {
   // This is the entry point of a background thread, so I/O is allowed.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   string16 lang;
   GoogleUpdateSettings::GetLanguage(&lang);
   if (lang.empty())
     lang = L"en";
-  std::string brand;
-  google_util::GetBrand(&brand);
   string16 referral;
   GoogleUpdateSettings::GetReferral(&referral);
-  if (SendFinancialPing(brand, lang, referral)) {
+
+  std::string brand;
+  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);
   }
+
+  std::string reactivation_brand;
+  if (google_util::GetReactivationBrand(&reactivation_brand) &&
+      !IsBrandOrganic(reactivation_brand)) {
+    string16 reactivation_brand16 = UTF8ToUTF16(reactivation_brand);
+    rlz_lib::SupplementaryBranding branding(reactivation_brand16.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,
@@ skipping 114 matching lines @@
       base::IgnoreReturn<bool>(
           base::Bind(&RLZTracker::GetAccessPointRlz, point, not_used)));
   return true;
 }
 
 // static
 void RLZTracker::CleanupRlz() {
   GetInstance()->rlz_cache_.clear();
   GetInstance()->registrar_.RemoveAll();
 }