Enable V4LocalDatabaseManager based on Finch.

chrome/browser/safe_browsing/services_delegate_impl.cc

 // Copyright 2016 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/services_delegate_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/field_trial.h"
+#include "base/strings/string_util.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/chrome_switches.h"
+#include "components/safe_browsing_db/v4_local_database_manager.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace safe_browsing {
 
+namespace {
+const base::Feature kSafeBrowsingV4LocalDatabaseManagerEnabled {
+    "SafeBrowsingV4LocalDatabaseManagerEnabled",
+    base::FEATURE_DISABLED_BY_DEFAULT
+};
+}  // namespace
+
 // static
 std::unique_ptr<ServicesDelegate> ServicesDelegate::Create(
     SafeBrowsingService* safe_browsing_service) {
   return base::WrapUnique(
       new ServicesDelegateImpl(safe_browsing_service, nullptr));
 }
 
 // static
 std::unique_ptr<ServicesDelegate> ServicesDelegate::CreateForTest(
     SafeBrowsingService* safe_browsing_service,
@@ skipping 18 matching lines @@
     net::URLRequestContextGetter* context_getter) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 #if defined(SAFE_BROWSING_CSD)
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableClientSidePhishingDetection)) {
     csd_service_.reset(ClientSideDetectionService::Create(context_getter));
   }
 #endif  // defined(SAFE_BROWSING_CSD)
 }
 
-void ServicesDelegateImpl::InitializeServices() {
+void ServicesDelegateImpl::Initialize() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   download_service_.reset(
       (services_creator_ &&
        services_creator_->CanCreateDownloadProtectionService())
           ? services_creator_->CreateDownloadProtectionService()
           : CreateDownloadProtectionService());
   incident_service_.reset(
       (services_creator_ &&
        services_creator_->CanCreateIncidentReportingService())
           ? services_creator_->CreateIncidentReportingService()
           : CreateIncidentReportingService());
   resource_request_detector_.reset(
       (services_creator_ &&
        services_creator_->CanCreateResourceRequestDetector())
           ? services_creator_->CreateResourceRequestDetector()
           : CreateResourceRequestDetector());
+
+  if (IsV4LocalDatabaseManagerEnabled()) {
+    v4_local_database_manager_ = CreateV4LocalDatabaseManager();
+  }
 }
 
 void ServicesDelegateImpl::ShutdownServices() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // The IO thread is going away, so make sure the ClientSideDetectionService
   // dtor executes now since it may call the dtor of URLFetcher which relies
   // on it.
   csd_service_.reset();
 
   resource_request_detector_.reset();
@@ skipping 61 matching lines @@
 IncidentReportingService*
 ServicesDelegateImpl::CreateIncidentReportingService() {
   return new IncidentReportingService(safe_browsing_service_);
 }
 
 ResourceRequestDetector* ServicesDelegateImpl::CreateResourceRequestDetector() {
   return new ResourceRequestDetector(safe_browsing_service_->database_manager(),
                                      incident_service_->GetIncidentReceiver());
 }
 
+void ServicesDelegateImpl::StartOnIOThread(
+    net::URLRequestContextGetter* url_request_context_getter,
+    const V4ProtocolConfig& v4_config) {
+  if (v4_local_database_manager_.get()) {
+    v4_local_database_manager_->StartOnIOThread(url_request_context_getter,
+                                                v4_config);
+  }
+}
+
+void ServicesDelegateImpl::StopOnIOThread(bool shutdown) {
+  if (v4_local_database_manager_.get()) {
+    v4_local_database_manager_->StopOnIOThread(shutdown);
+  }
+}
+
+V4LocalDatabaseManager* ServicesDelegateImpl::CreateV4LocalDatabaseManager() {
+  return new V4LocalDatabaseManager();
+}
+
+bool ServicesDelegateImpl::IsV4LocalDatabaseManagerEnabled() {
+  return base::FeatureList::IsEnabled(
+      kSafeBrowsingV4LocalDatabaseManagerEnabled);
+}
+
 }  // namespace safe_browsing