Add "enabled" state to the ClientSideDetectionService.

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.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_change_registrar.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/safe_browsing/client_side_detection_service.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_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
@@ skipping 128 matching lines @@
     : database_(NULL),
       protocol_manager_(NULL),
       enabled_(false),
       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) {
+#if !defined(OS_CHROMEOS)
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableClientSidePhishingDetection) &&
+      CanReportStats()) {
+    csd_service_.reset(
+        safe_browsing::ClientSideDetectionService::Create(
+            g_browser_process->system_request_context()));
+  }
+#endif
+}
+
+SafeBrowsingService::~SafeBrowsingService() {
+  // Deletes the PrefChangeRegistrars, whose dtors also unregister |this| as an
+  // observer of the preferences.
+  STLDeleteValues(&prefs_map_);
+
+  // We should have already been shut down. If we're still enabled, then the
+  // database isn't going to be closed properly, which could lead to corruption.
+  DCHECK(!enabled_);
 }
 
 void SafeBrowsingService::Initialize() {
   // Track the safe browsing preference of existing profiles.
   // The SafeBrowsingService will be started if any existing profile has the
   // preference enabled. It will also listen for updates to the preferences.
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   if (profile_manager) {
     std::vector<Profile*> profiles = profile_manager->GetLoadedProfiles();
     for (size_t i = 0; i < profiles.size(); ++i) {
       if (profiles[i]->IsOffTheRecord())
         continue;
       AddPrefService(profiles[i]->GetPrefs());
     }
   }
 
   // Track profile creation and destruction.
   prefs_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CREATED,
                        NotificationService::AllSources());
   prefs_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                        NotificationService::AllSources());
 }
 
 void SafeBrowsingService::ShutDown() {
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(this, &SafeBrowsingService::OnIOShutdown));
+  Stop();
+  // The IO thread is going away, so make sure the ClientSideDetectionService
+  // dtor executes now since it may call the dtor of URLFetcher which relies
+  // on it.
+  csd_service_.reset();
 }
 
 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. User must also
 // ensure that safe browsing is enabled from the calling profile.
@@ skipping 269 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &SafeBrowsingService::OnResetDatabase));
 }
 
 void SafeBrowsingService::LogPauseDelay(base::TimeDelta time) {
   UMA_HISTOGRAM_LONG_TIMES("SB2.Delay", time);
 }
 
-SafeBrowsingService::~SafeBrowsingService() {
-  // Deletes the PrefChangeRegistrars, whose dtors also unregister |this| as an
-  // observer of the preferences.
-  STLDeleteValues(&prefs_map_);
-
-  // We should have already been shut down. If we're still enabled, then the
-  // database isn't going to be closed properly, which could lead to corruption.
-  DCHECK(!enabled_);
-}
-
 void SafeBrowsingService::OnIOInitialize(
     const std::string& client_key,
     const std::string& wrapped_key,
     net::URLRequestContextGetter* request_context_getter) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (enabled_)
     return;
   DCHECK(!safe_browsing_thread_.get());
   safe_browsing_thread_.reset(new base::Thread("Chrome_SafeBrowsingThread"));
   if (!safe_browsing_thread_->Start())
@@ skipping 386 matching lines @@
        local_state && local_state->GetBoolean(prefs::kMetricsReportingEnabled));
 #endif
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           this, &SafeBrowsingService::OnIOInitialize, client_key, wrapped_key,
           request_context_getter));
 }
 
+void SafeBrowsingService::Stop() {
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &SafeBrowsingService::OnIOShutdown));
+}
+
 void SafeBrowsingService::OnCloseDatabase() {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   DCHECK(closing_database_);
 
   // Because |closing_database_| is true, nothing on the IO thread will be
   // accessing the database, so it's safe to delete and then NULL the pointer.
   delete database_;
   database_ = NULL;
 
   // Acquiring the lock here guarantees correct ordering between the resetting
@@ skipping 404 matching lines @@
   for (iter = prefs_map_.begin(); iter != prefs_map_.end(); ++iter) {
     if (iter->first->GetBoolean(prefs::kSafeBrowsingEnabled)) {
       enable = true;
       break;
     }
   }
 
   if (enable)
     Start();
   else
-    ShutDown();
+    Stop();
+
+  if (csd_service_.get())
+    csd_service_->SetEnabled(enable);
 }