DevToolsNetworkController: support "limit throughput" network condition.

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 "base/time/time.h"
 #include "chrome/browser/devtools/devtools_network_conditions.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";
 
+struct Throttle {
+  DevToolsNetworkTransaction* transaction;
+  int64_t penalty;
+};
+
+int64_t kPacketSize = 1500;
+
 }  // 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);
+
+  size_t length = throttles_.size();
+  if (!length)

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

redundant

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

Done.

+    return;
+
+  for (size_t i = 0; i < length; ++i) {
+    if (throttles_[i].transaction == transaction)
+      throttles_[i].transaction = NULL;
+  }
 }
 
 void DevToolsNetworkController::SetNetworkState(
     const std::string& client_id,
     const scoped_refptr<DevToolsNetworkConditions> conditions) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &DevToolsNetworkController::SetNetworkStateOnIO,
           weak_ptr_factory_.GetWeakPtr(),
           client_id,
           conditions));
 }
 
 void DevToolsNetworkController::SetNetworkStateOnIO(
     const std::string& client_id,
     const scoped_refptr<DevToolsNetworkConditions> conditions) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  bool was_throttling = conditions_ && conditions_->IsThrottling();

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

Can we put the line below to the beginning of this method? Or even to the
calling function?
if (!conditions && client_id != active_client_id_)
    return;

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

Done.

+
   if (!conditions) {
     if (client_id == active_client_id_) {
       conditions_ = NULL;
       active_client_id_ = std::string();
+      if (was_throttling)
+        CancelThrottles();
     }
     return;
   }
+
+  // Prepare to update throughput.
+  if (was_throttling)

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

I think this calls should be noops in case we weren't previously throttling. Can
we avoid these checks?

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

Done.

+    UpdateThrottles();
+
   conditions_ = conditions;
   active_client_id_ = 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();
+  if (was_throttling)
+    FireThrottledCallbacks();
+
+  if (conditions_->IsOffline()) {
+    // 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();
+    }
+  }
+
+  if (conditions_->IsThrottling()) {
+    DCHECK(conditions_->maximal_throughput() != 0);
+    offset_ = base::TimeTicks::Now();
+    last_tick_ = 0;
+    tick_length_ = base::TimeDelta::FromMicroseconds(
+        1000000L * kPacketSize / conditions_->maximal_throughput());
+    ArmTimer();
+  } else if (was_throttling) {
+    CancelThrottles();

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

Can we join two Cancel... calls?

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

Done.

   }
 }
 
 bool DevToolsNetworkController::ShouldFail(
     const net::HttpRequestInfo* request) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(request);
   if (!conditions_ || !conditions_->IsOffline())
     return false;
 
   if (!conditions_->HasMatchingDomain(request->url))
     return false;
 
   return !request->extra_headers.HasHeader(kDevToolsRequestInitiator);
 }
+
+bool DevToolsNetworkController::ShouldThrottle(
+    const net::HttpRequestInfo* request) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(request);
+  if (!conditions_ || !conditions_->IsThrottling())
+    return false;
+
+  if (!conditions_->HasMatchingDomain(request->url))
+    return false;
+
+  return !request->extra_headers.HasHeader(kDevToolsRequestInitiator);
+}
+
+void DevToolsNetworkController::UpdateThrottles() {
+  int64_t last_tick = (base::TimeTicks::Now() - offset_) / tick_length_;
+  int64_t ticks = last_tick - last_tick_;
+  last_tick_ = last_tick;
+
+  int64_t length = throttles_.size();
+  if (!length)
+    return;
+
+  int64_t full_rounds = ticks / length;
+  int64_t reminder = ticks % length;

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

remainder :)

[vsevik, 2014/06/11 08:39:32]

last_throttle_to_get_packet

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

Done.

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

Thanks =)

+  Throttles throttles;
+  for (int64_t i = reminder; i < length; ++i) {
+    throttles.push_back(throttles_[i]);

[vsevik, 2014/06/11 08:39:32]

std::rotate FTW!

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

Done.

+    throttles.back().penalty -= (full_rounds * kPacketSize);
+  }
+  for (int64_t i = 0; i < reminder; ++i) {
+    throttles.push_back(throttles_[i]);
+    throttles.back().penalty -= ((full_rounds + 1) * kPacketSize);
+  }
+  throttles_.swap(throttles);
+}
+
+void DevToolsNetworkController::CancelThrottles() {
+  int64_t length = throttles_.size();
+  if (!length)
+    return;
+
+  Throttles throttles;
+  throttles_.swap(throttles);
+  for (int64_t i = 0; i < length; ++i) {
+    DevToolsNetworkTransaction* transaction = throttles[i].transaction;
+    if (transaction)
+      transaction->FireThrottledCallback();
+  }
+}
+
+void DevToolsNetworkController::FireThrottledCallbacks() {
+  size_t length = throttles_.size();
+  if (!length)
+    return;
+
+  Throttles active;
+  Throttles finished;
+  for (size_t i = 0; i < length; ++i) {
+    if (throttles_[i].penalty <= 0)
+      finished.push_back(throttles_[i]);
+    else
+      active.push_back(throttles_[i]);
+  }
+  throttles_.swap(active);
+
+  length = finished.size();
+  for (size_t i = 0; i < length; ++i) {
+    DevToolsNetworkTransaction* transaction = finished[i].transaction;
+    if (transaction)
+      transaction->FireThrottledCallback();
+  }
+}
+
+void DevToolsNetworkController::OnTimer() {
+  UpdateThrottles();
+  FireThrottledCallbacks();
+  ArmTimer();
+}
+
+void DevToolsNetworkController::ArmTimer() {
+  size_t length = throttles_.size();
+  if (!length)
+    return;
+  int64_t best_n;

[vsevik, 2014/06/11 08:39:32]

min_ticks_left

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

Done.

+  for (size_t i = 0; i < length; ++i) {
+    int64_t n1 = (throttles_[i].penalty + kPacketSize - 1) / kPacketSize;

[vsevik, 2014/06/11 08:39:32]

penalty_packets_left

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

Done.

+    int64_t n = (i + 1) + length * (n1 - 1);

[vsevik, 2014/06/11 08:39:32]

ticksLeft

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

Done.

+    if (i == 0 || n < best_n)
+      best_n = n;
+  }
+  base::TimeDelta desired_time = offset_ + tick_length_ * (last_tick_ + best_n);
+  timer_.Start(
+      FROM_HERE,
+      desired_time - base::TimeTicks::Now(),
+      base::Bind(
+          &DevToolsNetworkController::OnTimer,
+          weak_ptr_factory_.GetWeakPtr()));
+}
+
+void DevToolsNetworkController::ThrottleTransaction(
+    DevToolsNetworkTransaction* transaction,
+    int64_t penalty) {
+  UpdateThrottles();
+  throttles_.push_back({transaction, penalty});
+  FireThrottledCallbacks();
+  ArmTimer();
+}