Add the ability for DevTools to wrap network transactions.

The eventual goal is to allow it to simulate flaky network connections.

Docs:
https://docs.google.com/a/google.com/document/d/1SkuWqLYIUpMDI05n7vgx8zdkunyUsxGs9tvUPDOqEJY/edit
https://docs.google.com/a/google.com/document/d/19O_UeUfCFZg5cEnH5jkkZ6_tqsfaLQLYUEIGyXw3oTo/edit

BUG=245436

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=273584

Review URL: https://codereview.chromium.org/182993003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@274253 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/devtools/chrome_devtools_manager_delegate.cc

@@ -4,14 +4,40 @@
 
 #include "chrome/browser/devtools/chrome_devtools_manager_delegate.h"
 
+#include "base/values.h"
+#include "chrome/browser/devtools/devtools_network_controller.h"
+#include "chrome/browser/devtools/devtools_protocol.h"
+#include "chrome/browser/devtools/devtools_protocol_constants.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
+#include "content/public/browser/devtools_manager.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/site_instance.h"
 
-ChromeDevToolsManagerDelegate::ChromeDevToolsManagerDelegate() {
+ChromeDevToolsManagerDelegate::ChromeDevToolsManagerDelegate()
+    : devtools_callback_(base::Bind(
+          &ChromeDevToolsManagerDelegate::OnDevToolsStateChanged,
+          base::Unretained(this))),
+      devtools_callback_registered_(false) {
+  // This constructor is invoked from DevToolsManagerImpl constructor, so it
+  // shouldn't call DevToolsManager::GetInstance()
 }
 
 ChromeDevToolsManagerDelegate::~ChromeDevToolsManagerDelegate() {
+  // This destructor is invoked from DevToolsManagerImpl destructor, so it
+  // shouldn't call DevToolsManager::GetInstance()
+}
+
+void ChromeDevToolsManagerDelegate::EnsureDevtoolsCallbackRegistered() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (!devtools_callback_registered_) {
+    content::DevToolsManager::GetInstance()->AddAgentStateCallback(
+        devtools_callback_);
+    devtools_callback_registered_ = true;
+  }
 }
 
 void ChromeDevToolsManagerDelegate::Inspect(
@@ -30,5 +56,53 @@ void ChromeDevToolsManagerDelegate::Inspect(
 base::DictionaryValue* ChromeDevToolsManagerDelegate::HandleCommand(
     content::DevToolsAgentHost* agent_host,
     base::DictionaryValue* command_dict) {
+  scoped_ptr<DevToolsProtocol::Command> command(
+       DevToolsProtocol::ParseCommand(command_dict));
+  if (!command)
+    return NULL;
+  const std::string method = command->method();
+  if (method == chrome::devtools::Network::emulateNetworkConditions::kName)
+    return EmulateNetworkConditions(agent_host, command.get())->Serialize();
   return NULL;
 }
+
+Profile* ChromeDevToolsManagerDelegate::GetProfile(
+    content::DevToolsAgentHost* agent_host) {
+  content::RenderViewHost* host = agent_host->GetRenderViewHost();
+  if (!host)
+    return NULL;
+  return Profile::FromBrowserContext(host->GetSiteInstance()->GetProcess()->
+      GetBrowserContext());
+}
+
+scoped_ptr<DevToolsProtocol::Response>
+ChromeDevToolsManagerDelegate::EmulateNetworkConditions(
+    content::DevToolsAgentHost* agent_host,
+    DevToolsProtocol::Command* command) {
+  base::DictionaryValue* params = command->params();
+  bool offline = false;
+  const char* offline_param =
+      chrome::devtools::Network::emulateNetworkConditions::kParamOffline;
+  if (!params || !params->GetBoolean(offline_param, &offline))
+    return command->InvalidParamResponse(offline_param);
+
+  EnsureDevtoolsCallbackRegistered();
+  UpdateNetworkState(agent_host, offline);
+  return command->SuccessResponse(NULL);
+}
+
+void ChromeDevToolsManagerDelegate::UpdateNetworkState(
+    content::DevToolsAgentHost* agent_host,
+    bool offline) {
+  Profile* profile = GetProfile(agent_host);
+  if (!profile)
+    return;
+  profile->GetDevToolsNetworkController()->SetNetworkState(
+      agent_host->GetId(), offline);
+}
+
+void ChromeDevToolsManagerDelegate::OnDevToolsStateChanged(
+    content::DevToolsAgentHost* agent_host,
+    bool attached) {
+  UpdateNetworkState(agent_host, false);
+}

chrome/browser/devtools/chrome_devtools_manager_delegate.h

@@ -5,10 +5,14 @@
 #ifndef CHROME_BROWSER_DEVTOOLS_CHROME_DEVTOOLS_MANAGER_DELEGATE_H_
 #define CHROME_BROWSER_DEVTOOLS_CHROME_DEVTOOLS_MANAGER_DELEGATE_H_
 
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "chrome/browser/devtools/devtools_protocol.h"
 #include "content/public/browser/devtools_manager_delegate.h"
 
+class Profile;
+
 class ChromeDevToolsManagerDelegate : public content::DevToolsManagerDelegate {
  public:
   ChromeDevToolsManagerDelegate();
@@ -22,6 +26,21 @@ class ChromeDevToolsManagerDelegate : public content::DevToolsManagerDelegate {
       base::DictionaryValue* command_dict) OVERRIDE;
 
  private:
+  base::Callback<void(content::DevToolsAgentHost*, bool)> devtools_callback_;
+  bool devtools_callback_registered_;
+  void EnsureDevtoolsCallbackRegistered();
+
+  Profile* GetProfile(content::DevToolsAgentHost* agent_host);
+
+  scoped_ptr<DevToolsProtocol::Response> EmulateNetworkConditions(
+      content::DevToolsAgentHost* agent_host,
+      DevToolsProtocol::Command* command);
+
+  void UpdateNetworkState(content::DevToolsAgentHost* agent_host, bool offline);
+
+  void OnDevToolsStateChanged(content::DevToolsAgentHost* agent_host,
+                              bool attached);
+
   DISALLOW_COPY_AND_ASSIGN(ChromeDevToolsManagerDelegate);
 };
 

chrome/browser/devtools/devtools_network_controller.cc

+// Copyright 2014 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/devtools/devtools_network_controller.h"
+
+#include "chrome/browser/devtools/devtools_network_transaction.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_io_data.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/resource_context.h"
+
+using content::BrowserThread;
+
+namespace {
+
+const char kDevToolsRequestInitiator[] = "X-DevTools-Request-Initiator";
+
+}  // namespace
+
+DevToolsNetworkController::DevToolsNetworkController()
+    : weak_ptr_factory_(this) {
+}
+
+DevToolsNetworkController::~DevToolsNetworkController() {
+}
+
+void DevToolsNetworkController::AddTransaction(
+    DevToolsNetworkTransaction* transaction) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  transactions_.insert(transaction);
+}
+
+void DevToolsNetworkController::RemoveTransaction(
+    DevToolsNetworkTransaction* transaction) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(transactions_.find(transaction) != transactions_.end());
+  transactions_.erase(transaction);
+}
+
+void DevToolsNetworkController::SetNetworkState(
+    const std::string& client_id,
+    bool offline) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserThread::PostTask(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &DevToolsNetworkController::SetNetworkStateOnIO,
+          weak_ptr_factory_.GetWeakPtr(),
+          client_id,
+          offline));
+}
+
+void DevToolsNetworkController::SetNetworkStateOnIO(
+    const std::string& client_id,
+    bool offline) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!offline) {
+    clients_.erase(client_id);
+    return;
+  }
+  clients_.insert(client_id);
+
+  // Iterate over a copy of set, because failing of transaction could result in
+  // creating a new one, or (theoretically) destroying one.
+  Transactions old_transactions(transactions_);
+  for (Transactions::iterator it = old_transactions.begin();
+       it != old_transactions.end(); ++it) {
+    if (transactions_.find(*it) == transactions_.end())
+      continue;
+    if (!(*it)->request() || (*it)->failed())
+      continue;
+    if (ShouldFail((*it)->request()))
+      (*it)->Fail();
+  }
+}
+
+bool DevToolsNetworkController::ShouldFail(
+    const net::HttpRequestInfo* request) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(request);
+  if (clients_.empty())
+    return false;
+
+  if (request->extra_headers.HasHeader(kDevToolsRequestInitiator))
+    return false;
+
+  // TODO: Add domain blacklist.
+
+  return true;
+}

