DevToolsNetworkController: support "limit throughput" network condition.

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),
+      callback_type_(NONE),
       proxy_callback_(base::Bind(&DevToolsNetworkTransaction::OnCallback,
                                  base::Unretained(this))) {
   DCHECK(controller);
   controller->AddTransaction(this);
 }
 
 DevToolsNetworkTransaction::~DevToolsNetworkTransaction() {
   controller_->RemoveTransaction(this);
 }
 
+void DevToolsNetworkTransaction::Throttle(int result) {
+  throttled_result_ = result;
+  int64_t penalty = 0;
+  if (callback_type_ == START)
+    penalty += network_transaction_->GetTotalReceivedBytes();
+  if (result > 0)
+    penalty += result;
+  controller_->ThrottleTransaction(this, penalty);

[vsevik, 2014/06/11 08:10:34]

We should make sure we do not callback synchronously in case of zero penalty
here.

[eustas, 2014/06/11 10:54:26]

Done.

+}
+
 void DevToolsNetworkTransaction::OnCallback(int rv) {
   if (failed_)
     return;
   DCHECK(!callback_.is_null());
+  if (callback_type_ == START || callback_type_ == READ) {
+    if (controller_->ShouldThrottle(request_)) {
+      Throttle(rv);
+      return;
+    }
+  }
   net::CompletionCallback callback = callback_;
   callback_.Reset();
+  callback_type_ = NONE;
   callback.Run(rv);
 }
 
+int DevToolsNetworkTransaction::SetupCallback(

[vsevik, 2014/06/11 08:10:34]

DCHECK(callback_type_ == NONE);

if (result == net::ERR_IO_PENDING) {
  callback_type_ = callback_type;
  callback_ = callback;
  return result;
}

if (!controller_->ShouldThrottle(request_))
  return result;

// Comment this
if (callback_type == START && result < 0)
  return result;

// Comment this
if (callback_type == READ && result < 0)
  return result;

// Comment this
if (callback_type == READ && result == 0)
  return result;

if (callback_type != START && callback_type != READ)
  return result;

callback_type_ = callback_type;
callback_ = callback;
// This should never callback synchronously
Throttle(result);
return net::ERR_IO_PENDING;

[eustas, 2014/06/11 10:54:26]

Done.

+    net::CompletionCallback callback,
+    int result,
+    CallbackType callback_type) {
+  if (callback_type == START || (callback_type == READ && result > 0)) {

[vsevik, 2014/06/10 17:24:20]

Is it possible that result != net::ERR_IO_PENDING for START ? How could this
happen?

[vsevik, 2014/06/11 08:10:34]

Should we also throttle the result < 0 case here?

[eustas, 2014/06/11 10:54:26]

Yes, SPDY "push" streams can cause OK = 0 result.

[eustas, 2014/06/11 10:54:26]

Yes, even ERROR start may have caused network traffic.

+    if (controller_->ShouldThrottle(request_)) {
+      if (result != net::ERR_IO_PENDING) {
+        callback_type_ = callback_type;
+        callback_ = callback;
+        Throttle(result);

[vsevik, 2014/06/10 17:24:20]

Is it OK that we could callback before returning from the original network
transaction method?

[eustas, 2014/06/11 10:54:26]

Done.

+        return net::ERR_IO_PENDING;
+      }
+    }
+  }
+
+  if (result == net::ERR_IO_PENDING) {
+    callback_type_ = callback_type;
+    callback_ = callback;
+  } else {
+    callback_type_ = NONE;

[vsevik, 2014/06/11 08:10:34]

This is redundant, let's DCHECK(callback_type_ == NONE) in the beginning instead

[eustas, 2014/06/11 10:54:26]

Done.

+  }
+  return result;
+}
+
 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_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;
 
   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;
+  return SetupCallback(callback, rv, START);
 }
 
 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;
+  return SetupCallback(callback, rv, RESTART_IGNORING_LAST_ERROR);

[vsevik, 2014/06/10 17:24:20]

Is it somehow enforced that several of all these methods that setup callback
could not be called together (next could be called before the previous one
called back)

[eustas, 2014/06/11 10:54:26]

It is required by transaction contract, but not enforced.
Typical client is a carefully maintained state machine, so it is unlikely that
contract might be broken.

 }
 
 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;
+  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;
   int rv = network_transaction_->RestartWithAuth(credentials, proxy_callback_);
-  if (rv == net::ERR_IO_PENDING)
-    callback_ = callback;
-  return rv;
+  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;
   int rv = network_transaction_->Read(buf, buf_len, proxy_callback_);
-  if (rv == net::ERR_IO_PENDING)
-    callback_ = callback;
-  return rv;
+  return SetupCallback(callback, rv, READ);
 }
 
 void DevToolsNetworkTransaction::StopCaching() {
   network_transaction_->StopCaching();
 }
 
 bool DevToolsNetworkTransaction::GetFullRequestHeaders(
     net::HttpRequestHeaders* headers) const {
   return network_transaction_->GetFullRequestHeaders(headers);
 }
@@ skipping 41 matching lines @@
 void DevToolsNetworkTransaction::SetBeforeNetworkStartCallback(
     const BeforeNetworkStartCallback& callback) {
   network_transaction_->SetBeforeNetworkStartCallback(callback);
 }
 
 int DevToolsNetworkTransaction::ResumeNetworkStart() {
   if (failed_)
     return net::ERR_INTERNET_DISCONNECTED;
   return network_transaction_->ResumeNetworkStart();
 }
+
+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_);
+}