DevTools: make network conditions emulation scoped (browser)

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 "chrome/browser/devtools/devtools_network_realm.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"
 
+namespace {
+
+const char kDevToolsRequestInitiator[] = "X-DevTools-Request-Initiator";
+const char kDevToolsEmulateNetworkConditionsClientId[] =
+    "X-DevTools-Emulate-Network-Conditions-Client-Id";
+
+}  // namespace
+
 DevToolsNetworkTransaction::DevToolsNetworkTransaction(
     DevToolsNetworkController* controller,
     scoped_ptr<net::HttpTransaction> network_transaction)
     : controller_(controller),
       network_transaction_(network_transaction.Pass()),
       request_(NULL),
       failed_(false),
       throttled_byte_count_(0),
       callback_type_(NONE),
       proxy_callback_(base::Bind(&DevToolsNetworkTransaction::OnCallback,
                                  base::Unretained(this))) {
   DCHECK(controller);
-  controller->AddTransaction(this);
 }
 
 DevToolsNetworkTransaction::~DevToolsNetworkTransaction() {
-  controller_->RemoveTransaction(this);
+  if (realm_)
+    realm_->RemoveTransaction(this);
 }
 
 void DevToolsNetworkTransaction::Throttle(int result) {
   throttled_result_ = result;
 
   if (callback_type_ == START)
     throttled_byte_count_ += network_transaction_->GetTotalReceivedBytes();
   if (result > 0)
     throttled_byte_count_ += result;
 
-  controller_->ThrottleTransaction(this);
+  if (realm_)
+    realm_->ThrottleTransaction(this);
 }
 
 void DevToolsNetworkTransaction::OnCallback(int rv) {
   if (failed_)
     return;
   DCHECK(!callback_.is_null());
   if (callback_type_ == START || callback_type_ == READ) {
-    if (controller_->ShouldThrottle(request_)) {
+    if (realm_ && realm_->ShouldThrottle(this)) {
       Throttle(rv);
       return;
     }
   }
   net::CompletionCallback callback = callback_;
   callback_.Reset();
   callback_type_ = NONE;
   callback.Run(rv);
 }
 
 int DevToolsNetworkTransaction::SetupCallback(
     net::CompletionCallback callback,
     int result,
     CallbackType callback_type) {
   DCHECK(callback_type_ == NONE);
 
   if (result == net::ERR_IO_PENDING) {
     callback_type_ = callback_type;
     callback_ = callback;
     return result;
   }
 
-  if (!controller_->ShouldThrottle(request_))
+  if (!realm_ || !realm_->ShouldThrottle(this))
     return result;
 
   // Only START and READ operation throttling is supported.
   if (callback_type != START && callback_type != READ)
     return result;
 
   // In case of error |throttled_byte_count_| is unknown.
   if (result < 0)
     return result;
 
@@ skipping 20 matching lines @@
   callback_type_ = NONE;
   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;
+  realm_ = controller_->GetRealm(this);
+  realm_->AddTransaction(this);
 
-  if (controller_->ShouldFail(request_)) {
+  if (realm_->ShouldFail(this)) {
     failed_ = true;
     network_transaction_->SetBeforeNetworkStartCallback(
         BeforeNetworkStartCallback());
     return net::ERR_INTERNET_DISCONNECTED;
   }
-  int rv = network_transaction_->Start(request, proxy_callback_, net_log);
+  int rv = network_transaction_->Start(request_, proxy_callback_, net_log);
   return SetupCallback(callback, rv, START);
 }
 
+void DevToolsNetworkTransaction::ProcessRequest() {
+  DCHECK(request_);
+  bool hasDevToolsClientId = request_->extra_headers.HasHeader(

[vsevik, 2014/06/18 12:33:37]

has_devtools_...

[eustas, 2014/06/18 12:57:47]

Done.

+      kDevToolsEmulateNetworkConditionsClientId);
+  bool hasDevToolsRequestInitiator = request_->extra_headers.HasHeader(
+      kDevToolsRequestInitiator);
+  if (!hasDevToolsClientId && !hasDevToolsRequestInitiator)
+    return;
+
+  custom_request_.reset(new net::HttpRequestInfo(*request_));
+
+  if (hasDevToolsClientId) {
+    custom_request_->extra_headers.GetHeader(
+        kDevToolsEmulateNetworkConditionsClientId, &client_id_);
+    custom_request_->extra_headers.RemoveHeader(
+        kDevToolsEmulateNetworkConditionsClientId);
+  }
+
+  if (hasDevToolsRequestInitiator) {
+    custom_request_->extra_headers.GetHeader(
+        kDevToolsRequestInitiator, &request_initiator_);
+    custom_request_->extra_headers.RemoveHeader(kDevToolsRequestInitiator);
+  }
+
+  request_ = custom_request_.get();
+}
+
 int DevToolsNetworkTransaction::RestartIgnoringLastError(
     const net::CompletionCallback& callback) {
   if (failed_)
     return net::ERR_INTERNET_DISCONNECTED;
   int rv = network_transaction_->RestartIgnoringLastError(proxy_callback_);
   return SetupCallback(callback, rv, RESTART_IGNORING_LAST_ERROR);
 }
 
 int DevToolsNetworkTransaction::RestartWithCertificate(
     net::X509Certificate* client_cert,
@@ skipping 89 matching lines @@
 }
 
 void DevToolsNetworkTransaction::FireThrottledCallback() {
   DCHECK(!callback_.is_null());
   DCHECK(callback_type_ == READ || callback_type_ == START);
   net::CompletionCallback callback = callback_;
   callback_.Reset();
   callback_type_ = NONE;
   callback.Run(throttled_result_);
 }