Add the ability for DevTools to wrap network transactions.

chrome/browser/profiles/profile_io_data.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/profiles/profile_io_data.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/content_settings_provider.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
+#include "chrome/browser/devtools/devtools_network_controller.h"
+#include "chrome/browser/devtools/devtools_network_transaction_factory.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/extensions/extension_resource_protocols.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/media/media_device_id_salt.h"
 #include "chrome/browser/net/about_protocol_handler.h"
 #include "chrome/browser/net/chrome_fraudulent_certificate_reporter.h"
 #include "chrome/browser/net/chrome_http_user_agent_settings.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
@@ skipping 692 matching lines @@
 
 HostContentSettingsMap* ProfileIOData::GetHostContentSettingsMap() const {
   DCHECK(initialized_);
   return host_content_settings_map_.get();
 }
 
 ResourceContext::SaltCallback ProfileIOData::GetMediaDeviceIDSalt() const {
   return base::Bind(&MediaDeviceIDSalt::GetSalt, media_device_id_salt_);
 }
 
+void ProfileIOData::SetNetworkState(
+    const std::string& client_id, bool offline) const {
+  DCHECK(network_controller_);
+  network_controller_->SetNetworkState(client_id, offline);
+}
+
 bool ProfileIOData::IsOffTheRecord() const {
   return profile_type() == Profile::INCOGNITO_PROFILE
       || profile_type() == Profile::GUEST_PROFILE;
 }
 
 void ProfileIOData::InitializeMetricsEnabledStateOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 #if defined(OS_CHROMEOS)
   // Just fetch the value from ChromeOS' settings while we're on the UI thread.
   // TODO(stevet): For now, this value is only set on profile initialization.
@@ skipping 132 matching lines @@
   ContentSetting setting = content_settings->GetContentSetting(
       origin, origin, type, NO_RESOURCE_IDENTIFIER);
   return setting == CONTENT_SETTING_ALLOW;
 }
 
 ResourceContext::SaltCallback
 ProfileIOData::ResourceContext::GetMediaDeviceIDSalt() {
   return io_data_->GetMediaDeviceIDSalt();
 }
 
+void ProfileIOData::ResourceContext::SetNetworkState(
+    const std::string& client_id,
+    bool offline) {
+  io_data_->SetNetworkState(client_id, offline);
+}
+
 // static
 std::string ProfileIOData::GetSSLSessionCacheShard() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // The SSL session cache is partitioned by setting a string. This returns a
   // unique string to partition the SSL session cache. Each time we create a
   // new profile, we'll get a fresh SSL session cache which is separate from
   // the other profiles.
   static unsigned ssl_session_cache_instance = 0;
   return base::StringPrintf("profile/%u", ssl_session_cache_instance++);
 }
@@ skipping 228 matching lines @@
 
 void ProfileIOData::set_server_bound_cert_service(
     net::ServerBoundCertService* server_bound_cert_service) const {
   server_bound_cert_service_.reset(server_bound_cert_service);
 }
 
 void ProfileIOData::DestroyResourceContext() {
   resource_context_.reset();
 }
 
-void ProfileIOData::PopulateNetworkSessionParams(
+scoped_ptr<net::HttpCache> ProfileIOData::CreateMainHttpFactory(
     const ProfileParams* profile_params,
-    net::HttpNetworkSession::Params* params) const {
-
+    net::HttpCache::BackendFactory* main_backend) const {
+  net::HttpNetworkSession::Params params;
   ChromeURLRequestContext* context = main_request_context();
 
   IOThread* const io_thread = profile_params->io_thread;
 
-  io_thread->InitializeNetworkSessionParams(params);
+  io_thread->InitializeNetworkSessionParams(&params);
 
-  params->host_resolver = context->host_resolver();
-  params->cert_verifier = context->cert_verifier();
-  params->server_bound_cert_service = context->server_bound_cert_service();
-  params->transport_security_state = context->transport_security_state();
-  params->cert_transparency_verifier = context->cert_transparency_verifier();
-  params->proxy_service = context->proxy_service();
-  params->ssl_session_cache_shard = GetSSLSessionCacheShard();
-  params->ssl_config_service = context->ssl_config_service();
-  params->http_auth_handler_factory = context->http_auth_handler_factory();
-  params->network_delegate = network_delegate();
-  params->http_server_properties = context->http_server_properties();
-  params->net_log = context->net_log();
+  params.host_resolver = context->host_resolver();
+  params.cert_verifier = context->cert_verifier();
+  params.server_bound_cert_service = context->server_bound_cert_service();
+  params.transport_security_state = context->transport_security_state();
+  params.cert_transparency_verifier = context->cert_transparency_verifier();
+  params.proxy_service = context->proxy_service();
+  params.ssl_session_cache_shard = GetSSLSessionCacheShard();
+  params.ssl_config_service = context->ssl_config_service();
+  params.http_auth_handler_factory = context->http_auth_handler_factory();
+  params.network_delegate = network_delegate();
+  params.http_server_properties = context->http_server_properties();
+  params.net_log = context->net_log();
+
+  network_controller_.reset(new DevToolsNetworkController());
+
+  net::HttpNetworkSession* session = new net::HttpNetworkSession(params);
+  return scoped_ptr<net::HttpCache>(new net::HttpCache(
+      new DevToolsNetworkTransactionFactory(network_controller_.get(), session),
+      context->net_log(), main_backend, true));
+}
+
+scoped_ptr<net::HttpCache> ProfileIOData::CreateHttpFactory(
+    net::HttpNetworkSession* shared_session,
+    net::HttpCache::BackendFactory* backend) const {
+  return scoped_ptr<net::HttpCache>(new net::HttpCache(
+      new DevToolsNetworkTransactionFactory(
+          network_controller_.get(), shared_session),
+      shared_session->net_log(), backend, false));
 }
 
 void ProfileIOData::SetCookieSettingsForTesting(
     CookieSettings* cookie_settings) {
   DCHECK(!cookie_settings_.get());
   cookie_settings_ = cookie_settings;
 }
 
 void ProfileIOData::set_signin_names_for_testing(
     SigninNamesOnIOThread* signin_names) {
   signin_names_.reset(signin_names);
 }