Only send the client-side phishing model to a renderer if its profile has SafeBrowsing enabled.

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"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/stl_util.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "chrome/common/net/http_return.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/common/safe_browsing/client_model.pb.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "chrome/common/safe_browsing/safebrowsing_messages.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/common/notification_service.h"
 #include "crypto/sha2.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
@@ skipping 29 matching lines @@
 ClientSideDetectionService::CacheState::CacheState(bool phish, base::Time time)
     : is_phishing(phish),
       timestamp(time) {}
 
 ClientSideDetectionService::ClientSideDetectionService(
     net::URLRequestContextGetter* request_context_getter)
     : 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());
+                 NotificationService::AllBrowserContextsAndSources());
 }
 
 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;
   }
   return service.release();
 }
 
-void ClientSideDetectionService::SetEnabled(bool enabled) {
+void ClientSideDetectionService::SetEnabledAndRefreshState(bool enabled) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  SendModelToRenderers();  // always refresh the renderer state
   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);
@@ skipping 98 matching lines @@
   DCHECK(type == content::NOTIFICATION_RENDERER_PROCESS_CREATED);
   if (!model_.get()) {
     // Model might not be ready or maybe there was an error.
     return;
   }
   SendModelToProcess(Source<RenderProcessHost>(source).ptr());
 }
 
 void ClientSideDetectionService::SendModelToProcess(
     RenderProcessHost* process) {
-  VLOG(2) << "Sending phishing model to renderer";
-  process->Send(new SafeBrowsingMsg_SetPhishingModel(model_str_));
+  // The ClientSideDetectionService is enabled if _any_ active profile has
+  // SafeBrowsing turned on.  Here we check the profile for each renderer
+  // process and only send the model to those that have SafeBrowsing enabled.
+  Profile* profile = Profile::FromBrowserContext(process->browser_context());
+  std::string model;
+  if (profile->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled)) {
+    VLOG(2) << "Sending phishing model to RenderProcessHost @" << process;
+    model = model_str_;
+  } else {
+    VLOG(2) << "Disabling client-side phishing detection for "
+            << "RenderProcessHost @" << process;
+  }
+  process->Send(new SafeBrowsingMsg_SetPhishingModel(model));
 }
 
 void ClientSideDetectionService::SendModelToRenderers() {
   for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     SendModelToProcess(i.GetCurrentValue());
   }
 }
 
 void ClientSideDetectionService::ScheduleFetchModel(int64 delay_ms) {
@@ skipping 332 matching lines @@
                                                 &whitelist_patterns);
     for (size_t j = 0; j < whitelist_patterns.size(); ++j) {
       if (whitelist_patterns[j] == canonical_url_as_pattern) {
         return true;
       }
     }
   }
   return false;
 }
 }  // namespace safe_browsing