DevTools: make network conditions emulation scoped (browser)

chrome/browser/devtools/devtools_network_realm.cc

Index: chrome/browser/devtools/devtools_network_realm.cc
diff --git a/chrome/browser/devtools/devtools_network_controller.cc b/chrome/browser/devtools/devtools_network_realm.cc
similarity index 53%
copy from chrome/browser/devtools/devtools_network_controller.cc
copy to chrome/browser/devtools/devtools_network_realm.cc
index 176ac6655dba216d1251f908d5f0fcba088fceca..a51c9b604d52629201e0985e7b4d1029856c4e31 100644
--- a/chrome/browser/devtools/devtools_network_controller.cc
+++ b/chrome/browser/devtools/devtools_network_realm.cc
@@ -2,73 +2,71 @@
 // 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 "chrome/browser/devtools/devtools_network_realm.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";
 int64_t kPacketSize = 1500;
 
 }  // namespace
 
-DevToolsNetworkController::DevToolsNetworkController()
-    : weak_ptr_factory_(this) {
+DevToolsNetworkRealm::DevToolsNetworkRealm()

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

DevToolsNetworkInterceptor

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

Done.

+    : conditions_(new DevToolsNetworkConditions()),
+      weak_ptr_factory_(this) {
+}
+
+DevToolsNetworkRealm::~DevToolsNetworkRealm() {
 }
 
-DevToolsNetworkController::~DevToolsNetworkController() {
+base::WeakPtr<DevToolsNetworkRealm> DevToolsNetworkRealm::GetWeakPtr() {
+  return weak_ptr_factory_.GetWeakPtr();
 }
 
-void DevToolsNetworkController::AddTransaction(
+void DevToolsNetworkRealm::AddTransaction(
     DevToolsNetworkTransaction* transaction) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(transactions_.find(transaction) == transactions_.end());
   transactions_.insert(transaction);
 }
 
-void DevToolsNetworkController::RemoveTransaction(
+void DevToolsNetworkRealm::RemoveTransaction(
     DevToolsNetworkTransaction* transaction) {
-  DCHECK(thread_checker_.CalledOnValidThread());
   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 (!conditions_->IsThrottling())
+    return;
 
-void DevToolsNetworkController::SetNetworkState(
-    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(),
-          conditions));
+  UpdateThrottles();
+  throttled_transactions_.erase(std::remove(throttled_transactions_.begin(),
+      throttled_transactions_.end(), transaction),
+      throttled_transactions_.end());
+  ArmTimer();
 }
 
-void DevToolsNetworkController::SetNetworkStateOnIO(
+void DevToolsNetworkRealm::UpdateConditions(
     const scoped_refptr<DevToolsNetworkConditions> conditions) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (conditions_ && conditions_->IsThrottling())
+  DCHECK(conditions);
+  if (conditions_->IsThrottling())
     UpdateThrottles();
 
   conditions_ = conditions;
-  if (!conditions || !(conditions->IsThrottling() || conditions->IsOffline())) {
+
+  if (conditions->IsThrottling()) {
+    DCHECK(conditions->download_throughput() != 0);
+    offset_ = base::TimeTicks::Now();
+    last_tick_ = 0;
+    int64_t us_tick_length =
+        (1000000L * kPacketSize) / conditions->download_throughput();
+    DCHECK(us_tick_length != 0);
+    if (us_tick_length == 0)
+      us_tick_length = 1;
+    tick_length_ = base::TimeDelta::FromMicroseconds(us_tick_length);
+    ArmTimer();
+  } else {
     timer_.Stop();

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

Why are you now doing this if we went offline?

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

OK. I've changed logic - now we process offline mode first and "clear"
throttles.

     int64_t length = throttled_transactions_.size();
     for (int64_t i = 0; i < length; ++i)
@@ -76,65 +74,21 @@ void DevToolsNetworkController::SetNetworkStateOnIO(
     throttled_transactions_.clear();
   }
 
-  if (!conditions)
-    return;
-
-  if (conditions_->IsOffline()) {
-    // Iterate over a copy of set, because failing of transaction could
-    // result in creating a new one, or (theoretically) destroying one.
+  if (conditions->offline()) {
     Transactions old_transactions(transactions_);
-    for (Transactions::iterator it = old_transactions.begin();
-         it != old_transactions.end(); ++it) {
+    Transactions::iterator it = old_transactions.begin();
+    for (;it != old_transactions.end(); ++it) {
       if (transactions_.find(*it) == transactions_.end())
         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) {
-  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() {
+void DevToolsNetworkRealm::UpdateThrottles() {
   int64_t last_tick = (base::TimeTicks::Now() - offset_) / tick_length_;
   int64_t ticks = last_tick - last_tick_;
   last_tick_ = last_tick;
@@ -152,7 +106,7 @@ void DevToolsNetworkController::UpdateThrottles() {
       throttled_transactions_.begin() + shift, throttled_transactions_.end());
 }
 
-void DevToolsNetworkController::OnTimer() {
+void DevToolsNetworkRealm::OnTimer() {
   UpdateThrottles();
 
   std::vector<DevToolsNetworkTransaction*> active_transactions;
@@ -173,7 +127,7 @@ void DevToolsNetworkController::OnTimer() {
   ArmTimer();
 }
 
-void DevToolsNetworkController::ArmTimer() {
+void DevToolsNetworkRealm::ArmTimer() {
   size_t length = throttled_transactions_.size();
   if (!length)
     return;
@@ -191,13 +145,35 @@ void DevToolsNetworkController::ArmTimer() {
       FROM_HERE,
       desired_time - base::TimeTicks::Now(),
       base::Bind(
-          &DevToolsNetworkController::OnTimer,
-          weak_ptr_factory_.GetWeakPtr()));
+          &DevToolsNetworkRealm::OnTimer,
+          base::Unretained(this)));
 }
 
-void DevToolsNetworkController::ThrottleTransaction(
+void DevToolsNetworkRealm::ThrottleTransaction(
     DevToolsNetworkTransaction* transaction) {
   UpdateThrottles();
   throttled_transactions_.push_back(transaction);
   ArmTimer();
 }
+
+bool DevToolsNetworkRealm::ShouldFail(
+    const DevToolsNetworkTransaction* transaction) {
+  if (!conditions_->offline())
+    return false;
+
+  if (!transaction->request_initiator().empty())
+    return false;
+
+  return true;
+}
+
+bool DevToolsNetworkRealm::ShouldThrottle(
+    const DevToolsNetworkTransaction* transaction) {
+  if (!conditions_->IsThrottling())
+    return false;
+
+  if (!transaction->request_initiator().empty())
+    return false;
+
+  return true;
+}