DevTools: make network conditions emulation scoped (browser)

chrome/browser/devtools/devtools_network_controller.cc

Index: chrome/browser/devtools/devtools_network_controller.cc
diff --git a/chrome/browser/devtools/devtools_network_controller.cc b/chrome/browser/devtools/devtools_network_controller.cc
index 176ac6655dba216d1251f908d5f0fcba088fceca..3437a1924de3d90a93fe377d773a2049382a8b26 100644
--- a/chrome/browser/devtools/devtools_network_controller.cc
+++ b/chrome/browser/devtools/devtools_network_controller.cc
@@ -4,23 +4,15 @@
 
 #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_realm.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"
+#include "net/base/load_flags.h"
+#include "net/http/http_request_info.h"
 
 using content::BrowserThread;
 
-namespace {
-
-const char kDevToolsRequestInitiator[] = "X-DevTools-Request-Initiator";
-int64_t kPacketSize = 1500;
-
-}  // namespace
-
 DevToolsNetworkController::DevToolsNetworkController()
     : weak_ptr_factory_(this) {
 }
@@ -40,16 +32,20 @@ void DevToolsNetworkController::RemoveTransaction(
   DCHECK(transactions_.find(transaction) != transactions_.end());
   transactions_.erase(transaction);
 
-  if (conditions_ && conditions_->IsThrottling()) {
-    UpdateThrottles();
-    throttled_transactions_.erase(std::remove(throttled_transactions_.begin(),
-        throttled_transactions_.end(), transaction),
-        throttled_transactions_.end());
-    ArmTimer();
+  if (has_throttling_realms_) {
+    if (DevToolsNetworkRealm* realm = FindRealm(transaction))
+      realm->RemoveTransaction(transaction);
   }
 }
 
+DevToolsNetworkRealm* DevToolsNetworkController::FindRealm(
+    const DevToolsNetworkTransaction* transaction) {
+  const std::string& client_id = transaction->client_id();
+  return client_id.empty() ? NULL : realms_.get(client_id);
+}
+
 void DevToolsNetworkController::SetNetworkState(
+    const std::string& client_id,
     const scoped_refptr<DevToolsNetworkConditions> conditions) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
@@ -58,28 +54,40 @@ void DevToolsNetworkController::SetNetworkState(
       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());
-  if (conditions_ && conditions_->IsThrottling())
-    UpdateThrottles();
-
-  conditions_ = conditions;
-  if (!conditions || !(conditions->IsThrottling() || conditions->IsOffline())) {
-    timer_.Stop();
-    int64_t length = throttled_transactions_.size();
-    for (int64_t i = 0; i < length; ++i)
-        throttled_transactions_[i]->FireThrottledCallback();
-    throttled_transactions_.clear();
+
+  DevToolsNetworkRealm* realm = realms_.get(client_id);
+  if (!realm) {
+    if (!conditions)
+      return;
+    Realm new_realm = Realm(new DevToolsNetworkRealm());
+    new_realm->UpdateConditions(conditions);
+    realms_.set(client_id, new_realm.Pass());
+  } else {
+    realm->UpdateConditions(conditions);
+    if (!conditions)
+      realms_.erase(client_id);
   }
 
-  if (!conditions)
-    return;
+  bool has_offline_realms = false;
+  bool has_throttling_realms = false;
+  for (Realms::iterator it = realms_.begin(); it != realms_.end(); ++it) {
+    has_offline_realms =
+        has_offline_realms || it->second->conditions()->IsOffline();
+    has_throttling_realms =
+        has_throttling_realms || it->second->conditions()->IsThrottling();
+  }
+  has_offline_realms_ = has_offline_realms;
+  has_throttling_realms_ = has_throttling_realms;
 
-  if (conditions_->IsOffline()) {
+  if (conditions && 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_);

[vsevik, 2014/06/18 09:18:04]

Why is this handled in controller, not realm?
We are trying to completely separate network transactions processing for
different clients, let's do EVERYTHING client-specific in a separate instance .

[eustas, 2014/06/18 11:45:10]

Done.

@@ -89,115 +97,52 @@ void DevToolsNetworkController::SetNetworkStateOnIO(
         continue;
       if (!(*it)->request() || (*it)->failed())
         continue;
-      if (ShouldFail((*it)->request()))
+      if (ShouldFail(*it))
         (*it)->Fail();
     }
   }
-
-  if (conditions_->IsThrottling()) {
-    DCHECK(conditions_->maximal_throughput() != 0);
-    offset_ = base::TimeTicks::Now();
-    last_tick_ = 0;
-    int64_t us_tick_length =
-        (1000000L * kPacketSize) / conditions_->maximal_throughput();
-    DCHECK(us_tick_length != 0);
-    if (us_tick_length == 0)
-      us_tick_length = 1;
-    tick_length_ = base::TimeDelta::FromMicroseconds(us_tick_length);
-    ArmTimer();
-  }
 }
 
 bool DevToolsNetworkController::ShouldFail(
-    const net::HttpRequestInfo* request) {
+    const DevToolsNetworkTransaction* transaction) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(request);
-  if (!conditions_ || !conditions_->IsOffline())
+  if (!has_offline_realms_)
+    return false;
+
+  if (!transaction->request())
     return false;
 
-  if (!conditions_->HasMatchingDomain(request->url))
+  if (!transaction->request_initiator().empty())
     return false;
 
-  return !request->extra_headers.HasHeader(kDevToolsRequestInitiator);
+  if (DevToolsNetworkRealm* realm = FindRealm(transaction))
+    return realm->conditions()->IsOffline();
+
+  // Temporary workaround for AppCache.
+  int load_flags = transaction->request()->load_flags;
+  return (load_flags & net::LOAD_DISABLE_INTERCEPT) != 0;
 }
 
 bool DevToolsNetworkController::ShouldThrottle(
-    const net::HttpRequestInfo* request) {
+    const DevToolsNetworkTransaction* transaction) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(request);
-  if (!conditions_ || !conditions_->IsThrottling())
+  if (!has_throttling_realms_)
     return false;
 
