Add "enabled" state to the ClientSideDetectionService.

chrome/browser/safe_browsing/client_side_detection_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.
 //
 // Helper class which handles communication with the SafeBrowsing backends for
 // client-side phishing detection.  This class is used to fetch the client-side
 // model and send it to all renderers.  This class is also used to send a ping
 // back to Google to verify if a particular site is really phishing or not.
 //
 // This class is not thread-safe and expects all calls to be made on the UI
@@ skipping 40 matching lines @@
 class ClientSideModel;
 
 class ClientSideDetectionService : public URLFetcher::Delegate,
                                    public NotificationObserver {
  public:
   typedef Callback2<GURL /* phishing URL */, bool /* is phishing */>::Type
       ClientReportPhishingRequestCallback;
 
   virtual ~ClientSideDetectionService();
 
-  // Creates a client-side detection service and starts fetching the client-side
-  // detection model if necessary.  The caller takes ownership of the object.
-  // This function may return NULL.
+  // Creates a client-side detection service.  The service is initially
+  // disabled, use SetEnabled() to start it.  The caller takes ownership of the
+  // object.  This function may return NULL.
   static ClientSideDetectionService* Create(
       net::URLRequestContextGetter* request_context_getter);
 
+  // Enables or disables the service.  This is usually called by the
+  // SafeBrowsingService, which tracks whether any profile uses these services
+  // at all.  Disabling cancels any pending requests; existing
+  // ClientSideDetectionHosts will have their callbacks called with "false"
+  // verdicts.  Enabling starts downloading the model after a delay.
+  void SetEnabled(bool enabled);
+
+  bool enabled() const {
+    return enabled_;
+  }
+
   // From the URLFetcher::Delegate interface.
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
                                   const net::URLRequestStatus& status,
                                   int response_code,
                                   const net::ResponseCookies& cookies,
                                   const std::string& data) OVERRIDE;
 
   // NotificationObserver overrides:
   virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
   // Sends a request to the SafeBrowsing servers with the ClientPhishingRequest.
   // The URL scheme of the |url()| in the request should be HTTP.  This method
   // takes ownership of the |verdict| as well as the |callback| and calls the
   // the callback once the result has come back from the server or if an error
-  // occurs during the fetch.  If an error occurs the phishing verdict will
-  // always be false.  The callback is always called after
-  // SendClientReportPhishingRequest() returns and on the same thread as
+  // occurs during the fetch.  If the service is disabled or an error occurs
+  // the phishing verdict will always be false.  The callback is always called
+  // after SendClientReportPhishingRequest() returns and on the same thread as
   // SendClientReportPhishingRequest() was called.  You may set |callback| to
   // NULL if you don't care about the server verdict.
   virtual void SendClientReportPhishingRequest(
       ClientPhishingRequest* verdict,
       ClientReportPhishingRequestCallback* callback);
 
   // Returns true if the given IP address string falls within a private
   // (unroutable) network block.  Pages which are hosted on these IP addresses
   // are exempt from client-side phishing detection.  This is called by the
   // ClientSideDetectionHost prior to sending the renderer a
@@ skipping 35 matching lines @@
     MODEL_INVALID_VERSION_NUMBER,
     MODEL_BAD_HASH_IDS,
     MODEL_STATUS_MAX  // Always add new values before this one.
   };
 
   // Starts fetching the model from the network or the cache.  This method
   // is called periodically to check whether a new client model is available
   // for download.
   void StartFetchModel();
 
+  // Schedules the next fetch of the model.
+  virtual void ScheduleFetchModel(int64 delay_ms);  // Virtual for testing.
+
   // This method is called when we're done fetching the model either because
   // we hit an error somewhere or because we're actually done fetch and
   // validating the model.
   virtual void EndFetchModel(ClientModelStatus status);  // Virtual for testing.
 
  private:
   friend class ClientSideDetectionServiceTest;
   FRIEND_TEST_ALL_PREFIXES(ClientSideDetectionServiceTest, FetchModelTest);
   FRIEND_TEST_ALL_PREFIXES(ClientSideDetectionServiceTest, SetBadSubnets);
+  FRIEND_TEST_ALL_PREFIXES(ClientSideDetectionServiceTest, SetEnabled);
   FRIEND_TEST_ALL_PREFIXES(ClientSideDetectionServiceTest, IsBadIpAddress);
   FRIEND_TEST_ALL_PREFIXES(ClientSideDetectionServiceTest,
                            ModelHasValidHashIds);
 
   // CacheState holds all information necessary to respond to a caller without
   // actually making a HTTP request.
   struct CacheState {
     bool is_phishing;
     base::Time timestamp;
 
@@ skipping 64 matching lines @@
   // |bad_subnets| for faster lookups.  This method is static to simplify
   // testing.
   static void SetBadSubnets(const ClientSideModel& model,
                             BadSubnetMap* bad_subnets);
 
 
   // Returns true iff all the hash id's in the client-side model point to
   // valid hashes in the model.
   static bool ModelHasValidHashIds(const ClientSideModel& model);
 
+  // Whether the service is running or not.  When the service is not running,
+  // it won't download the model nor report detected phishing URLs.
+  bool enabled_;
+
   std::string model_str_;
   scoped_ptr<ClientSideModel> model_;
   scoped_ptr<base::TimeDelta> model_max_age_;
   scoped_ptr<URLFetcher> model_fetcher_;
 
   // Map of client report phishing request to the corresponding callback that
   // has to be invoked when the request is done.
   struct ClientReportInfo;
   std::map<const URLFetcher*, ClientReportInfo*> client_phishing_reports_;
 
@@ skipping 24 matching lines @@
   // this map to speed up lookups.
   BadSubnetMap bad_subnets_;
 
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSideDetectionService);
 };
 }  // namepsace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_CLIENT_SIDE_DETECTION_SERVICE_H_