chrome/browser/devtools/devtools_network_controller.h

+// Copyright 2014 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.
+
+#ifndef CHROME_BROWSER_DEVTOOLS_DEVTOOLS_NETWORK_CONTROLLER_H_
+#define CHROME_BROWSER_DEVTOOLS_DEVTOOLS_NETWORK_CONTROLLER_H_
+
+#include <set>
+#include <string>
+
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/thread_checker.h"
+
+class DevToolsNetworkTransaction;
+class GURL;
+class Profile;
+
+namespace content {
+class ResourceContext;
+}
+
+namespace net {
+struct HttpRequestInfo;
+}
+
+namespace test {
+class DevToolsNetworkControllerHelper;
+}
+
+// DevToolsNetworkController tracks DevToolsNetworkTransactions.
+class DevToolsNetworkController {
+
+ public:
+  DevToolsNetworkController();
+  virtual ~DevToolsNetworkController();
+
+  void AddTransaction(DevToolsNetworkTransaction* transaction);
+
+  void RemoveTransaction(DevToolsNetworkTransaction* transaction);
+
+  // Applies network emulation configuration.
+  // |client_id| should be DevToolsAgentHost GUID.
+  void SetNetworkState(
+      const std::string& client_id,
+      bool disable_network);
+
+  bool ShouldFail(const net::HttpRequestInfo* request);
+
+ protected:
+  friend class test::DevToolsNetworkControllerHelper;
+
+ private:
+  // Controller must be constructed on IO thread.
+  base::ThreadChecker thread_checker_;
+
+  void SetNetworkStateOnIO(
+      const std::string& client_id,
+      bool disable_network);
+
+  typedef std::set<DevToolsNetworkTransaction*> Transactions;
+  Transactions transactions_;
+
+  typedef std::set<std::string> Clients;
+  Clients clients_;
+
+  base::WeakPtrFactory<DevToolsNetworkController> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkController);
+};
+
+#endif  // CHROME_BROWSER_DEVTOOLS_DEVTOOLS_NETWORK_CONTROLLER_H_

chrome/browser/devtools/devtools_network_controller_unittest.cc

