Fix callsites to URLRequestContext::CopyFrom

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/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
+#include "base/threading/worker_pool.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/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/ping_manager.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing_db/database_manager.h"
 #include "components/safe_browsing_db/v4_get_hash_protocol_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"
+#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"
 
 #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)
@@ skipping 14 matching lines @@
 #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;
@@ skipping 10 matching lines @@
  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::GetMessageLoopProxyForThread(BrowserThread::IO)) {}
 
 net::URLRequestContext*
@@ skipping 11 matching lines @@
       safe_browsing_request_context_->CopyFrom(
           system_context_getter_->GetURLRequestContext());
     }
     safe_browsing_cookie_store_ =
         content::CreateCookieStore(content::CookieStoreConfig(
             CookieFilePath(),
             content::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES, nullptr,
             nullptr));
     safe_browsing_request_context_->set_cookie_store(
         safe_browsing_cookie_store_.get());
-    // The above cookie store will persist cookies, but the ChannelIDService in
-    // the system request context is ephemeral, which could lead to losing the
-    // keys that cookies are bound to. Since this is only used for safe
-    // browsing, any cookie bindings don't matter.
-    //
-    // For crbug.com/548423, the channel ID store and cookie store used for a
-    // request are being tracked to see if an ephemeral channel ID store is used
-    // with a persistent cookie store (which apart from here would be a bug).
-    // The following line tells that tracking to ignore the mismatch from this
-    // URLRequestContext.
-    safe_browsing_request_context_->set_has_known_mismatched_cookie_store();
+
+    // Set up the ChannelIDService
+    scoped_refptr<net::SQLiteChannelIDStore> channel_id_db =
+        new net::SQLiteChannelIDStore(
+            ChannelIDFilePath(),
+            BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
+                base::SequencedWorkerPool::GetSequenceToken()));
+    channel_id_service_.reset(new net::ChannelIDService(
+        new net::DefaultChannelIDStore(channel_id_db.get()),
+        base::WorkerPool::GetTaskRunner(true)));
+    safe_browsing_request_context_->set_channel_id_service(
+        channel_id_service_.get());
+
+    // 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());
+    }
   }
 
   return safe_browsing_request_context_.get();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 SafeBrowsingURLRequestContextGetter::GetNetworkTaskRunner() const {
   return network_task_runner_;
 }
 
@@ skipping 460 matching lines @@
     ping_manager()->ReportThreatDetails(report);
 }
 
 void SafeBrowsingService::ProcessResourceRequest(
     const ResourceRequestInfo& request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   services_delegate_->ProcessResourceRequest(&request);
 }
 
 }  // namespace safe_browsing