Add "enabled" state to the ClientSideDetectionService.

chrome/browser/safe_browsing/client_side_detection_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/client_side_detection_service.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 45 matching lines @@
   scoped_ptr<ClientReportPhishingRequestCallback> callback;
   GURL phishing_url;
 };
 
 ClientSideDetectionService::CacheState::CacheState(bool phish, base::Time time)
     : is_phishing(phish),
       timestamp(time) {}
 
 ClientSideDetectionService::ClientSideDetectionService(
     net::URLRequestContextGetter* request_context_getter)
-    : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+    : enabled_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       request_context_getter_(request_context_getter) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  NotificationService::AllSources());
 }
 
 ClientSideDetectionService::~ClientSideDetectionService() {
   method_factory_.RevokeAll();
   STLDeleteContainerPairPointers(client_phishing_reports_.begin(),
                                  client_phishing_reports_.end());
   client_phishing_reports_.clear();
 }
 
 // static
 ClientSideDetectionService* ClientSideDetectionService::Create(
     net::URLRequestContextGetter* request_context_getter) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_ptr<ClientSideDetectionService> service(
       new ClientSideDetectionService(request_context_getter));
   if (!service->InitializePrivateNetworks()) {
     UMA_HISTOGRAM_COUNTS("SBClientPhishing.InitPrivateNetworksFailed", 1);
     return NULL;
   }
-  // We fetch the model at every browser restart.  In a lot of cases the model
-  // will be in the cache so it won't actually be fetched from the network.
-  // We delay the first model fetch to avoid slowing down browser startup.
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      service->method_factory_.NewRunnableMethod(
-          &ClientSideDetectionService::StartFetchModel),
-      kInitialClientModelFetchDelayMs);
   return service.release();
 }
 
+void ClientSideDetectionService::SetEnabled(bool enabled) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (enabled == enabled_)
+    return;
+  enabled_ = enabled;
+  if (enabled_) {
+    // Refresh the model when the service is enabled.  This can happen when the
+    // preference is toggled, or early during startup if the preference is
+    // already enabled. In a lot of cases the model will be in the cache so it
+    // won't actually be fetched from the network.
+    // We delay the first model fetch to avoid slowing down browser startup.
+    ScheduleFetchModel(kInitialClientModelFetchDelayMs);
+  } else {
+    // Cancel pending requests.
+    model_fetcher_.reset();
+    // Invoke pending callbacks with a false verdict.
+    for (std::map<const URLFetcher*, ClientReportInfo*>::iterator it =
+             client_phishing_reports_.begin();
+         it != client_phishing_reports_.end(); ++it) {
+      ClientReportInfo* info = it->second;
+      if (info->callback.get())
+        info->callback->Run(info->phishing_url, false);
+    }
+    STLDeleteContainerPairPointers(client_phishing_reports_.begin(),
+                                   client_phishing_reports_.end());
+    client_phishing_reports_.clear();
+    cache_.clear();
+  }
+}
+
 void ClientSideDetectionService::SendClientReportPhishingRequest(
     ClientPhishingRequest* verdict,
     ClientReportPhishingRequestCallback* callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   MessageLoop::current()->PostTask(
       FROM_HERE,
       method_factory_.NewRunnableMethod(
           &ClientSideDetectionService::StartClientReportPhishingRequest,
           verdict, callback));
 }
@@ skipping 81 matching lines @@
   process->Send(new SafeBrowsingMsg_SetPhishingModel(model_str_));
 }
 
 void ClientSideDetectionService::SendModelToRenderers() {
   for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     SendModelToProcess(i.GetCurrentValue());
   }
 }
 
+void ClientSideDetectionService::ScheduleFetchModel(int64 delay_ms) {
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      method_factory_.NewRunnableMethod(
+          &ClientSideDetectionService::StartFetchModel),
+      delay_ms);
+}
+
 void ClientSideDetectionService::StartFetchModel() {
-  // Start fetching the model either from the cache or possibly from the
-  // network if the model isn't in the cache.
-  model_fetcher_.reset(URLFetcher::Create(0 /* ID is not used */,
-                                          GURL(kClientModelUrl),
-                                          URLFetcher::GET,
-                                          this));
-  model_fetcher_->set_request_context(request_context_getter_.get());
-  model_fetcher_->Start();
+  if (enabled_) {
+    // Start fetching the model either from the cache or possibly from the
+    // network if the model isn't in the cache.
+    model_fetcher_.reset(URLFetcher::Create(0 /* ID is not used */,
+                                            GURL(kClientModelUrl),
+                                            URLFetcher::GET,
+                                            this));
+    model_fetcher_->set_request_context(request_context_getter_.get());
+    model_fetcher_->Start();
+  }
 }
 
 void ClientSideDetectionService::EndFetchModel(ClientModelStatus status) {
   UMA_HISTOGRAM_ENUMERATION("SBClientPhishing.ClientModelStatus",
                             status,
                             MODEL_STATUS_MAX);
   if (status == MODEL_SUCCESS) {
     SetBadSubnets(*model_, &bad_subnets_);
     SendModelToRenderers();
   }
   int delay_ms = kClientModelFetchIntervalMs;
   // If the most recently fetched model had a valid max-age and the model was
   // valid we're scheduling the next model update for after the max-age expired.
   if (model_max_age_.get() &&
       (status == MODEL_SUCCESS || status == MODEL_NOT_CHANGED)) {
     // We're adding 60s of additional delay to make sure we're past
     // the model's age.
     *model_max_age_ += base::TimeDelta::FromMinutes(1);
     delay_ms = model_max_age_->InMilliseconds();
   }
   model_max_age_.reset();
 
   // Schedule the next model reload.
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &ClientSideDetectionService::StartFetchModel),
-      delay_ms);
+  ScheduleFetchModel(delay_ms);
 }
 
 void ClientSideDetectionService::StartClientReportPhishingRequest(
     ClientPhishingRequest* verdict,
     ClientReportPhishingRequestCallback* callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_ptr<ClientPhishingRequest> request(verdict);
   scoped_ptr<ClientReportPhishingRequestCallback> cb(callback);
 
+  if (!enabled_) {
+    if (cb.get())
+      cb->Run(GURL(request->url()), false);
+    return;
+  }
+
   std::string request_data;
   if (!request->SerializeToString(&request_data)) {
     UMA_HISTOGRAM_COUNTS("SBClientPhishing.RequestNotSerialized", 1);
     VLOG(1) << "Unable to serialize the CSD request. Proto file changed?";
     if (cb.get()) {
       cb->Run(GURL(request->url()), false);
     }
     return;
   }
 
@@ skipping 223 matching lines @@
     }
   }
   for (int i = 0; i < model.page_word_size(); ++i) {
     if (model.page_word(i) < 0 || model.page_word(i) > max_index) {
       return false;
     }
   }
   return true;
 }
 }  // namespace safe_browsing