Componentize safe_browsing: factor out SafeBrowsingURLRequestContextGetter.

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
-#include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
-#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/chrome_password_protection_service.h"
 #include "chrome/browser/safe_browsing/ping_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_navigation_observer_manager.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #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/browser/safe_browsing_url_request_context_getter.h"
 #include "components/safe_browsing/common/safebrowsing_constants.h"
 #include "components/safe_browsing/common/safebrowsing_switches.h"
 #include "components/safe_browsing/triggers/trigger_manager.h"
 #include "components/safe_browsing_db/database_manager.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 "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"
-#include "net/http/http_transaction_factory.h"
-#include "net/ssl/channel_id_service.h"
-#include "net/ssl/default_channel_id_store.h"
-#include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"

[Jialiu Lin, 2017/05/24 21:42:31]

nit: Do you still need this include?

[timvolodine, 2017/05/25 13:01:04]

The URLRequestContextGetter is still used in 2 places in this file..

 #include "services/preferences/public/interfaces/tracked_preference_validation_delegate.mojom.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 "components/safe_browsing_db/remote_database_manager.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/safe_browsing/incident_reporting/variations_seed_signature_analyzer.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #endif
 
 using content::BrowserThread;
 
 namespace safe_browsing {
 
 namespace {
 
-// Filename suffix for the cookie database.
-const base::FilePath::CharType kCookiesFile[] = FILE_PATH_LITERAL(" Cookies");
-const base::FilePath::CharType kChannelIDFile[] =
-    FILE_PATH_LITERAL(" Channel IDs");
-
 // The default URL prefix where browser fetches chunk updates, hashes,
 // and reports safe browsing hits and malware details.
 const char kSbDefaultURLPrefix[] =
     "https://safebrowsing.google.com/safebrowsing";
 
 // The backup URL prefix used when there are issues establishing a connection
 // with the server at the primary URL.
 const char kSbBackupConnectErrorURLPrefix[] =
     "https://alt1-safebrowsing.google.com/safebrowsing";
 
 // The backup URL prefix used when there are HTTP-specific issues with the
 // server at the primary URL.
 const char kSbBackupHttpErrorURLPrefix[] =
     "https://alt2-safebrowsing.google.com/safebrowsing";
 
 // The backup URL prefix used when there are local network specific issues.
 const char kSbBackupNetworkErrorURLPrefix[] =
     "https://alt3-safebrowsing.google.com/safebrowsing";
 
-base::FilePath CookieFilePath() {
-  return base::FilePath(
-      SafeBrowsingService::GetBaseFilename().value() + kCookiesFile);
-}
-
-base::FilePath ChannelIDFilePath() {
-  return base::FilePath(SafeBrowsingService::GetBaseFilename().value() +
-                        kChannelIDFile);
-}
-
 }  // namespace
 
-class SafeBrowsingURLRequestContextGetter
-    : public net::URLRequestContextGetter {
- public:
-  explicit SafeBrowsingURLRequestContextGetter(
-      scoped_refptr<net::URLRequestContextGetter> system_context_getter);
-
-  // Implementation for net::UrlRequestContextGetter.
-  net::URLRequestContext* GetURLRequestContext() override;
-  scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()
-      const override;
-
-  // Shuts down any pending requests using the getter, and sets |shut_down_| to
-  // true.
-  void ServiceShuttingDown();
-
-  // Disables QUIC. This should not be necessary anymore when
-  // http://crbug.com/678653 is implemented.
-  void DisableQuicOnIOThread();
-
- protected:
-  ~SafeBrowsingURLRequestContextGetter() override;
-
- private:
-  bool shut_down_;
-
-  scoped_refptr<net::URLRequestContextGetter> system_context_getter_;
-
-  std::unique_ptr<net::CookieStore> safe_browsing_cookie_store_;
-
-  std::unique_ptr<net::URLRequestContext> safe_browsing_request_context_;
-
-  scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
-
-  std::unique_ptr<net::ChannelIDService> channel_id_service_;
-  std::unique_ptr<net::HttpNetworkSession> http_network_session_;
-  std::unique_ptr<net::HttpTransactionFactory> http_transaction_factory_;
-};
-
-SafeBrowsingURLRequestContextGetter::SafeBrowsingURLRequestContextGetter(
-    scoped_refptr<net::URLRequestContextGetter> system_context_getter)
-    : shut_down_(false),
-      system_context_getter_(system_context_getter),
-      network_task_runner_(
-          BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)) {}
-
-net::URLRequestContext*
-SafeBrowsingURLRequestContextGetter::GetURLRequestContext() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  // Check if the service has been shut down.
-  if (shut_down_)
-    return nullptr;
-
-  if (!safe_browsing_request_context_) {
-    safe_browsing_request_context_.reset(new net::URLRequestContext());
-    // May be NULL in unit tests.
-    if (system_context_getter_) {
-      safe_browsing_request_context_->CopyFrom(
-          system_context_getter_->GetURLRequestContext());
-    }
-    scoped_refptr<base::SequencedTaskRunner> background_task_runner =
-        base::CreateSequencedTaskRunnerWithTraits(
-            {base::MayBlock(), base::TaskPriority::BACKGROUND,
-             base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
-    // Set up the ChannelIDService
-    scoped_refptr<net::SQLiteChannelIDStore> channel_id_db =
-        new net::SQLiteChannelIDStore(ChannelIDFilePath(),
-                                      background_task_runner);
-    channel_id_service_.reset(new net::ChannelIDService(
-        new net::DefaultChannelIDStore(channel_id_db.get())));
-
-    // Set up the CookieStore
-    content::CookieStoreConfig cookie_config(
-        CookieFilePath(), content::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES,
-        nullptr, nullptr);
-    cookie_config.channel_id_service = channel_id_service_.get();
-    cookie_config.background_task_runner = background_task_runner;
-    safe_browsing_cookie_store_ = content::CreateCookieStore(cookie_config);
-    safe_browsing_request_context_->set_cookie_store(
-        safe_browsing_cookie_store_.get());
-
-    safe_browsing_request_context_->set_channel_id_service(
-        channel_id_service_.get());
-    safe_browsing_cookie_store_->SetChannelIDServiceID(
-        channel_id_service_->GetUniqueID());
-
-    // Rebuild the HttpNetworkSession and the HttpTransactionFactory to use the
-    // new ChannelIDService.
-    if (safe_browsing_request_context_->http_transaction_factory() &&
-        safe_browsing_request_context_->http_transaction_factory()
-            ->GetSession()) {
-      net::HttpNetworkSession::Params safe_browsing_params =
-          safe_browsing_request_context_->http_transaction_factory()
-              ->GetSession()
-              ->params();
-      safe_browsing_params.channel_id_service = channel_id_service_.get();
-      http_network_session_.reset(
-          new net::HttpNetworkSession(safe_browsing_params));
-      http_transaction_factory_.reset(
-          new net::HttpNetworkLayer(http_network_session_.get()));
-      safe_browsing_request_context_->set_http_transaction_factory(
-          http_transaction_factory_.get());
-    }
-    safe_browsing_request_context_->set_name("safe_browsing");
-  }
-
-  return safe_browsing_request_context_.get();
-}
-
-scoped_refptr<base::SingleThreadTaskRunner>
-SafeBrowsingURLRequestContextGetter::GetNetworkTaskRunner() const {
-  return network_task_runner_;
-}
-
-void SafeBrowsingURLRequestContextGetter::ServiceShuttingDown() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  shut_down_ = true;
-  URLRequestContextGetter::NotifyContextShuttingDown();
-  safe_browsing_request_context_.reset();
-}
-
-void SafeBrowsingURLRequestContextGetter::DisableQuicOnIOThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (http_network_session_)
-    http_network_session_->DisableQuic();
-}
-
-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(V4FeatureList::GetV4UsageStatus());
   }
 
  private:
   friend struct base::LazyInstanceTraitsBase<SafeBrowsingServiceFactoryImpl>;
 
   SafeBrowsingServiceFactoryImpl() { }
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceFactoryImpl);
 };
 
 static base::LazyInstance<SafeBrowsingServiceFactoryImpl>::Leaky
     g_safe_browsing_service_factory_impl = LAZY_INSTANCE_INITIALIZER;
 
 // static
 base::FilePath SafeBrowsingService::GetCookieFilePathForTesting() {
-  return CookieFilePath();
+  return base::FilePath(SafeBrowsingService::GetBaseFilename().value() +
+                        safe_browsing::kCookiesFile);
 }
 
 // static
 base::FilePath SafeBrowsingService::GetBaseFilename() {
   base::FilePath path;
   bool result = PathService::Get(chrome::DIR_USER_DATA, &path);
   DCHECK(result);
   return path.Append(safe_browsing::kSafeBrowsingBaseFilename);
 }
 
@@ skipping 20 matching lines @@
   // 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();
 
+  base::FilePath user_data_dir;
+  bool result = PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
+  DCHECK(result);
+
   url_request_context_getter_ = new SafeBrowsingURLRequestContextGetter(
-      g_browser_process->system_request_context());
+      g_browser_process->system_request_context(), user_data_dir);
 
   ui_manager_ = CreateUIManager();
 
   if (!use_v4_only_) {
     database_manager_ = CreateDatabaseManager();
   }
 
   navigation_observer_manager_ = new SafeBrowsingNavigationObserverManager();
 
   services_delegate_->Initialize(v4_enabled_);
@@ skipping 452 matching lines @@
   auto it = password_protection_service_map_.find(profile);
   if (it != password_protection_service_map_.end())
     password_protection_service_map_.erase(it);
 }
 
 void SafeBrowsingService::CreateTriggerManager() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   trigger_manager_ = base::MakeUnique<TriggerManager>(ui_manager_.get());
 }
 }  // namespace safe_browsing