Browser tests for using the new SafeBrowsing protocol (v4)

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 239 matching lines @@
 SafeBrowsingURLRequestContextGetter::~SafeBrowsingURLRequestContextGetter() {}
 
 // static
 SafeBrowsingServiceFactory* SafeBrowsingService::factory_ = NULL;
 
 // The default SafeBrowsingServiceFactory.  Global, made a singleton so we
 // don't leak it.
 class SafeBrowsingServiceFactoryImpl : public SafeBrowsingServiceFactory {
  public:
   SafeBrowsingService* CreateSafeBrowsingService() override {
-    return new SafeBrowsingService();
+    return new SafeBrowsingService(V4FeatureList::GetV4UsageStatus());
   }
 
  private:
   friend struct base::DefaultLazyInstanceTraits<SafeBrowsingServiceFactoryImpl>;
 
   SafeBrowsingServiceFactoryImpl() { }
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceFactoryImpl);
 };
 
@@ skipping 14 matching lines @@
 }
 
 
 // static
 SafeBrowsingService* SafeBrowsingService::CreateSafeBrowsingService() {
   if (!factory_)
     factory_ = g_safe_browsing_service_factory_impl.Pointer();
   return factory_->CreateSafeBrowsingService();
 }
 
-SafeBrowsingService::SafeBrowsingService()
+SafeBrowsingService::SafeBrowsingService(
+    V4FeatureList::V4UsageStatus v4_usage_status)
     : services_delegate_(ServicesDelegate::Create(this)),
       estimated_extended_reporting_by_prefs_(SBER_LEVEL_OFF),
       enabled_(false),
       enabled_by_prefs_(false),
-      enabled_v4_only_(safe_browsing::V4FeatureList::IsV4OnlyEnabled()) {}
+      use_v4_only_(v4_usage_status == V4FeatureList::V4UsageStatus::V4_ONLY),
+      v4_enabled_(v4_usage_status ==
+                      V4FeatureList::V4UsageStatus::V4_INSTANTIATED ||
+                  v4_usage_status == V4FeatureList::V4UsageStatus::V4_ONLY) {}
 
 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();
 
-  if (!enabled_v4_only_) {
+  if (!use_v4_only_) {
     database_manager_ = CreateDatabaseManager();
   }
 
   if (base::FeatureList::IsEnabled(
     SafeBrowsingNavigationObserverManager::kDownloadAttribution)) {
     navigation_observer_manager_ = new SafeBrowsingNavigationObserverManager();
   }
 
-  services_delegate_->Initialize();
+  services_delegate_->Initialize(v4_enabled_);
   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();
     // TODO(felt): I believe this for-loop is dead code. Confirm this and
     // remove in a future CL. See https://codereview.chromium.org/1341533002/
@@ skipping 70 matching lines @@
   url_request_context_getter_->DisableQuicOnIOThread();
 }
 
 const scoped_refptr<SafeBrowsingUIManager>&
 SafeBrowsingService::ui_manager() const {
   return ui_manager_;
 }
 
 const scoped_refptr<SafeBrowsingDatabaseManager>&
 SafeBrowsingService::database_manager() const {
-  return enabled_v4_only_ ? v4_local_database_manager() : database_manager_;
+  return use_v4_only_ ? v4_local_database_manager() : database_manager_;
 }
 
 scoped_refptr<SafeBrowsingNavigationObserverManager>
 SafeBrowsingService::navigation_observer_manager() {
   return navigation_observer_manager_;
 }
 
 SafeBrowsingProtocolManager* SafeBrowsingService::protocol_manager() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 #if defined(SAFE_BROWSING_DB_LOCAL)
-  DCHECK(!enabled_v4_only_);
+  DCHECK(!use_v4_only_);
   return protocol_manager_.get();
 #else
   return nullptr;
 #endif
 }
 
 SafeBrowsingPingManager* SafeBrowsingService::ping_manager() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return ping_manager_.get();
 }
@@ skipping 109 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_);
+  DCHECK(!use_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)
-  if (!enabled_v4_only_) {
+  if (!use_v4_only_) {
     DCHECK(database_manager_.get());
     database_manager_->StartOnIOThread(url_request_context_getter, v4_config);
   }
 #endif
 
 #if defined(SAFE_BROWSING_DB_LOCAL)
-  if (!enabled_v4_only_) {
+  if (!use_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)
-  if (!enabled_v4_only_) {
+  if (!use_v4_only_) {
     database_manager_->StopOnIOThread(shutdown);
   }
 #endif
   ui_manager_->StopOnIOThread(shutdown);
 
   services_delegate_->StopOnIOThread(shutdown);
 
   if (enabled_) {
     enabled_ = false;
 
@@ skipping 140 matching lines @@
     ping_manager()->ReportThreatDetails(report);
 }
 
 void SafeBrowsingService::ProcessResourceRequest(
     const ResourceRequestInfo& request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   services_delegate_->ProcessResourceRequest(&request);
 }
 
 }  // namespace safe_browsing