Split to SafeBrowsingDatabaseManager into Local* and Remote*.

chrome/browser/safe_browsing/safe_browsing_service.cc

 // Copyright (c) 2012 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/safe_browsing_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 33 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/extras/sqlite/cookie_crypto_delegate.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(OS_WIN)
 #include "chrome/installer/util/browser_distribution.h"
 #endif
 
+#if defined(SAFE_BROWSING_DB_LOCAL)
+#include "chrome/browser/safe_browsing/local_database_manager.h"
+#elif defined(SAFE_BROWSING_DB_REMOTE)
+#include "chrome/browser/safe_browsing/remote_database_manager.h"
+#endif
+
 #if defined(FULL_SAFE_BROWSING)
 #include "chrome/browser/safe_browsing/incident_reporting/binary_integrity_analyzer.h"
 #include "chrome/browser/safe_browsing/incident_reporting/blacklist_load_analyzer.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident_reporting_service.h"
 #include "chrome/browser/safe_browsing/incident_reporting/off_domain_inclusion_detector.h"
 #include "chrome/browser/safe_browsing/incident_reporting/resource_request_detector.h"
 #include "chrome/browser/safe_browsing/incident_reporting/variations_seed_signature_analyzer.h"
 #endif
 
 using content::BrowserThread;
@@ skipping 172 matching lines @@
 
   if (IsIncidentReportingServiceEnabled()) {
     incident_service_.reset(new safe_browsing::IncidentReportingService(
         this, url_request_context_getter_));
     resource_request_detector_.reset(new safe_browsing::ResourceRequestDetector(
         incident_service_->GetIncidentReceiver()));
   }
 
   off_domain_inclusion_detector_.reset(
       new safe_browsing::OffDomainInclusionDetector(database_manager_));
-#endif  // !defined(OS_ANDROID)
+#endif  // !defined(FULL_SAFE_BROWSING)
 
   // Track the safe browsing preference of existing profiles.
   // The SafeBrowsingService will be started if any existing profile has the
   // preference enabled. It will also listen for updates to the preferences.
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   if (profile_manager) {
     std::vector<Profile*> profiles = profile_manager->GetLoadedProfiles();
     for (size_t i = 0; i < profiles.size(); ++i) {
       if (profiles[i]->IsOffTheRecord())
         continue;
@@ skipping 115 matching lines @@
     resource_request_detector_->OnResourceRequest(request);
 #endif
 }
 
 SafeBrowsingUIManager* SafeBrowsingService::CreateUIManager() {
   return new SafeBrowsingUIManager(this);
 }
 
 SafeBrowsingDatabaseManager* SafeBrowsingService::CreateDatabaseManager() {
 #if defined(SAFE_BROWSING_DB_LOCAL)
-  return new SafeBrowsingDatabaseManager(this);
+  return new LocalSafeBrowsingDatabaseManager(this);
+#elif defined(SAFE_BROWSING_DB_REMOTE)
+  return new RemoteSafeBrowsingDatabaseManager();
 #else
   return NULL;
 #endif
 }
 
 void SafeBrowsingService::RegisterAllDelayedAnalysis() {
 #if defined(FULL_SAFE_BROWSING)
   safe_browsing::RegisterBinaryIntegrityAnalysis();
   safe_browsing::RegisterBlacklistLoadAnalysis();
   safe_browsing::RegisterVariationsSeedSignatureAnalysis();
@@ skipping 66 matching lines @@
       cmdline->HasSwitch(switches::kSbDisableAutoUpdate) ||
       cmdline->HasSwitch(switches::kDisableBackgroundNetworking);
   config.url_prefix = kSbDefaultURLPrefix;
   config.backup_connect_error_url_prefix = kSbBackupConnectErrorURLPrefix;
   config.backup_http_error_url_prefix = kSbBackupHttpErrorURLPrefix;
   config.backup_network_error_url_prefix = kSbBackupNetworkErrorURLPrefix;
 
   return config;
 }
 
+// Any tests that create a DatabaseManager that isn't derived from
+// LocalSafeBrowsingDatabaseManager should override this to return NULL.
+SafeBrowsingProtocolManagerDelegate*
+SafeBrowsingService::GetProtocolManagerDelegate() {
+#if defined(SAFE_BROWSING_DB_LOCAL)
+  return static_cast<LocalSafeBrowsingDatabaseManager*>(
+      database_manager_.get());
+#else
+  NOTREACHED();
+  return NULL;
+#endif
+}
+
 void SafeBrowsingService::StartOnIOThread(
     net::URLRequestContextGetter* url_request_context_getter) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (enabled_)
     return;
   enabled_ = true;
 
   SafeBrowsingProtocolConfig config = GetProtocolConfig();
 
-#if defined(SAFE_BROWSING_DB_LOCAL)
+#if defined(SAFE_BROWSING_DB_LOCAL) || defined(SAFE_BROWSING_DB_REMOTE)
   DCHECK(database_manager_.get());
   database_manager_->StartOnIOThread();
+#endif
 
-  DCHECK(!protocol_manager_);
-  protocol_manager_ = SafeBrowsingProtocolManager::Create(
-      database_manager_.get(), url_request_context_getter, config);
-  protocol_manager_->Initialize();
+#if defined(SAFE_BROWSING_DB_LOCAL)
+  SafeBrowsingProtocolManagerDelegate* protocol_manager_delegate =
+      GetProtocolManagerDelegate();
+  if (protocol_manager_delegate) {
+    protocol_manager_ = SafeBrowsingProtocolManager::Create(
+        protocol_manager_delegate, url_request_context_getter, config);
+    protocol_manager_->Initialize();
+  }
 #endif
 
   DCHECK(!ping_manager_);
   ping_manager_ = SafeBrowsingPingManager::Create(
       url_request_context_getter, config);
 }
 
 void SafeBrowsingService::StopOnIOThread(bool shutdown) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-#if defined(SAFE_BROWSING_DB_LOCAL)
+#if defined(SAFE_BROWSING_DB_LOCAL) || defined(SAFE_BROWSING_DB_REMOTE)
   database_manager_->StopOnIOThread(shutdown);
 #endif
   ui_manager_->StopOnIOThread(shutdown);
 
   if (enabled_) {
     enabled_ = false;
 
 #if defined(SAFE_BROWSING_DB_LOCAL)
     // This cancels all in-flight GetHash requests. Note that database_manager_
     // relies on the protocol_manager_ so if the latter is destroyed, the
     // former must be stopped.
-    delete protocol_manager_;
-    protocol_manager_ = NULL;
+    if (protocol_manager_) {
+      delete protocol_manager_;
+      protocol_manager_ = NULL;
+    }
 #endif
     delete ping_manager_;
     ping_manager_ = NULL;
   }
 }
 
 void SafeBrowsingService::Start() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BrowserThread::PostTask(
@@ skipping 68 matching lines @@
   else
     Stop(false);
 
 #if defined(FULL_SAFE_BROWSING)
   if (csd_service_)
     csd_service_->SetEnabledAndRefreshState(enable);
   if (download_service_)
     download_service_->SetEnabled(enable);
 #endif
 }