V4Only: In V4Only mode use PVer4 for all SafeBrowsing operations

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 <stddef.h>
 
 #include <vector>
 
@@ skipping 21 matching lines @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/safe_browsing/file_type_policies.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing/common/safebrowsing_constants.h"
 #include "components/safe_browsing/common/safebrowsing_switches.h"
 #include "components/safe_browsing_db/database_manager.h"
 #include "components/safe_browsing_db/safe_browsing_prefs.h"
+#include "components/safe_browsing_db/v4_feature_list.h"
 #include "components/safe_browsing_db/v4_get_hash_protocol_manager.h"
+#include "components/safe_browsing_db/v4_local_database_manager.h"
 #include "components/user_prefs/tracked/tracked_preference_validation_delegate.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cookie_store_factory.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/resource_request_info.h"
 #include "google_apis/google_api_keys.h"
 #include "net/cookies/cookie_store.h"
 #include "net/extras/sqlite/cookie_crypto_delegate.h"
 #include "net/extras/sqlite/sqlite_channel_id_store.h"
 #include "net/http/http_network_layer.h"
@@ skipping 224 matching lines @@
 // static
 SafeBrowsingService* SafeBrowsingService::CreateSafeBrowsingService() {
   if (!factory_)
     factory_ = g_safe_browsing_service_factory_impl.Pointer();
   return factory_->CreateSafeBrowsingService();
 }
 
 SafeBrowsingService::SafeBrowsingService()
     : services_delegate_(ServicesDelegate::Create(this)),
       enabled_(false),
-      enabled_by_prefs_(false) {}
+      enabled_by_prefs_(false),
+      enabled_v4_only_(safe_browsing::V4FeatureList::IsV4OnlyEnabled()) {}
 
 SafeBrowsingService::~SafeBrowsingService() {
   // We should have already been shut down. If we're still enabled, then the
   // database isn't going to be closed properly, which could lead to corruption.
   DCHECK(!enabled_);
 }
 
 void SafeBrowsingService::Initialize() {
   // Ensure FileTypePolicies's Singleton is instantiated during startup.
   // This guarantees we'll log UMA metrics about its state.
   FileTypePolicies::GetInstance();
 
   url_request_context_getter_ = new SafeBrowsingURLRequestContextGetter(
       g_browser_process->system_request_context());
 
   ui_manager_ = CreateUIManager();
 
-  database_manager_ = CreateDatabaseManager();
+  if (!enabled_v4_only_) {
+    database_manager_ = CreateDatabaseManager();
+  }
 
   services_delegate_->Initialize();
   services_delegate_->InitializeCsdService(url_request_context_getter_.get());
 
   // 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();
@@ skipping 42 matching lines @@
   // has to be released now rather than in the destructor because it can only
   // be deleted on the IOThread, and the SafeBrowsingService outlives the IO
   // thread.
   url_request_context_getter_ = nullptr;
 }
 
 bool SafeBrowsingService::DownloadBinHashNeeded() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
 #if defined(FULL_SAFE_BROWSING)
-  return database_manager_->IsDownloadProtectionEnabled() ||
+  return database_manager()->IsDownloadProtectionEnabled() ||
          (download_protection_service() &&
           download_protection_service()->enabled());
 #else
   return false;
 #endif
 }
 
 net::URLRequestContextGetter* SafeBrowsingService::url_request_context() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return url_request_context_getter_.get();
 }
 
 const scoped_refptr<SafeBrowsingUIManager>&
 SafeBrowsingService::ui_manager() const {
   return ui_manager_;
 }
 
 const scoped_refptr<SafeBrowsingDatabaseManager>&
 SafeBrowsingService::database_manager() const {
-  return database_manager_;
+  return enabled_v4_only_ ? v4_local_database_manager() : database_manager_;
 }
 
 SafeBrowsingProtocolManager* SafeBrowsingService::protocol_manager() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 #if defined(SAFE_BROWSING_DB_LOCAL)
+  DCHECK(!enabled_v4_only_);
   return protocol_manager_.get();
 #else
   return nullptr;
 #endif
 }
 
 SafeBrowsingPingManager* SafeBrowsingService::ping_manager() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return ping_manager_.get();
 }
 
-const scoped_refptr<V4LocalDatabaseManager>&
+const scoped_refptr<SafeBrowsingDatabaseManager>&
 SafeBrowsingService::v4_local_database_manager() const {
   return services_delegate_->v4_local_database_manager();
 }
 
 std::unique_ptr<TrackedPreferenceValidationDelegate>
 SafeBrowsingService::CreatePreferenceValidationDelegate(
     Profile* profile) const {
   return services_delegate_->CreatePreferenceValidationDelegate(profile);
 }
 
@@ skipping 37 matching lines @@
   return new RemoteSafeBrowsingDatabaseManager();
 #else
   return NULL;
 #endif
 }
 
 void SafeBrowsingService::RegisterAllDelayedAnalysis() {
 #if defined(FULL_SAFE_BROWSING)
   RegisterBinaryIntegrityAnalysis();
   RegisterBlacklistLoadAnalysis();
-  RegisterModuleLoadAnalysis(database_manager_);
+  RegisterModuleLoadAnalysis(database_manager());
   RegisterVariationsSeedSignatureAnalysis();
 #endif
 }
 
 SafeBrowsingProtocolConfig SafeBrowsingService::GetProtocolConfig() const {
   SafeBrowsingProtocolConfig config;
   config.client_name = GetProtocolConfigClientName();
 
   base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
   config.disable_auto_update =
@@ skipping 39 matching lines @@
 #endif  // defined(OS_WIN)
 
   return client_name;
 }
 
 // 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)
+  DCHECK(!enabled_v4_only_);
   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();
   V4ProtocolConfig v4_config = GetV4ProtocolConfig();
 
   services_delegate_->StartOnIOThread(url_request_context_getter, v4_config);
 
 #if defined(SAFE_BROWSING_DB_LOCAL) || defined(SAFE_BROWSING_DB_REMOTE)
-  DCHECK(database_manager_.get());
-  database_manager_->StartOnIOThread(url_request_context_getter, v4_config);
+  if (!enabled_v4_only_) {
+    DCHECK(database_manager_.get());
+    database_manager_->StartOnIOThread(url_request_context_getter, v4_config);
+  }
 #endif
 
 #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();
+  if (!enabled_v4_only_) {
+    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) || defined(SAFE_BROWSING_DB_REMOTE)
-  database_manager_->StopOnIOThread(shutdown);
+  if (!enabled_v4_only_) {
+    database_manager_->StopOnIOThread(shutdown);
+  }
 #endif
   ui_manager_->StopOnIOThread(shutdown);
 
   services_delegate_->StopOnIOThread(shutdown);
 
   if (enabled_) {
     enabled_ = false;
 
 #if defined(SAFE_BROWSING_DB_LOCAL)
     // This cancels all in-flight GetHash requests. Note that
@@ skipping 127 matching lines @@
     ping_manager()->ReportThreatDetails(report);
 }
 
 void SafeBrowsingService::ProcessResourceRequest(
     const ResourceRequestInfo& request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   services_delegate_->ProcessResourceRequest(&request);
 }
 
 }  // namespace safe_browsing