Make safe browsing work in a multi-profile environment.

chrome/browser/safe_browsing/safe_browsing_service.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.
 
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/prefs/pref_service.h"
-#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/malware_details.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
@@ skipping 19 matching lines @@
 const char* const kSbDefaultMacKeyURLPrefix =
     "https://sb-ssl.google.com/safebrowsing";
 
 // When download url check takes this long, client's callback will be called
 // without waiting for the result.
 const int64 kDownloadUrlCheckTimeoutMs = 10000;
 
 // Similar to kDownloadUrlCheckTimeoutMs, but for download hash checks.
 const int64 kDownloadHashCheckTimeoutMs = 10000;
 
-// TODO(lzheng): Replace this with Profile* ProfileManager::GetDefaultProfile().
-Profile* GetDefaultProfile() {
-  FilePath user_data_dir;
-  PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
-  ProfileManager* profile_manager = g_browser_process->profile_manager();
-  return profile_manager->GetDefaultProfile(user_data_dir);
-}
-
 // Records disposition information about the check.  |hit| should be
 // |true| if there were any prefix hits in |full_hashes|.
 void RecordGetHashCheckStatus(
     bool hit,
     bool is_download,
     const std::vector<SBFullHashResult>& full_hashes) {
   SafeBrowsingProtocolManager::ResultType result;
   if (full_hashes.empty()) {
     result = SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_EMPTY;
   } else if (hit) {
@@ skipping 90 matching lines @@
       enable_download_protection_(false),
       enable_csd_whitelist_(false),
       update_in_progress_(false),
       database_update_in_progress_(false),
       closing_database_(false),
       download_urlcheck_timeout_ms_(kDownloadUrlCheckTimeoutMs),
       download_hashcheck_timeout_ms_(kDownloadHashCheckTimeoutMs) {
 }
 
 void SafeBrowsingService::Initialize() {
-  // Get the profile's preference for SafeBrowsing.
-  PrefService* pref_service = GetDefaultProfile()->GetPrefs();
-  if (pref_service->GetBoolean(prefs::kSafeBrowsingEnabled))
-    Start();
+  // Always initialize the safe browsing service. Each profile will decide
+  // whether to use it based on per-user preferences. TODO(mirandac): in
+  // follow-up CL, only initialize if a profile is launched for which safe
+  // browsing is enabled. see http://crbug.com/88661
+  Start();
 }
 
 void SafeBrowsingService::ShutDown() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(this, &SafeBrowsingService::OnIOShutdown));
 }
 
 bool SafeBrowsingService::CanCheckUrl(const GURL& url) const {
   return url.SchemeIs(chrome::kFtpScheme) ||
          url.SchemeIs(chrome::kHttpScheme) ||
          url.SchemeIs(chrome::kHttpsScheme);
 }
 
-// Only report SafeBrowsing related stats when UMA is enabled and
-// safe browsing is enabled.
+// Only report SafeBrowsing related stats when UMA is enabled. User must also
+// ensure that safe browsing is enabled from the calling profile.
 bool SafeBrowsingService::CanReportStats() const {
   const MetricsService* metrics = g_browser_process->metrics_service();
-  const PrefService* pref_service = GetDefaultProfile()->GetPrefs();
-  return metrics && metrics->reporting_active() &&
-      pref_service && pref_service->GetBoolean(prefs::kSafeBrowsingEnabled);
+  return metrics && metrics->reporting_active();
 }
 
 // Binhash verification is only enabled for UMA users for now.
 bool SafeBrowsingService::DownloadBinHashNeeded() const {
   return enable_download_protection_ && CanReportStats();
 }
 
 bool SafeBrowsingService::CheckDownloadUrl(const std::vector<GURL>& url_chain,
                                            Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 644 matching lines @@
   PrefService* local_state = g_browser_process->local_state();
   DCHECK(local_state);
   std::string client_key, wrapped_key;
   if (local_state) {
     client_key =
       local_state->GetString(prefs::kSafeBrowsingClientKey);
     wrapped_key =
       local_state->GetString(prefs::kSafeBrowsingWrappedKey);
   }
 
-  // We will issue network fetches using the default profile's request context.
+  // We will issue network fetches using the system request context.
   scoped_refptr<net::URLRequestContextGetter> request_context_getter(
-      GetDefaultProfile()->GetRequestContext());
+    g_browser_process->system_request_context());
 
   CommandLine* cmdline = CommandLine::ForCurrentProcess();
   enable_download_protection_ =
       !cmdline->HasSwitch(switches::kSbDisableDownloadProtection);
 
   // We only download the csd-whitelist if client-side phishing detection is
   // enabled and if the user has opted in with stats collection.  Note: we
   // cannot check whether the metrics_service() object is created because it
   // may be initialized after this method is called.
 #ifdef OS_CHROMEOS
@@ skipping 104 matching lines @@
   if (IsWhitelisted(resource)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         NewRunnableMethod(this,
                           &SafeBrowsingService::NotifyClientBlockingComplete,
                           resource.client, true));
     return;
   }
 
   // The tab might have been closed.
-  TabContents* wc =
+  TabContents* tab_contents =
       tab_util::GetTabContentsByID(resource.render_process_host_id,
                                    resource.render_view_id);
 
-  if (!wc) {
+  if (!tab_contents) {
     // The tab is gone and we did not have a chance at showing the interstitial.
-    // Just act as "Don't Proceed" was chosen.
+    // Just act as if "Don't Proceed" were chosen.
     std::vector<UnsafeResource> resources;
     resources.push_back(resource);
     BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           this, &SafeBrowsingService::OnBlockingPageDone, resources, false));
     return;
   }
 
-  if (resource.threat_type != SafeBrowsingService::SAFE && CanReportStats()) {
-    GURL page_url = wc->GetURL();
+  if (resource.threat_type != SafeBrowsingService::SAFE &&
+      CanReportStats()) {
+    GURL page_url = tab_contents->GetURL();
     GURL referrer_url;
-    NavigationEntry* entry = wc->controller().GetActiveEntry();
+    NavigationEntry* entry = tab_contents->controller().GetActiveEntry();
     if (entry)
       referrer_url = entry->referrer();
 
     // When the malicious url is on the main frame, and resource.original_url
     // is not the same as the resource.url, that means we have a redirect from
     // resource.original_url to resource.url.
     // Also, at this point, page_url points to the _previous_ page that we
     // were on. We replace page_url with resource.original_url and referrer
     // with page_url.
     if (!resource.is_subresource &&
@@ skipping 213 matching lines @@
          (entry.result == CLIENT_SIDE_PHISHING_URL &&
           resource.threat_type == URL_PHISHING))  &&
         entry.domain ==
         net::RegistryControlledDomainService::GetDomainAndRegistry(
             resource.url)) {
       return true;
     }
   }
   return false;
 }