src/chrome/browser/safe_browsing/safe_browsing_service.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5 // The Safe Browsing service is responsible for downloading anti-phishing and
   6 // anti-malware tables and checking urls against them.
   7
   8 #ifndef CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_SERVICE_H_
   9 #define CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_SERVICE_H_
  10
  11 #include <map>
  12 #include <string>
  13
  14 #include "base/callback.h"
  15 #include "base/files/file_path.h"
  16 #include "base/memory/ref_counted.h"
  17 #include "base/memory/scoped_ptr.h"
  18 #include "base/observer_list.h"
  19 #include "base/sequenced_task_runner_helpers.h"
  20 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
  21 #include "content/public/browser/browser_thread.h"
  22 #include "content/public/browser/notification_observer.h"
  23 #include "content/public/browser/notification_registrar.h"
  24
  25 class PrefChangeRegistrar;
  26 class PrefService;
  27 class SafeBrowsingDatabaseManager;
  28 class SafeBrowsingPingManager;
  29 class SafeBrowsingProtocolManager;
  30 class SafeBrowsingServiceFactory;
  31 class SafeBrowsingUIManager;
  32 class SafeBrowsingURLRequestContextGetter;
  33
  34 namespace base {
  35 class Thread;
  36 }
  37
  38 namespace net {
  39 class URLRequestContext;
  40 class URLRequestContextGetter;
  41 }
  42
  43 namespace safe_browsing {
  44 class ClientSideDetectionService;
  45 class DownloadProtectionService;
  46 }
  47
  48 // Construction needs to happen on the main thread.
  49 // The SafeBrowsingService owns both the UI and Database managers which do
  50 // the heavylifting of safebrowsing service. Both of these managers stay
  51 // alive until SafeBrowsingService is destroyed, however, they are disabled
  52 // permanently when Shutdown method is called.
  53 class SafeBrowsingService
  54     : public base::RefCountedThreadSafe<
  55           SafeBrowsingService,
  56           content::BrowserThread::DeleteOnUIThread>,
  57       public content::NotificationObserver {
  58  public:
  59   // Makes the passed |factory| the factory used to instanciate
  60   // a SafeBrowsingService. Useful for tests.
  61   static void RegisterFactory(SafeBrowsingServiceFactory* factory) {
  62     factory_ = factory;
  63   }
  64
  65   static base::FilePath GetCookieFilePathForTesting();
  66
  67   static base::FilePath GetBaseFilename();
  68
  69   // Create an instance of the safe browsing service.
  70   static SafeBrowsingService* CreateSafeBrowsingService();
  71
  72   // Called on the UI thread to initialize the service.
  73   void Initialize();
  74
  75   // Called on the main thread to let us know that the io_thread is going away.
  76   void ShutDown();
  77
  78   // Called on UI thread to decide if the download file's sha256 hash
  79   // should be calculated for safebrowsing.
  80   bool DownloadBinHashNeeded() const;
  81
  82   bool enabled() const { return enabled_; }
  83
  84   safe_browsing::ClientSideDetectionService*
  85       safe_browsing_detection_service() const {
  86     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  87     return csd_service_.get();
  88   }
  89
  90   // The DownloadProtectionService is not valid after the SafeBrowsingService
  91   // is destroyed.
  92   safe_browsing::DownloadProtectionService*
  93       download_protection_service() const {
  94     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  95     return download_service_.get();
  96   }
  97
  98   net::URLRequestContextGetter* url_request_context();
  99
 100   const scoped_refptr<SafeBrowsingUIManager>& ui_manager() const;
 101
 102   const scoped_refptr<SafeBrowsingDatabaseManager>& database_manager() const;
 103
 104   SafeBrowsingProtocolManager* protocol_manager() const;
 105
 106   SafeBrowsingPingManager* ping_manager() const;
 107
 108  protected:
 109   // Creates the safe browsing service.  Need to initialize before using.
 110   SafeBrowsingService();
 111
 112   virtual ~SafeBrowsingService();
 113
 114   virtual SafeBrowsingDatabaseManager* CreateDatabaseManager();
 115
 116   virtual SafeBrowsingUIManager* CreateUIManager();
 117
 118  private:
 119   friend class SafeBrowsingServiceFactoryImpl;
 120   friend struct content::BrowserThread::DeleteOnThread<
 121       content::BrowserThread::UI>;
 122   friend class base::DeleteHelper<SafeBrowsingService>;
 123   friend class SafeBrowsingServerTest;
 124   friend class SafeBrowsingServiceTest;
 125   friend class SafeBrowsingURLRequestContextGetter;
 126
 127   void InitURLRequestContextOnIOThread(
 128       net::URLRequestContextGetter* system_url_request_context_getter);
 129
 130   void DestroyURLRequestContextOnIOThread();
 131
 132   // Called to initialize objects that are used on the io_thread.  This may be
 133   // called multiple times during the life of the SafeBrowsingService.
 134   void StartOnIOThread(
 135       net::URLRequestContextGetter* url_request_context_getter);
 136
 137   // Called to stop or shutdown operations on the io_thread. This may be called
 138   // multiple times to stop during the life of the SafeBrowsingService. If
 139   // shutdown is true, then the operations on the io thread are shutdown
 140   // permanently and cannot be restarted.
 141   void StopOnIOThread(bool shutdown);
 142
 143   // Start up SafeBrowsing objects. This can be called at browser start, or when
 144   // the user checks the "Enable SafeBrowsing" option in the Advanced options
 145   // UI.
 146   void Start();
 147
 148   // Stops the SafeBrowsingService. This can be called when the safe browsing
 149   // preference is disabled. When shutdown is true, operation is permanently
 150   // shutdown and cannot be restarted.
 151   void Stop(bool shutdown);
 152
 153   // content::NotificationObserver override
 154   virtual void Observe(int type,
 155                        const content::NotificationSource& source,
 156                        const content::NotificationDetails& details) OVERRIDE;
 157
 158   // Starts following the safe browsing preference on |pref_service|.
 159   void AddPrefService(PrefService* pref_service);
 160
 161   // Stop following the safe browsing preference on |pref_service|.
 162   void RemovePrefService(PrefService* pref_service);
 163
 164   // Checks if any profile is currently using the safe browsing service, and
 165   // starts or stops the service accordingly.
 166   void RefreshState();
 167
 168   // The factory used to instanciate a SafeBrowsingService object.
 169   // Useful for tests, so they can provide their own implementation of
 170   // SafeBrowsingService.
 171   static SafeBrowsingServiceFactory* factory_;
 172
 173   // The SafeBrowsingURLRequestContextGetter used to access
 174   // |url_request_context_|. Accessed on UI thread.
 175   scoped_refptr<net::URLRequestContextGetter>
 176       url_request_context_getter_;
 177
 178   // The SafeBrowsingURLRequestContext. Accessed on IO thread.
 179   scoped_ptr<net::URLRequestContext> url_request_context_;
 180
 181   // Handles interaction with SafeBrowsing servers. Accessed on IO thread.
 182   SafeBrowsingProtocolManager* protocol_manager_;
 183
 184   // Provides phishing and malware statistics. Accessed on IO thread.
 185   SafeBrowsingPingManager* ping_manager_;
 186
 187   // Whether the service is running. 'enabled_' is used by SafeBrowsingService
 188   // on the IO thread during normal operations.
 189   bool enabled_;
 190
 191   // Tracks existing PrefServices, and the safe browsing preference on each.
 192   // This is used to determine if any profile is currently using the safe
 193   // browsing service, and to start it up or shut it down accordingly.
 194   // Accessed on UI thread.
 195   std::map<PrefService*, PrefChangeRegistrar*> prefs_map_;
 196
 197   // Used to track creation and destruction of profiles on the UI thread.
 198   content::NotificationRegistrar prefs_registrar_;
 199
 200   // The ClientSideDetectionService is managed by the SafeBrowsingService,
 201   // since its running state and lifecycle depends on SafeBrowsingService's.
 202   // Accessed on UI thread.
 203   scoped_ptr<safe_browsing::ClientSideDetectionService> csd_service_;
 204
 205   // The DownloadProtectionService is managed by the SafeBrowsingService,
 206   // since its running state and lifecycle depends on SafeBrowsingService's.
 207   // Accessed on UI thread.
 208   scoped_ptr<safe_browsing::DownloadProtectionService> download_service_;
 209
 210   // The UI manager handles showing interstitials.  Accessed on both UI and IO
 211   // thread.
 212   scoped_refptr<SafeBrowsingUIManager> ui_manager_;
 213
 214   // The database manager handles the database and download logic.  Accessed on
 215   // both UI and IO thread.
 216   scoped_refptr<SafeBrowsingDatabaseManager> database_manager_;
 217
 218   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingService);
 219 };
 220
 221 // Factory for creating SafeBrowsingService.  Useful for tests.
 222 class SafeBrowsingServiceFactory {
 223  public:
 224   SafeBrowsingServiceFactory() { }
 225   virtual ~SafeBrowsingServiceFactory() { }
 226   virtual SafeBrowsingService* CreateSafeBrowsingService() = 0;
 227  private:
 228   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceFactory);
 229 };
 230
 231 #endif  // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_SERVICE_H_