+// Copyright 2014 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 <string>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "chrome/browser/devtools/devtools_network_controller.h"
+#include "chrome/browser/devtools/devtools_network_transaction.h"
+#include "net/http/http_transaction_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+namespace test {
+
+const char kClientId[] = "42";
+const char kAnotherClientId[] = "24";
+
+class TestCallback {
+ public:
+  TestCallback() : run_count_(0), value_(0) {}
+  void Run(int value) {
+    run_count_++;
+    value_ = value;
+  }
+  int run_count() { return run_count_; }
+  int value() { return value_; }
+
+ private:
+  int run_count_;
+  int value_;
+};
+
+class DevToolsNetworkControllerHelper {
+ public:
+  DevToolsNetworkControllerHelper() :
+      completion_callback_(
+          base::Bind(&TestCallback::Run, base::Unretained(&callback_))),
+      mock_transaction_(kSimpleGET_Transaction),
+      buffer_(new net::IOBuffer(64)) {
+    mock_transaction_.test_mode = TEST_MODE_SYNC_NET_START;
+    mock_transaction_.url = "http://dot.com";
+    AddMockTransaction(&mock_transaction_);
+
+    scoped_ptr<net::HttpTransaction> network_transaction;
+    network_layer_.CreateTransaction(
+        net::DEFAULT_PRIORITY, &network_transaction);
+    transaction_.reset(new DevToolsNetworkTransaction(
+        &controller_, network_transaction.Pass()));
+  }
+
+  net::HttpRequestInfo* GetRequest() {
+    if (!request_)
+      request_.reset(new MockHttpRequest(mock_transaction_));
+    return request_.get();
+  }
+
+  void SetNetworkState(const std::string& client_id, bool offline) {
+    controller_.SetNetworkStateOnIO(client_id, offline);
+  }
+
+  int Start() {
+    return transaction_->Start(
+        GetRequest(), completion_callback_, net::BoundNetLog());
+  }
+
+  int Read() {
+    return transaction_->Read(buffer_.get(), 64, completion_callback_);
+  }
+
+  ~DevToolsNetworkControllerHelper() {
+    RemoveMockTransaction(&mock_transaction_);
+  }
+
+  TestCallback* callback() { return &callback_; }
+  MockTransaction* mock_transaction() { return &mock_transaction_; }
+  DevToolsNetworkController* controller() { return &controller_; }
+  DevToolsNetworkTransaction* transaction() { return transaction_.get(); }
+
+ private:
+  base::MessageLoop message_loop_;
+  MockNetworkLayer network_layer_;
+  TestCallback callback_;
+  net::CompletionCallback completion_callback_;
+  MockTransaction mock_transaction_;
+  DevToolsNetworkController controller_;
+  scoped_ptr<DevToolsNetworkTransaction> transaction_;
+  scoped_refptr<net::IOBuffer> buffer_;
+  scoped_ptr<MockHttpRequest> request_;
+};
+
+TEST(DevToolsNetworkControllerTest, SingleDisableEnable) {
+  DevToolsNetworkControllerHelper helper;
+  DevToolsNetworkController* controller = helper.controller();
+  net::HttpRequestInfo* request = helper.GetRequest();
+
+  EXPECT_FALSE(controller->ShouldFail(request));
+  helper.SetNetworkState(kClientId, true);
+  EXPECT_TRUE(controller->ShouldFail(request));
+  helper.SetNetworkState(kClientId, false);
+  EXPECT_FALSE(controller->ShouldFail(request));
+}
+
+TEST(DevToolsNetworkControllerTest, DoubleDisableEnable) {
+  DevToolsNetworkControllerHelper helper;
+  DevToolsNetworkController* controller = helper.controller();
+  net::HttpRequestInfo* request = helper.GetRequest();
+
+  EXPECT_FALSE(controller->ShouldFail(request));
+  helper.SetNetworkState(kClientId, true);
+  EXPECT_TRUE(controller->ShouldFail(request));
+  helper.SetNetworkState(kAnotherClientId, true);
+  EXPECT_TRUE(controller->ShouldFail(request));
+  helper.SetNetworkState(kClientId, false);
+  EXPECT_TRUE(controller->ShouldFail(request));
+  helper.SetNetworkState(kAnotherClientId, false);
+  EXPECT_FALSE(controller->ShouldFail(request));
+}
+
+TEST(DevToolsNetworkControllerTest, FailOnStart) {
+  DevToolsNetworkControllerHelper helper;
+  helper.SetNetworkState(kClientId, true);
+
+  int rv = helper.Start();
+  EXPECT_EQ(rv, net::ERR_INTERNET_DISCONNECTED);
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(helper.callback()->run_count(), 0);
+}
+
+TEST(DevToolsNetworkControllerTest, FailRunningTransaction) {
+  DevToolsNetworkControllerHelper helper;
+  TestCallback* callback = helper.callback();
+
+  int rv = helper.Start();
+  EXPECT_EQ(rv, net::OK);
+
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(64));
+  rv = helper.Read();
+  EXPECT_EQ(rv, net::ERR_IO_PENDING);
+  EXPECT_EQ(callback->run_count(), 0);
+
+  helper.SetNetworkState(kClientId, true);
+  EXPECT_EQ(callback->run_count(), 1);
+  EXPECT_EQ(callback->value(), net::ERR_INTERNET_DISCONNECTED);
+
+  // Wait until HttpTrancation completes reading and invokes callback.
+  // DevToolsNetworkTransaction should ignore callback, because it has
+  // reported network error already.
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(callback->run_count(), 1);
+
+  // Check that transaction in not failed second time.
+  helper.SetNetworkState(kClientId, false);
+  helper.SetNetworkState(kClientId, true);
+  EXPECT_EQ(callback->run_count(), 1);
+}
+
+TEST(DevToolsNetworkControllerTest, ReadAfterFail) {
+  DevToolsNetworkControllerHelper helper;
+
+  int rv = helper.Start();
+  EXPECT_EQ(rv, net::OK);
+  EXPECT_TRUE(helper.transaction()->request());
+
+  helper.SetNetworkState(kClientId, true);
+  EXPECT_TRUE(helper.transaction()->failed());
+
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(64));
+  rv = helper.Read();
+  EXPECT_EQ(rv, net::ERR_INTERNET_DISCONNECTED);
+
+  // Check that callback is never invoked.
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(helper.callback()->run_count(), 0);
+}
+
+TEST(DevToolsNetworkControllerTest, AllowsDevToolsRequests) {
+  DevToolsNetworkControllerHelper helper;
+  helper.mock_transaction()->request_headers =
+      "X-DevTools-Request-Initiator: frontend\r\n";
+  DevToolsNetworkController* controller = helper.controller();
+  net::HttpRequestInfo* request = helper.GetRequest();
+
+  EXPECT_FALSE(controller->ShouldFail(request));
+  helper.SetNetworkState(kClientId, true);
+  EXPECT_FALSE(controller->ShouldFail(request));
+}
+
+}  // namespace test

chrome/browser/devtools/devtools_network_transaction.cc

