[rlz,cros] RLZ glue for ChromeOS.

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/command_line.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_util.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/prefs/session_startup_pref.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/browser/ui/startup/startup_browser_creator.cc"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "net/http/http_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/threading/sequenced_worker_pool.h"
 #endif
 
@@ skipping 18 matching lines @@
 }  // namespace GoogleUpdateSettings
 #endif
 
 using content::BrowserThread;
 using content::NavigationEntry;
 
 namespace {
 
 const char kRlzThreadName[] = "RLZ_thread";
 
+bool IsGoogleUrl(const GURL& url) {
+  return google_util::IsGoogleHomePageUrl(url.possibly_invalid_spec());
+}
+
 bool IsBrandOrganic(const std::string& brand) {
   return brand.empty() || google_util::IsOrganic(brand);
 }
 
 void RecordProductEvents(bool first_run,
                          bool is_google_default_search,
                          bool is_google_homepage,
                          bool is_google_in_startpages,
                          bool already_ran,
                          bool omnibox_used,
@@ skipping 119 matching lines @@
 // static
 bool RLZTracker::InitRlzDelayed(bool first_run,
                                 int delay,
                                 bool is_google_default_search,
                                 bool is_google_homepage,
                                 bool is_google_in_startpages) {
   return GetInstance()->Init(first_run, delay, is_google_default_search,
                              is_google_homepage, is_google_in_startpages);
 }
 
+// static
+bool RLZTracker::InitRlzFromProfileDelayed(Profile* profile,
+                                           bool first_run,
+                                           int delay) {
+  bool is_google_default_search = false;
+  TemplateURLService* template_url_service =
+      TemplateURLServiceFactory::GetForProfile(profile);
+  if (template_url_service) {
+    const TemplateURL* url_template =
+        template_url_service->GetDefaultSearchProvider();
+    is_google_default_search =
+        url_template && url_template->url_ref().HasGoogleBaseURLs();
+  }
+
+  PrefService* pref_service = profile->GetPrefs();
+  bool is_google_homepage = google_util::IsGoogleHomePageUrl(
+      pref_service->GetString(prefs::kHomePage));
+
+  bool is_google_in_startpages = false;
+  SessionStartupPref session_startup_prefs =
+      StartupBrowserCreator::GetSessionStartupPref(
+          *CommandLine::ForCurrentProcess(), profile);
+  if (session_startup_prefs.type == SessionStartupPref::URLS) {
+    is_google_in_startpages = std::count_if(session_startup_prefs.urls.begin(),
+                                            session_startup_prefs.urls.end(),
+                                            IsGoogleUrl) > 0;
+  }
+
+  if (!InitRlzDelayed(first_run, delay,
+                      is_google_default_search, is_google_homepage,
+                      is_google_in_startpages)) {
+    return false;
+  }
+
+  // Prime the RLZ cache for the home page access point so that its avaiable
+  // for the startup page if needed (i.e., when the startup page is set to
+  // the home page).
+  GetAccessPointRlz(CHROME_HOME_PAGE, NULL);
+
+  return true;
+}
+
 bool RLZTracker::Init(bool first_run,
                       int delay,
                       bool is_google_default_search,
                       bool is_google_homepage,
                       bool is_google_in_startpages) {
   first_run_ = first_run;
   is_google_default_search_ = is_google_default_search;
   is_google_homepage_ = is_google_homepage;
   is_google_in_startpages_ = is_google_in_startpages;
 
@@ skipping 310 matching lines @@
   string16* not_used = NULL;
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&RLZTracker::GetAccessPointRlz), point,
                  not_used));
   return true;
 }
 
 // static
 void RLZTracker::CleanupRlz() {
-  GetInstance()->rlz_cache_.clear();
-  GetInstance()->registrar_.RemoveAll();
+  RLZTracker* instance = GetInstance();
+  instance->rlz_cache_.clear();
+  instance->registrar_.RemoveAll();
+#if defined(OS_CHROMEOS)
+  instance->blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&rlz_lib::CleanupRlz));
+#endif
+  instance->blocking_task_runner_ = NULL;
+  instance->rlz_thread_.Stop();
 }