Start and stop the safe browsing service depending on whether any profile is using it.

chrome/browser/safe_browsing/safe_browsing_service.h

 // 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.
 //
 // The Safe Browsing service is responsible for downloading anti-phishing and
 // anti-malware tables and checking urls against them.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_SERVICE_H_
 #define CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_SERVICE_H_
 #pragma once
 
 #include <deque>
+#include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "content/common/notification_observer.h"
 #include "content/common/notification_registrar.h"
 #include "googleurl/src/gurl.h"
 
 class MalwareDetails;
+class PrefChangeRegistrar;
 class PrefService;
 class SafeBrowsingDatabase;
 class SafeBrowsingProtocolManager;
 class SafeBrowsingServiceFactory;
 
 namespace base {
 class Thread;
 }
 
 namespace net {
@@ skipping 181 matching lines @@
 
   // The blocking page on the UI thread has completed.
   void OnBlockingPageDone(const std::vector<UnsafeResource>& resources,
                           bool proceed);
 
   // Called on the UI thread when the SafeBrowsingProtocolManager has received
   // updated MAC keys.
   void OnNewMacKeys(const std::string& client_key,
                     const std::string& wrapped_key);
 
-  // Notification on the UI thread from the advanced options UI.
-  void OnEnable(bool enabled);
-
   bool enabled() const { return enabled_; }
 
   bool download_protection_enabled() const {
     return enabled_ && enable_download_protection_;
   }
 
   // Preference handling.
   static void RegisterPrefs(PrefService* prefs);
 
   // Called on the IO thread to reset the database.
@@ skipping 168 matching lines @@
                           int64 timeout_ms);
 
   // Adds the given entry to the whitelist.  Called on the UI thread.
   void UpdateWhitelist(const UnsafeResource& resource);
 
   // NotificationObserver override
   virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
+  // Starts following the safe browsing preference on |pref_service|.
+  void AddPrefService(PrefService* pref_service);
+
+  // Stop following the safe browsing preference on |pref_service|.
+  void RemovePrefService(PrefService* pref_service);
+
+  // Checks if any profile is currently using the safe browsing service, and
+  // starts or stops the service accordingly.
+  void RefreshState();
+
   // The factory used to instanciate a SafeBrowsingService object.
   // Useful for tests, so they can provide their own implementation of
   // SafeBrowsingService.
   static SafeBrowsingServiceFactory* factory_;
 
   CurrentChecks checks_;
 
   // Used for issuing only one GetHash request for a given prefix.
   GetHashRequests gethash_requests_;
 
@@ skipping 42 matching lines @@
 
   std::deque<QueuedCheck> queued_checks_;
 
   // When download url check takes this long, client's callback will be called
   // without waiting for the result.
   int64 download_urlcheck_timeout_ms_;
 
   // Similar to |download_urlcheck_timeout_ms_|, but for download hash checks.
   int64 download_hashcheck_timeout_ms_;
 
+  // Used to track purge memory notifications. Lives on the IO thread.
   NotificationRegistrar registrar_;
 
+  // Tracks existing PrefServices, and the safe browsing preference on each.
+  // This is used to determine if any profile is currently using the safe
+  // browsing service, and to start it up or shut it down accordingly.
+  std::map<PrefService*, PrefChangeRegistrar*> prefs_map_;
+
+  // Used to track creation and destruction of profiles on the UI thread.
+  NotificationRegistrar prefs_registrar_;
+
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingService);
 };
 
 // Factory for creating SafeBrowsingService.  Useful for tests.
 class SafeBrowsingServiceFactory {
  public:
   SafeBrowsingServiceFactory() { }
   virtual ~SafeBrowsingServiceFactory() { }
   virtual SafeBrowsingService* CreateSafeBrowsingService() = 0;
  private:
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceFactory);
 };
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_SERVICE_H_