+// Copyright 2014 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/devtools/devtools_network_transaction.h"
+
+#include "chrome/browser/devtools/devtools_network_controller.h"
+#include "net/base/net_errors.h"
+#include "net/base/upload_progress.h"
+#include "net/http/http_network_transaction.h"
+#include "net/http/http_request_info.h"
+
+DevToolsNetworkTransaction::DevToolsNetworkTransaction(
+    DevToolsNetworkController* controller,
+    scoped_ptr<net::HttpTransaction> network_transaction)
+    : controller_(controller),
+      network_transaction_(network_transaction.Pass()),
+      request_(NULL),
+      failed_(false),
+      proxy_callback_(base::Bind(&DevToolsNetworkTransaction::OnCallback,
+                                 base::Unretained(this))) {
+  DCHECK(controller);
+  controller->AddTransaction(this);
+}
+
+DevToolsNetworkTransaction::~DevToolsNetworkTransaction() {
+  controller_->RemoveTransaction(this);
+}
+
+void DevToolsNetworkTransaction::OnCallback(int rv) {
+  if (failed_)
+    return;
+  DCHECK(!callback_.is_null());
+  net::CompletionCallback callback = callback_;
+  callback_.Reset();
+  callback.Run(rv);
+}
+
+void DevToolsNetworkTransaction::Fail() {
+  DCHECK(request_);
+  DCHECK(!failed_);
+  failed_ = true;
+  network_transaction_->SetBeforeNetworkStartCallback(
+      BeforeNetworkStartCallback());
+  if (callback_.is_null())
+    return;
+  net::CompletionCallback callback = callback_;
+  callback_.Reset();
+  callback.Run(net::ERR_INTERNET_DISCONNECTED);
+}
+
+int DevToolsNetworkTransaction::Start(
+    const net::HttpRequestInfo* request,
+    const net::CompletionCallback& callback,
+    const net::BoundNetLog& net_log) {
+  DCHECK(request);
+  request_ = request;
+
+  if (controller_->ShouldFail(request_)) {
+    failed_ = true;
+    network_transaction_->SetBeforeNetworkStartCallback(
+        BeforeNetworkStartCallback());
+    return net::ERR_INTERNET_DISCONNECTED;
+  }
+  int rv = network_transaction_->Start(request, proxy_callback_, net_log);
+  if (rv == net::ERR_IO_PENDING)
+    callback_ = callback;
+  return rv;
+}
+
+int DevToolsNetworkTransaction::RestartIgnoringLastError(
+    const net::CompletionCallback& callback) {
+  if (failed_)
+    return net::ERR_INTERNET_DISCONNECTED;
+  int rv = network_transaction_->RestartIgnoringLastError(proxy_callback_);
+  if (rv == net::ERR_IO_PENDING)
+    callback_ = callback;
+  return rv;
+}
+
+int DevToolsNetworkTransaction::RestartWithCertificate(
+    net::X509Certificate* client_cert,
+    const net::CompletionCallback& callback) {
+  if (failed_)
+    return net::ERR_INTERNET_DISCONNECTED;
+  int rv = network_transaction_->RestartWithCertificate(
+      client_cert, proxy_callback_);
+  if (rv == net::ERR_IO_PENDING)
+    callback_ = callback;
+  return rv;
+}
+
+int DevToolsNetworkTransaction::RestartWithAuth(
+    const net::AuthCredentials& credentials,
+    const net::CompletionCallback& callback) {
+  if (failed_)
+    return net::ERR_INTERNET_DISCONNECTED;
+  int rv = network_transaction_->RestartWithAuth(credentials, proxy_callback_);
+  if (rv == net::ERR_IO_PENDING)
+    callback_ = callback;
+  return rv;
+}
+
+bool DevToolsNetworkTransaction::IsReadyToRestartForAuth() {
+  return network_transaction_->IsReadyToRestartForAuth();
+}
+
+int DevToolsNetworkTransaction::Read(
+    net::IOBuffer* buf,
+    int buf_len,
+    const net::CompletionCallback& callback) {
+  if (failed_)
+    return net::ERR_INTERNET_DISCONNECTED;
+  int rv = network_transaction_->Read(buf, buf_len, proxy_callback_);
+  if (rv == net::ERR_IO_PENDING)
+    callback_ = callback;
+  return rv;
+}
+
+void DevToolsNetworkTransaction::StopCaching() {
+  network_transaction_->StopCaching();
+}
+
+bool DevToolsNetworkTransaction::GetFullRequestHeaders(
+    net::HttpRequestHeaders* headers) const {
+  return network_transaction_->GetFullRequestHeaders(headers);
+}
+
+int64 DevToolsNetworkTransaction::GetTotalReceivedBytes() const {
+  return network_transaction_->GetTotalReceivedBytes();
+}
+
+void DevToolsNetworkTransaction::DoneReading() {
+  network_transaction_->DoneReading();
+}
+
+const net::HttpResponseInfo*
+DevToolsNetworkTransaction::GetResponseInfo() const {
+  return network_transaction_->GetResponseInfo();
+}
+
+net::LoadState DevToolsNetworkTransaction::GetLoadState() const {
+  return network_transaction_->GetLoadState();
+}
+
+net::UploadProgress DevToolsNetworkTransaction::GetUploadProgress() const {
+  return network_transaction_->GetUploadProgress();
+}
+
+void DevToolsNetworkTransaction::SetQuicServerInfo(
+    net::QuicServerInfo* quic_server_info) {
+  network_transaction_->SetQuicServerInfo(quic_server_info);
+}
+
+bool DevToolsNetworkTransaction::GetLoadTimingInfo(
+    net::LoadTimingInfo* load_timing_info) const {
+  return network_transaction_->GetLoadTimingInfo(load_timing_info);
+}
+
+void DevToolsNetworkTransaction::SetPriority(net::RequestPriority priority) {
+  network_transaction_->SetPriority(priority);
+}
+
+void DevToolsNetworkTransaction::SetWebSocketHandshakeStreamCreateHelper(
+    net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) {
+  network_transaction_->SetWebSocketHandshakeStreamCreateHelper(create_helper);
+}
+
+void DevToolsNetworkTransaction::SetBeforeNetworkStartCallback(
+    const BeforeNetworkStartCallback& callback) {
+  network_transaction_->SetBeforeNetworkStartCallback(callback);
+}
+
+int DevToolsNetworkTransaction::ResumeNetworkStart() {
+  if (failed_)
+    return net::ERR_INTERNET_DISCONNECTED;
+  return network_transaction_->ResumeNetworkStart();
+}

chrome/browser/devtools/devtools_network_transaction.h

+// Copyright 2014 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.
+
+#ifndef CHROME_BROWSER_DEVTOOLS_DEVTOOLS_NETWORK_TRANSACTION_H_
+#define CHROME_BROWSER_DEVTOOLS_DEVTOOLS_NETWORK_TRANSACTION_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "net/base/completion_callback.h"
+#include "net/base/load_states.h"
+#include "net/base/request_priority.h"
+#include "net/http/http_transaction.h"
+#include "net/websockets/websocket_handshake_stream_base.h"
+
+class DevToolsNetworkController;
+class GURL;
+
+namespace net {
+class AuthCredentials;
+class BoundNetLog;
+class HttpRequestHeaders;
+struct HttpRequestInfo;
+class HttpResponseInfo;
+class HttpNetworkSession;
+class IOBuffer;
+struct LoadTimingInfo;
+class UploadProgress;
+class X509Certificate;
+}
+
+// DevToolsNetworkTransaction is a wrapper for network transaction. All
+// HttpTransaction methods are proxied to real transaction, but |callback|
+// parameter is saved and replaced with proxy callback. Fail method should be
+// used to simulate network outage. It runs saved callback (if any) with
+// net::ERR_INTERNET_DISCONNECTED result value.
+class DevToolsNetworkTransaction : public net::HttpTransaction {
+ public:
+  DevToolsNetworkTransaction(
+      DevToolsNetworkController* controller,
+      scoped_ptr<net::HttpTransaction> network_transaction);
+
+  virtual ~DevToolsNetworkTransaction();
+
+  const net::HttpRequestInfo* request() const { return request_; }
+  bool failed() const { return failed_; }
+
+  // Runs callback (if any) with net::ERR_INTERNET_DISCONNECTED result value.
+  void Fail();
+
+  // HttpTransaction methods:
+  virtual int Start(
+      const net::HttpRequestInfo* request,
+      const net::CompletionCallback& callback,
+      const net::BoundNetLog& net_log) OVERRIDE;
+  virtual int RestartIgnoringLastError(
+      const net::CompletionCallback& callback) OVERRIDE;
+  virtual int RestartWithCertificate(
+      net::X509Certificate* client_cert,
+      const net::CompletionCallback& callback) OVERRIDE;
+  virtual int RestartWithAuth(
+      const net::AuthCredentials& credentials,
+      const net::CompletionCallback& callback) OVERRIDE;
+  virtual bool IsReadyToRestartForAuth() OVERRIDE;
+
+  virtual int Read(
+      net::IOBuffer* buf,
+      int buf_len,
+      const net::CompletionCallback& callback) OVERRIDE;
+  virtual void StopCaching() OVERRIDE;
+  virtual bool GetFullRequestHeaders(
+      net::HttpRequestHeaders* headers) const OVERRIDE;
+  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
+  virtual void DoneReading() OVERRIDE;
+  virtual const net::HttpResponseInfo* GetResponseInfo() const OVERRIDE;
+  virtual net::LoadState GetLoadState() const OVERRIDE;
+  virtual net::UploadProgress GetUploadProgress() const OVERRIDE;
+  virtual void SetQuicServerInfo(
+      net::QuicServerInfo* quic_server_info) OVERRIDE;
+  virtual bool GetLoadTimingInfo(
+      net::LoadTimingInfo* load_timing_info) const OVERRIDE;
+  virtual void SetPriority(net::RequestPriority priority) OVERRIDE;
+  virtual void SetWebSocketHandshakeStreamCreateHelper(
+      net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) OVERRIDE;
+  virtual void SetBeforeNetworkStartCallback(
+      const BeforeNetworkStartCallback& callback) OVERRIDE;
+  virtual int ResumeNetworkStart() OVERRIDE;
+
+ private:
+  // Proxy callback handler. Runs saved callback.
+  void OnCallback(int result);
+
+  DevToolsNetworkController* controller_;
+
+  // Real network transaction.
+  scoped_ptr<net::HttpTransaction> network_transaction_;
+
+  const net::HttpRequestInfo* request_;
+
+  // True if Start was already invoked.
+  bool started_;
+
+  // True if Fail was already invoked.
+  bool failed_;
+
+  net::CompletionCallback proxy_callback_;
+  net::CompletionCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkTransaction);
+};
+
+#endif  // CHROME_BROWSER_DEVTOOLS_DEVTOOLS_NETWORK_TRANSACTION_H_

