[DevTools] Call directly into underlying http transaction when throttling is disabled.

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_interceptor.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/net_errors.h"
@@ skipping 132 matching lines @@
   interceptor_ = controller_->GetInterceptor(client_id);
 
   if (interceptor_ && interceptor_->ShouldFail()) {
     failed_ = true;
     network_transaction_->SetBeforeNetworkStartCallback(
         BeforeNetworkStartCallback());
     interceptor_.reset();
     return net::ERR_INTERNET_DISCONNECTED;
   }
 
-  if (interceptor_)
-    interceptor_->AddThrottable(this);
+  if (!interceptor_)
+    return network_transaction_->Start(request_, callback, net_log);
+
+  interceptor_->AddThrottable(this);
   int rv = network_transaction_->Start(request_, proxy_callback_, net_log);
   return SetupCallback(callback, rv, START);
 }
 
 void DevToolsNetworkTransaction::ProcessRequest(std::string* client_id) {
   DCHECK(request_);
   bool has_devtools_client_id = request_->extra_headers.HasHeader(
       kDevToolsEmulateNetworkConditionsClientId);
   if (!has_devtools_client_id)
     return;
 
   custom_request_.reset(new net::HttpRequestInfo(*request_));
   custom_request_->extra_headers.GetHeader(
       kDevToolsEmulateNetworkConditionsClientId, client_id);
   custom_request_->extra_headers.RemoveHeader(
       kDevToolsEmulateNetworkConditionsClientId);
   request_ = custom_request_.get();
 }
 
 int DevToolsNetworkTransaction::RestartIgnoringLastError(
     const net::CompletionCallback& callback) {
   if (failed_)
     return net::ERR_INTERNET_DISCONNECTED;
+  if (!interceptor_)
+    return network_transaction_->RestartIgnoringLastError(callback);
   int rv = network_transaction_->RestartIgnoringLastError(proxy_callback_);
   return SetupCallback(callback, rv, RESTART_IGNORING_LAST_ERROR);
 }
 
 int DevToolsNetworkTransaction::RestartWithCertificate(
     net::X509Certificate* client_cert,
     net::SSLPrivateKey* client_private_key,
     const net::CompletionCallback& callback) {
   if (failed_)
     return net::ERR_INTERNET_DISCONNECTED;
+  if (!interceptor_) {
+    return network_transaction_->RestartWithCertificate(
+        client_cert, client_private_key, callback);
+  }
   int rv = network_transaction_->RestartWithCertificate(
       client_cert, client_private_key, proxy_callback_);
   return SetupCallback(callback, rv, RESTART_WITH_CERTIFICATE);
 }
 
 int DevToolsNetworkTransaction::RestartWithAuth(
     const net::AuthCredentials& credentials,
     const net::CompletionCallback& callback) {
   if (failed_)
     return net::ERR_INTERNET_DISCONNECTED;
+  if (!interceptor_)
+    return network_transaction_->RestartWithAuth(credentials, callback);
   int rv = network_transaction_->RestartWithAuth(credentials, proxy_callback_);
   return SetupCallback(callback, rv, RESTART_WITH_AUTH);
 }
 
 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;
+  if (!interceptor_)
+    return network_transaction_->Read(buf, buf_len, callback);
   int rv = network_transaction_->Read(buf, buf_len, proxy_callback_);
   return SetupCallback(callback, rv, READ);
 }
 
 void DevToolsNetworkTransaction::StopCaching() {
   network_transaction_->StopCaching();
 }
 
 bool DevToolsNetworkTransaction::GetFullRequestHeaders(
     net::HttpRequestHeaders* headers) const {
@@ skipping 55 matching lines @@
 }
 
 void DevToolsNetworkTransaction::SetBeforeProxyHeadersSentCallback(
     const BeforeProxyHeadersSentCallback& callback) {
   network_transaction_->SetBeforeProxyHeadersSentCallback(callback);
 }
 
 int DevToolsNetworkTransaction::ResumeNetworkStart() {
   if (failed_)
     return net::ERR_INTERNET_DISCONNECTED;
+  if (!interceptor_)
+    return network_transaction_->ResumeNetworkStart();
   return network_transaction_->ResumeNetworkStart();
 }
 
 void
 DevToolsNetworkTransaction::GetConnectionAttempts(net::ConnectionAttempts* out)
 const {
   network_transaction_->GetConnectionAttempts(out);
 }
 
 void DevToolsNetworkTransaction::ThrottleFinished() {
   DCHECK(!callback_.is_null());
   DCHECK(callback_type_ == READ || callback_type_ == START);
   net::CompletionCallback callback = callback_;
   callback_.Reset();
   callback_type_ = NONE;
   callback.Run(throttled_result_);
 }