rlz: Hook up on mac, switch to chrome's network stack on win.

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"
 
 #include <algorithm>
 
 #include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/file_path.h"
 #include "base/message_loop.h"
-#include "base/path_service.h"
 #include "base/string_util.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/chrome_notification_types.h"
-#include "chrome/common/chrome_paths.h"
-#include "chrome/common/env_vars.h"
-#include "chrome/installer/util/google_update_settings.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 
+#if defined(OS_WIN)
+#include "chrome/installer/util/google_update_settings.h"
+#else
+namespace GoogleUpdateSettings {
+static bool GetLanguage(string16* language) {
+  // TODO(thakis): Implement.
+  NOTIMPLEMENTED();
+  return false;
+}
+
+// The referral program is defunct and not used. No need to implement these
+// functions on mac.
+static bool GetReferral(string16* referral) {
+  return true;
+}
+static bool ClearReferral() {
+  return true;
+}
+}  // namespace GoogleUpdateSettings
+#endif
+
 using content::BrowserThread;
 using content::NavigationEntry;
 
 namespace {
 
 bool IsBrandOrganic(const std::string& brand) {
   return brand.empty() || google_util::IsOrganic(brand);
 }
 
 void RecordProductEvents(bool first_run, bool google_default_search,
@@ skipping 95 matching lines @@
   return GetInstance()->Init(first_run, delay, google_default_search,
                              google_default_homepage);
 }
 
 bool RLZTracker::Init(bool first_run, int delay, bool google_default_search,
                       bool google_default_homepage) {
   first_run_ = first_run;
   google_default_search_ = google_default_search;
   google_default_homepage_ = google_default_homepage;
 
+  worker_pool_token_ = BrowserThread::GetBlockingPool()->GetSequenceToken();

[Roger Tawa OOO till Jul 10th, 2012/03/24 01:10:42]

The idea is to delay rlz initialization as much as possible so that it does not
slow down chrome startup.  Can this call be moved to DelayedInit() ?

[Nico, 2012/03/24 01:29:47]

Done. (This is just an atomic increment behind the scenes though.)

+
   // A negative delay means that a 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.
   send_ping_immediately_ = false;
   if (delay < 0) {
     send_ping_immediately_ = true;
     delay = -delay;
   }
 
   // Maximum and minimum delay we would allow to be set through master
@@ skipping 20 matching lines @@
                  content::NotificationService::AllSources());
 
   ScheduleDelayedInit(delay);
 
   return true;
 }
 
 void RLZTracker::ScheduleDelayedInit(int delay) {
   // The RLZTracker is a singleton object that outlives any runnable tasks
   // that will be queued up.
+  // TODO: Move to SequencedWorkerPool once http://crbug.com/119657 is fixed.
   BrowserThread::PostDelayedTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&RLZTracker::DelayedInit, base::Unretained(this)),
       delay);
 }
 
 void RLZTracker::DelayedInit() {
   bool schedule_ping = false;
 
+  rlz_lib::SetURLRequestContext(g_browser_process->system_request_context());
+
   // 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) && !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) &&
       !IsBrandOrganic(reactivation_brand)) {
     rlz_lib::SupplementaryBranding branding(reactivation_brand.c_str());
     RecordProductEvents(first_run_, google_default_search_,
                         google_default_homepage_, already_ran_,
                         omnibox_used_, homepage_used_);
     schedule_ping = true;
   }
 
   already_ran_ = true;
 
   if (schedule_ping)
     ScheduleFinancialPing();
 }
 
 void RLZTracker::ScheduleFinancialPing() {
-  // TODO(thakis): Once akalin's TaskRunner around PostTask() is done,
-  // use that instead of the file thread.
-  BrowserThread::PostTask(
-      BrowserThread::FILE,
+  BrowserThread::GetBlockingPool()->PostSequencedWorkerTask(
+      worker_pool_token_,
       FROM_HERE,
       base::Bind(&RLZTracker::PingNowImpl, base::Unretained(this)));
 }
 
 void RLZTracker::PingNowImpl() {
   string16 lang;
   GoogleUpdateSettings::GetLanguage(&lang);
   if (lang.empty())
     lang = ASCIIToUTF16("en");
   string16 referral;
@@ skipping 134 matching lines @@
   base::AutoLock lock(cache_lock_);
   rlz_cache_[point] = rlz_local;
   return true;
 }
 
 bool RLZTracker::ScheduleGetAccessPointRlz(rlz_lib::AccessPoint point) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI))
     return false;
 
   string16* not_used = NULL;
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
+  BrowserThread::GetBlockingPool()->PostSequencedWorkerTask(
+      worker_pool_token_,
+      FROM_HERE,
       base::Bind(base::IgnoreResult(&RLZTracker::GetAccessPointRlz), point,
                  not_used));
   return true;
 }
 
 // static
 void RLZTracker::CleanupRlz() {
   GetInstance()->rlz_cache_.clear();
   GetInstance()->registrar_.RemoveAll();
 }