chrome/browser/devtools/devtools_network_transaction_factory.cc

+// Copyright 2014 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/devtools/devtools_network_transaction_factory.h"
+
+#include "chrome/browser/devtools/devtools_network_controller.h"
+#include "chrome/browser/devtools/devtools_network_transaction.h"
+#include "net/base/net_errors.h"
+#include "net/http/http_network_layer.h"
+#include "net/http/http_network_transaction.h"
+
+DevToolsNetworkTransactionFactory::DevToolsNetworkTransactionFactory(
+    DevToolsNetworkController* controller,
+    net::HttpNetworkSession* session)
+    : controller_(controller),
+      network_layer_(new net::HttpNetworkLayer(session)) {
+}
+
+DevToolsNetworkTransactionFactory::~DevToolsNetworkTransactionFactory() {
+}
+
+int DevToolsNetworkTransactionFactory::CreateTransaction(
+    net::RequestPriority priority,
+    scoped_ptr<net::HttpTransaction>* trans) {
+  scoped_ptr<net::HttpTransaction> network_transaction;
+  int rv = network_layer_->CreateTransaction(priority, &network_transaction);
+  if (rv != net::OK) {
+    return rv;
+  }
+  trans->reset(
+      new DevToolsNetworkTransaction(controller_, network_transaction.Pass()));
+  return net::OK;
+}
+
+net::HttpCache* DevToolsNetworkTransactionFactory::GetCache() {
+  return network_layer_->GetCache();
+}
+
+net::HttpNetworkSession* DevToolsNetworkTransactionFactory::GetSession() {
+  return network_layer_->GetSession();
+}

chrome/browser/devtools/devtools_network_transaction_factory.h

+// Copyright 2014 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.
+
+#ifndef CHROME_BROWSER_DEVTOOLS_DEVTOOLS_NETWORK_TRANSACTION_FACTORY_H_
+#define CHROME_BROWSER_DEVTOOLS_DEVTOOLS_NETWORK_TRANSACTION_FACTORY_H_
+
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/request_priority.h"
+#include "net/http/http_transaction_factory.h"
+
+class DevToolsNetworkController;
+
+namespace net {
+class HttpCache;
+class HttpNetworkSession;
+class HttpTransaction;
+}
+
+// NetworkTransactionFactory wraps HttpNetworkTransactions.
+class DevToolsNetworkTransactionFactory : public net::HttpTransactionFactory {
+ public:
+  DevToolsNetworkTransactionFactory(
+      DevToolsNetworkController* controller,
+      net::HttpNetworkSession* session);
+  virtual ~DevToolsNetworkTransactionFactory();
+
+  // net::HttpTransactionFactory methods:
+  virtual int CreateTransaction(
+      net::RequestPriority priority,
+      scoped_ptr<net::HttpTransaction>* trans) OVERRIDE;
+  virtual net::HttpCache* GetCache() OVERRIDE;
+  virtual net::HttpNetworkSession* GetSession() OVERRIDE;
+
+ private:
+  DevToolsNetworkController* controller_;
+  scoped_ptr<net::HttpTransactionFactory> network_layer_;
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkTransactionFactory);
+};
+
+#endif  // CHROME_BROWSER_DEVTOOLS_DEVTOOLS_NETWORK_TRANSACTION_FACTORY_H_

chrome/browser/profiles/off_the_record_profile_impl.cc

@@ -500,6 +500,11 @@ chrome_browser_net::Predictor* OffTheRecordProfileImpl::GetNetworkPredictor() {
   return NULL;
 }
 