-  if (!conditions_->HasMatchingDomain(request->url))
+  if (!transaction->request())
     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 = throttled_transactions_.size();
-  if (!length)
-    return;
-
-  int64_t shift = ticks % length;
-  for (int64_t i = 0; i < length; ++i) {
-    throttled_transactions_[i]->DecreaseThrottledByteCount(
-        (ticks / length) * kPacketSize + (i < shift ? kPacketSize : 0));
-  }
-  std::rotate(throttled_transactions_.begin(),
-      throttled_transactions_.begin() + shift, throttled_transactions_.end());
-}
-
-void DevToolsNetworkController::OnTimer() {
-  UpdateThrottles();
-
-  std::vector<DevToolsNetworkTransaction*> active_transactions;
-  std::vector<DevToolsNetworkTransaction*> finished_transactions;
-  size_t length = throttled_transactions_.size();
-  for (size_t i = 0; i < length; ++i) {
-    if (throttled_transactions_[i]->throttled_byte_count() < 0)
-      finished_transactions.push_back(throttled_transactions_[i]);
-    else
-      active_transactions.push_back(throttled_transactions_[i]);
-  }
-  throttled_transactions_.swap(active_transactions);
-
-  length = finished_transactions.size();
-  for (size_t i = 0; i < length; ++i)
-      finished_transactions[i]->FireThrottledCallback();
+  if (!transaction->request_initiator().empty())
+    return false;
 
-  ArmTimer();
-}
+  if (DevToolsNetworkRealm* realm = FindRealm(transaction))
+    return realm->conditions()->IsThrottling();
 
-void DevToolsNetworkController::ArmTimer() {
-  size_t length = throttled_transactions_.size();
-  if (!length)
-    return;
-  int64_t min_ticks_left = 0x10000L;
-  for (size_t i = 0; i < length; ++i) {
-    int64_t packets_left = (throttled_transactions_[i]->throttled_byte_count() +
-        kPacketSize - 1) / kPacketSize;
-    int64_t ticks_left = (i + 1) + length * (packets_left - 1);
-    if (i == 0 || ticks_left < min_ticks_left)
-      min_ticks_left = ticks_left;
-  }
-  base::TimeTicks desired_time =
-      offset_ + tick_length_ * (last_tick_ + min_ticks_left);
-  timer_.Start(
-      FROM_HERE,
-      desired_time - base::TimeTicks::Now(),
-      base::Bind(
-          &DevToolsNetworkController::OnTimer,
-          weak_ptr_factory_.GetWeakPtr()));
+  return false;
 }
 
 void DevToolsNetworkController::ThrottleTransaction(
     DevToolsNetworkTransaction* transaction) {
-  UpdateThrottles();
-  throttled_transactions_.push_back(transaction);
-  ArmTimer();
+  if (DevToolsNetworkRealm* realm = FindRealm(transaction))
+    realm->ThrottleTransaction(transaction);
 }