+DevToolsNetworkController*
+OffTheRecordProfileImpl::GetDevToolsNetworkController() {
+  return io_data_->GetDevToolsNetworkController();
+}
+
 void OffTheRecordProfileImpl::ClearNetworkingHistorySince(
     base::Time time,
     const base::Closure& completion) {

chrome/browser/profiles/off_the_record_profile_impl.h

@@ -80,6 +80,7 @@ class OffTheRecordProfileImpl : public Profile {
   virtual PrefProxyConfigTracker* GetProxyConfigTracker() OVERRIDE;
 
   virtual chrome_browser_net::Predictor* GetNetworkPredictor() OVERRIDE;
+  virtual DevToolsNetworkController* GetDevToolsNetworkController() OVERRIDE;
   virtual void ClearNetworkingHistorySince(
       base::Time time,
       const base::Closure& completion) OVERRIDE;

chrome/browser/profiles/off_the_record_profile_io_data.cc

@@ -142,6 +142,12 @@ OffTheRecordProfileIOData::Handle::CreateIsolatedAppRequestContextGetter(
   return context;
 }
 
+DevToolsNetworkController*
+OffTheRecordProfileIOData::Handle::GetDevToolsNetworkController() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return io_data_->network_controller();
+}
+
 void OffTheRecordProfileIOData::Handle::LazyInitialize() const {
   if (initialized_)
     return;
@@ -218,13 +224,9 @@ void OffTheRecordProfileIOData::InitializeInternal(
 
   net::HttpCache::BackendFactory* main_backend =
       net::HttpCache::DefaultBackend::InMemory(0);
-  net::HttpNetworkSession::Params network_session_params;
-  PopulateNetworkSessionParams(profile_params, &network_session_params);
-  net::HttpCache* cache = new net::HttpCache(
-      network_session_params, main_backend);
+  main_http_factory_ = CreateMainHttpFactory(profile_params, main_backend);
 
-  main_http_factory_.reset(cache);
-  main_context->set_http_transaction_factory(cache);
+  main_context->set_http_transaction_factory(main_http_factory_.get());
 #if !defined(DISABLE_FTP_SUPPORT)
   ftp_factory_.reset(
       new net::FtpNetworkLayer(main_context->host_resolver()));
@@ -314,10 +316,11 @@ ChromeURLRequestContext* OffTheRecordProfileIOData::InitializeAppRequestContext(
       net::HttpCache::DefaultBackend::InMemory(0);
   net::HttpNetworkSession* main_network_session =
       main_http_factory_->GetSession();
-  scoped_ptr<net::HttpTransactionFactory> app_http_cache(
-      new net::HttpCache(main_network_session, app_backend));
+  scoped_ptr<net::HttpCache> app_http_cache =
+      CreateHttpFactory(main_network_session, app_backend);
 
-  context->SetHttpTransactionFactory(app_http_cache.Pass());
+  context->SetHttpTransactionFactory(
+      app_http_cache.PassAs<net::HttpTransactionFactory>());
 
   scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
       new net::URLRequestJobFactoryImpl());

chrome/browser/profiles/off_the_record_profile_io_data.h

@@ -64,6 +64,9 @@ class OffTheRecordProfileIOData : public ProfileIOData {
             content::URLRequestInterceptorScopedVector
                 request_interceptors) const;
 
+    // Returns the DevToolsNetworkController attached to ProfileIOData.
+    DevToolsNetworkController* GetDevToolsNetworkController() const;
+
    private:
     typedef std::map<StoragePartitionDescriptor,
                      scoped_refptr<ChromeURLRequestContextGetter>,

chrome/browser/profiles/profile.h

@@ -17,6 +17,7 @@
 #include "content/public/browser/content_browser_client.h"
 
 class ChromeAppCacheService;
+class DevToolsNetworkController;
 class ExtensionService;
 class ExtensionSpecialStoragePolicy;
 class FaviconService;
@@ -312,6 +313,9 @@ class Profile : public content::BrowserContext {
   // Returns the Predictor object used for dns prefetch.
   virtual chrome_browser_net::Predictor* GetNetworkPredictor() = 0;
 
+  // Returns the DevToolsNetworkController for this profile.
+  virtual DevToolsNetworkController* GetDevToolsNetworkController() = 0;
+
   // Deletes all network related data since |time|. It deletes transport
   // security state since |time| and it also deletes HttpServerProperties data.
   // Works asynchronously, however if the |completion| callback is non-null, it

chrome/browser/profiles/profile_impl.cc

@@ -1241,6 +1241,10 @@ chrome_browser_net::Predictor* ProfileImpl::GetNetworkPredictor() {
   return predictor_;
 }
 
+DevToolsNetworkController* ProfileImpl::GetDevToolsNetworkController() {
+  return io_data_.GetDevToolsNetworkController();
+}
+
 void ProfileImpl::ClearNetworkingHistorySince(
     base::Time time,
     const base::Closure& completion) {

chrome/browser/profiles/profile_impl.h

@@ -142,6 +142,7 @@ class ProfileImpl : public Profile {
   virtual base::FilePath last_selected_directory() OVERRIDE;
   virtual void set_last_selected_directory(const base::FilePath& path) OVERRIDE;
   virtual chrome_browser_net::Predictor* GetNetworkPredictor() OVERRIDE;
+  virtual DevToolsNetworkController* GetDevToolsNetworkController() OVERRIDE;
   virtual void ClearNetworkingHistorySince(
       base::Time time,
       const base::Closure& completion) OVERRIDE;

chrome/browser/profiles/profile_impl_io_data.cc

@@ -296,6 +296,12 @@ ProfileImplIOData::Handle::GetIsolatedMediaRequestContextGetter(
   return context;
 }
 
+DevToolsNetworkController*
+ProfileImplIOData::Handle::GetDevToolsNetworkController() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return io_data_->network_controller();
+}
+
 void ProfileImplIOData::Handle::ClearNetworkingHistorySince(
     base::Time time,
     const base::Closure& completion) {
@@ -474,10 +480,8 @@ void ProfileImplIOData::InitializeInternal(
           lazy_params_->cache_max_size,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)
               .get());
-  net::HttpNetworkSession::Params network_session_params;
-  PopulateNetworkSessionParams(profile_params, &network_session_params);
-  net::HttpCache* main_cache = new net::HttpCache(
-      network_session_params, main_backend);
+  scoped_ptr<net::HttpCache> main_cache = CreateMainHttpFactory(
+      profile_params, main_backend);
   main_cache->InitializeInfiniteCache(lazy_params_->infinite_cache_path);
 
 #if defined(OS_ANDROID) || defined(OS_IOS)
@@ -495,8 +499,8 @@ void ProfileImplIOData::InitializeInternal(
         net::HttpCache::RECORD : net::HttpCache::PLAYBACK);
   }
 
-  main_http_factory_.reset(main_cache);
-  main_context->set_http_transaction_factory(main_cache);
+  main_http_factory_.reset(main_cache.release());
+  main_context->set_http_transaction_factory(main_http_factory_.get());
 
 #if !defined(DISABLE_FTP_SUPPORT)
   ftp_factory_.reset(
@@ -612,8 +616,8 @@ ChromeURLRequestContext* ProfileImplIOData::InitializeAppRequestContext(
   }
   net::HttpNetworkSession* main_network_session =
       main_http_factory_->GetSession();
-  net::HttpCache* app_http_cache =
-      new net::HttpCache(main_network_session, app_backend);
+  scoped_ptr<net::HttpCache> app_http_cache =
+      CreateHttpFactory(main_network_session, app_backend);
 
   scoped_refptr<net::CookieStore> cookie_store = NULL;
   if (partition_descriptor.in_memory) {
@@ -648,7 +652,8 @@ ChromeURLRequestContext* ProfileImplIOData::InitializeAppRequestContext(
   // Transfer ownership of the cookies and cache to AppRequestContext.
   context->SetCookieStore(cookie_store.get());
   context->SetHttpTransactionFactory(
-      scoped_ptr<net::HttpTransactionFactory>(app_http_cache));
+      scoped_ptr<net::HttpTransactionFactory>(
+          app_http_cache.PassAs<net::HttpTransactionFactory>()));
 
   scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
       new net::URLRequestJobFactoryImpl());
@@ -701,11 +706,12 @@ ProfileImplIOData::InitializeMediaRequestContext(
               .get());
   net::HttpNetworkSession* main_network_session =
       main_http_factory_->GetSession();
-  scoped_ptr<net::HttpTransactionFactory> media_http_cache(
-      new net::HttpCache(main_network_session, media_backend));
+  scoped_ptr<net::HttpCache> media_http_cache =
+      CreateHttpFactory(main_network_session, media_backend);
 
   // Transfer ownership of the cache to MediaRequestContext.
-  context->SetHttpTransactionFactory(media_http_cache.Pass());
+  context->SetHttpTransactionFactory(
+      media_http_cache.PassAs<net::HttpTransactionFactory>());
 
   // Note that we do not create a new URLRequestJobFactory because
   // the media context should behave exactly like its parent context

chrome/browser/profiles/profile_impl_io_data.h

@@ -90,6 +90,9 @@ class ProfileImplIOData : public ProfileIOData {
             const base::FilePath& partition_path,
             bool in_memory) const;
 
+    // Returns the DevToolsNetworkController attached to ProfileIOData.
+    DevToolsNetworkController* GetDevToolsNetworkController() const;
+
     // Deletes all network related data since |time|. It deletes transport
     // security state since |time| and also deletes HttpServerProperties data.
     // Works asynchronously, however if the |completion| callback is non-null,

chrome/browser/profiles/profile_io_data.cc

@@ -28,6 +28,8 @@
 #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"
@@ -1143,28 +1145,44 @@ 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);
-
-  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();
+  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();
+
+  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));
+}
+
+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));
 }
 
 void ProfileIOData::SetCookieSettingsForTesting(

chrome/browser/profiles/profile_io_data.h

@@ -24,12 +24,14 @@
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/resource_context.h"
 #include "net/cookies/cookie_monster.h"
+#include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/url_request/url_request_job_factory.h"
 
 class ChromeHttpUserAgentSettings;
 class ChromeNetworkDelegate;
 class CookieSettings;
+class DevToolsNetworkController;
 class HostContentSettingsMap;
 class ManagedModeURLFilter;
 class MediaDeviceIDSalt;
@@ -184,6 +186,10 @@ class ProfileIOData {
 
   content::ResourceContext::SaltCallback GetMediaDeviceIDSalt() const;
 
+  DevToolsNetworkController* network_controller() const {
+    return network_controller_.get();
+  }
+
   net::TransportSecurityState* transport_security_state() const {
     return transport_security_state_.get();
   }
@@ -362,11 +368,15 @@ class ProfileIOData {
   // URLRequests may be accessing.
   void DestroyResourceContext();
 
-  // Fills in fields of params using values from main_request_context_ and the
-  // IOThread associated with profile_params.
-  void PopulateNetworkSessionParams(
+  // Creates network session and main network transaction factory.
+  scoped_ptr<net::HttpCache> CreateMainHttpFactory(
       const ProfileParams* profile_params,
-      net::HttpNetworkSession::Params* params) const;
+      net::HttpCache::BackendFactory* main_backend) const;
+
+  // Creates network transaction factory.
+  scoped_ptr<net::HttpCache> CreateHttpFactory(
+      net::HttpNetworkSession* shared_session,
+      net::HttpCache::BackendFactory* backend) const;
 
   void SetCookieSettingsForTesting(CookieSettings* cookie_settings);
 
@@ -567,6 +577,8 @@ class ProfileIOData {
   mutable scoped_refptr<const ManagedModeURLFilter> managed_mode_url_filter_;
 #endif
 
+  mutable scoped_ptr<DevToolsNetworkController> network_controller_;
+
   // TODO(jhawkins): Remove once crbug.com/102004 is fixed.
   bool initialized_on_UI_thread_;
 

chrome/browser/ui/app_list/test/fake_profile.cc

@@ -209,6 +209,10 @@ chrome_browser_net::Predictor* FakeProfile::GetNetworkPredictor() {
   return NULL;
 }
 
+DevToolsNetworkController* FakeProfile::GetDevToolsNetworkController() {
+  return NULL;
+}
+
 void FakeProfile::ClearNetworkingHistorySince(
     base::Time time,
     const base::Closure& completion) {

chrome/browser/ui/app_list/test/fake_profile.h

@@ -111,6 +111,7 @@ class FakeProfile : public Profile {
 
   virtual PrefProxyConfigTracker* GetProxyConfigTracker() OVERRIDE;
   virtual chrome_browser_net::Predictor* GetNetworkPredictor() OVERRIDE;
+  virtual DevToolsNetworkController* GetDevToolsNetworkController() OVERRIDE;
   virtual void ClearNetworkingHistorySince(
       base::Time time, const base::Closure& completion) OVERRIDE;
   virtual void ClearDomainReliabilityMonitor(

chrome/chrome_debugger.gypi

@@ -64,6 +64,12 @@
         'browser/devtools/devtools_file_helper.h',
         'browser/devtools/devtools_file_system_indexer.cc',
         'browser/devtools/devtools_file_system_indexer.h',
+        'browser/devtools/devtools_network_controller.cc',
+        'browser/devtools/devtools_network_controller.h',
+        'browser/devtools/devtools_network_transaction.cc',
+        'browser/devtools/devtools_network_transaction.h',
+        'browser/devtools/devtools_network_transaction_factory.cc',
+        'browser/devtools/devtools_network_transaction_factory.h',
         'browser/devtools/devtools_protocol.cc',
         'browser/devtools/devtools_protocol.h',
         'browser/devtools/devtools_target_impl.cc',

chrome/chrome_tests_unit.gypi

@@ -824,6 +824,7 @@
         'browser/diagnostics/diagnostics_model_unittest.cc',
         'browser/diagnostics/diagnostics_controller_unittest.cc',
         'browser/devtools/devtools_contents_resizing_strategy_unittest.cc',
+        'browser/devtools/devtools_network_controller_unittest.cc',
         'browser/download/all_download_item_notifier_unittest.cc',
         'browser/download/chrome_download_manager_delegate_unittest.cc',
         'browser/download/download_history_unittest.cc',

chrome/test/base/testing_profile.cc

@@ -872,6 +872,10 @@ chrome_browser_net::Predictor* TestingProfile::GetNetworkPredictor() {
   return NULL;
 }
 
+DevToolsNetworkController* TestingProfile::GetDevToolsNetworkController() {
+  return NULL;
+}
+
 void TestingProfile::ClearNetworkingHistorySince(
     base::Time time,
     const base::Closure& completion) {

chrome/test/base/testing_profile.h

@@ -332,6 +332,7 @@ class TestingProfile : public Profile {
   void BlockUntilHistoryProcessesPendingRequests();
 
   virtual chrome_browser_net::Predictor* GetNetworkPredictor() OVERRIDE;
+  virtual DevToolsNetworkController* GetDevToolsNetworkController() OVERRIDE;
   virtual void ClearNetworkingHistorySince(
       base::Time time,
       const base::Closure& completion) OVERRIDE;

net/http/http_cache.cc

@@ -291,13 +291,9 @@ HttpCache::HttpCache(const net::HttpNetworkSession::Params& params,
       backend_factory_(backend_factory),
       building_backend_(false),
       mode_(NORMAL),
-      quic_server_info_factory_(params.enable_quic_persist_server_info ?
-          new QuicServerInfoFactoryAdaptor(this) : NULL),
       network_layer_(new HttpNetworkLayer(new HttpNetworkSession(params))),
       weak_factory_(this) {
-  HttpNetworkSession* session = network_layer_->GetSession();
-  session->quic_stream_factory()->set_quic_server_info_factory(
-      quic_server_info_factory_.get());
+  SetupQuicServerInfoFactory(network_layer_->GetSession());
 }
 
 
@@ -322,6 +318,7 @@ HttpCache::HttpCache(HttpTransactionFactory* network_layer,
       mode_(NORMAL),
       network_layer_(network_layer),
       weak_factory_(this) {
+  SetupQuicServerInfoFactory(network_layer_->GetSession());
 }
 
 HttpCache::~HttpCache() {
@@ -1007,6 +1004,16 @@ bool HttpCache::RemovePendingTransactionFromPendingOp(PendingOp* pending_op,
   return false;
 }
 
+void HttpCache::SetupQuicServerInfoFactory(HttpNetworkSession* session) {
+  if (session && session->params().enable_quic_persist_server_info &&
+      !session->quic_stream_factory()->has_quic_server_info_factory()) {
+    DCHECK(!quic_server_info_factory_);
+    quic_server_info_factory_.reset(new QuicServerInfoFactoryAdaptor(this));
+    session->quic_stream_factory()->set_quic_server_info_factory(
+        quic_server_info_factory_.get());
+  }
+}
+
 void HttpCache::ProcessPendingQueue(ActiveEntry* entry) {
   // Multiple readers may finish with an entry at once, so we want to batch up
   // calls to OnProcessPendingQueue.  This flag also tells us that we should

net/http/http_cache.h

@@ -124,17 +124,16 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory,
   HttpCache(const net::HttpNetworkSession::Params& params,
             BackendFactory* backend_factory);
 
-  // The disk cache is initialized lazily (by CreateTransaction) in  this case.
+  // The disk cache is initialized lazily (by CreateTransaction) in this case.
   // Provide an existing HttpNetworkSession, the cache can construct a
   // network layer with a shared HttpNetworkSession in order for multiple
   // network layers to share information (e.g. authentication data). The
   // HttpCache takes ownership of the |backend_factory|.
   HttpCache(HttpNetworkSession* session, BackendFactory* backend_factory);
 
-  // Initialize the cache from its component parts, which is useful for
-  // testing.  The lifetime of the network_layer and backend_factory are managed
-  // by the HttpCache and will be destroyed using |delete| when the HttpCache is
-  // destroyed.
+  // Initialize the cache from its component parts. The lifetime of the
+  // |network_layer| and |backend_factory| are managed by the HttpCache and
+  // will be destroyed using |delete| when the HttpCache is destroyed.
   HttpCache(HttpTransactionFactory* network_layer,
             NetLog* net_log,
             BackendFactory* backend_factory);
@@ -355,6 +354,9 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory,
   bool RemovePendingTransactionFromPendingOp(PendingOp* pending_op,
                                              Transaction* trans);
 
+  // Instantiates and sets QUIC server info factory.
+  void SetupQuicServerInfoFactory(HttpNetworkSession* session);
+
   // Resumes processing the pending list of |entry|.
   void ProcessPendingQueue(ActiveEntry* entry);
 
@@ -390,7 +392,7 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory,
 
   Mode mode_;
 
-  const scoped_ptr<QuicServerInfoFactoryAdaptor> quic_server_info_factory_;
+  scoped_ptr<QuicServerInfoFactoryAdaptor> quic_server_info_factory_;
 
   scoped_ptr<HttpTransactionFactory> network_layer_;
 

net/quic/quic_stream_factory.h

@@ -158,6 +158,10 @@ class NET_EXPORT_PRIVATE QuicStreamFactory
 
   bool enable_port_selection() const { return enable_port_selection_; }
 
+  bool has_quic_server_info_factory() {
+    return quic_server_info_factory_ != NULL;
+  }
+
   void set_quic_server_info_factory(
       QuicServerInfoFactory* quic_server_info_factory) {
     DCHECK(!quic_server_info_factory_);

net/url_request/view_cache_helper_unittest.cc

@@ -9,6 +9,7 @@
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
+#include "net/http/http_transaction_test_util.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -29,7 +30,7 @@ class TestURLRequestContext : public URLRequestContext {
 };
 
 TestURLRequestContext::TestURLRequestContext()
-    : cache_(reinterpret_cast<HttpTransactionFactory*>(NULL), NULL,
+    : cache_(new MockNetworkLayer(), NULL,
              HttpCache::DefaultBackend::InMemory(0)) {
   set_http_transaction_factory(&cache_);
 }

tools/gn/secondary/chrome/BUILD.gn

@@ -122,6 +122,12 @@ source_set("debugger") {
     "browser/devtools/devtools_file_helper.h",
     "browser/devtools/devtools_file_system_indexer.cc",
     "browser/devtools/devtools_file_system_indexer.h",
+    "browser/devtools/devtools_network_controller.cpp",
+    "browser/devtools/devtools_network_controller.h",
+    "browser/devtools/devtools_network_transaction.cpp",
+    "browser/devtools/devtools_network_transaction.h",
+    "browser/devtools/devtools_network_transaction_factory.cpp",
+    "browser/devtools/devtools_network_transaction_factory.h",
     "browser/devtools/devtools_protocol.cc",
     "browser/devtools/devtools_protocol.h",
     "browser/devtools/devtools_toggle_action.h",