REVIEW: Re-use devtools network throttling from content layer

https://chromium-review.googlesource.com/c/chromium/src/+/664356

atom/browser/api/atom_api_session.cc

@@ -31,11 +31,11 @@
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "brightray/browser/media/media_device_id_salt.h"
-#include "brightray/browser/net/devtools_network_conditions.h"
-#include "brightray/browser/net/devtools_network_controller_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_service.h"
+#include "content/common/devtools/devtools_network_conditions.h"
+#include "content/common/devtools/devtools_network_controller.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_manager_delegate.h"
 #include "content/public/browser/storage_partition.h"
@@ -543,23 +543,20 @@ void Session::SetDownloadPath(const base::FilePath& path) {
 }
 
 void Session::EnableNetworkEmulation(const mate::Dictionary& options) {
-  std::unique_ptr<brightray::DevToolsNetworkConditions> conditions;
+  std::unique_ptr<content::DevToolsNetworkConditions> conditions;
   bool offline = false;
   double latency = 0.0, download_throughput = 0.0, upload_throughput = 0.0;
   if (options.Get("offline", &offline) && offline) {
-    conditions.reset(new brightray::DevToolsNetworkConditions(offline));
+    conditions.reset(new content::DevToolsNetworkConditions(offline));
   } else {
     options.Get("latency", &latency);
     options.Get("downloadThroughput", &download_throughput);
     options.Get("uploadThroughput", &upload_throughput);
-    conditions.reset(
+    conditions.reset(new content::DevToolsNetworkConditions(
-        new brightray::DevToolsNetworkConditions(false,
+        false, latency, download_throughput, upload_throughput));
-                                                 latency,
-                                                 download_throughput,
-                                                 upload_throughput));
   }
 
-  browser_context_->network_controller_handle()->SetNetworkState(
+  content::DevToolsNetworkController::SetNetworkState(
       devtools_network_emulation_client_id_, std::move(conditions));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
@@ -570,8 +567,8 @@ void Session::EnableNetworkEmulation(const mate::Dictionary& options) {
 }
 
 void Session::DisableNetworkEmulation() {
-  std::unique_ptr<brightray::DevToolsNetworkConditions> conditions;
+  auto conditions = base::MakeUnique<content::DevToolsNetworkConditions>();
-  browser_context_->network_controller_handle()->SetNetworkState(
+  content::DevToolsNetworkController::SetNetworkState(
       devtools_network_emulation_client_id_, std::move(conditions));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,

atom/browser/net/atom_network_delegate.cc

@@ -10,12 +10,12 @@
 #include "atom/common/native_mate_converters/net_converter.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
-#include "brightray/browser/net/devtools_network_transaction.h"
+#include "content/common/devtools/devtools_network_transaction.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "net/url_request/url_request.h"
 
-using brightray::DevToolsNetworkTransaction;
+using content::DevToolsNetworkTransaction;
 using content::BrowserThread;
 
 namespace atom {
@@ -266,9 +266,9 @@ int AtomNetworkDelegate::OnBeforeStartTransaction(
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
   if (!client_id_.empty())
-    headers->SetHeader(
+    headers->SetHeader(content::DevToolsNetworkTransaction::
-        DevToolsNetworkTransaction::kDevToolsEmulateNetworkConditionsClientId,
+                           kDevToolsEmulateNetworkConditionsClientId,
-        client_id_);
+                       client_id_);
   if (!base::ContainsKey(response_listeners_, kOnBeforeSendHeaders))
     return brightray::NetworkDelegate::OnBeforeStartTransaction(
         request, callback, headers);

atom/browser/net/url_request_fetch_job.cc

@@ -96,9 +96,9 @@ void URLRequestFetchJob::BeforeStartInUI(
     if (val->IsNull()) {
       // We have to create the URLRequestContextGetter on UI thread.
       url_request_context_getter_ = new brightray::URLRequestContextGetter(
-          this, nullptr, nullptr, base::FilePath(), true,
+          this, nullptr, base::FilePath(), true,
-          BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
+          BrowserThread::GetTaskRunnerForThread(BrowserThread::IO), nullptr,
-          nullptr, content::URLRequestInterceptorScopedVector());
+          content::URLRequestInterceptorScopedVector());
     } else {
       mate::Handle<api::Session> session;
       if (mate::ConvertFromV8(isolate, val, &session) && !session.IsEmpty()) {

brightray/browser/browser_context.cc

@@ -132,7 +132,6 @@ net::URLRequestContextGetter* BrowserContext::CreateRequestContext(
   DCHECK(!url_request_getter_.get());
   url_request_getter_ = new URLRequestContextGetter(
       this,
-      network_controller_handle(),
       static_cast<NetLog*>(BrowserClient::Get()->GetNetLog()),
       GetPath(),
       in_memory_,

brightray/browser/browser_context.h

@@ -11,7 +11,6 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "brightray/browser/media/media_device_id_salt.h"
-#include "brightray/browser/net/devtools_network_controller_handle.h"
 #include "brightray/browser/permission_manager.h"
 #include "brightray/browser/url_request_context_getter.h"
 #include "content/public/browser/browser_context.h"
@@ -76,10 +75,6 @@ class BrowserContext : public base::RefCounted<BrowserContext>,
     return url_request_getter_.get();
   }
 
-  DevToolsNetworkControllerHandle* network_controller_handle() {
-    return &network_controller_handle_;
-  }
-
   void InitPrefs();
   PrefService* prefs() { return prefs_.get(); }
 
@@ -126,8 +121,6 @@ class BrowserContext : public base::RefCounted<BrowserContext>,
   base::FilePath path_;
   bool in_memory_;
 
-  DevToolsNetworkControllerHandle network_controller_handle_;
-
   std::unique_ptr<ResourceContext> resource_context_;
   scoped_refptr<URLRequestContextGetter> url_request_getter_;
   scoped_refptr<storage::SpecialStoragePolicy> storage_policy_;

brightray/browser/devtools_manager_delegate.cc

@@ -12,7 +12,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "brightray/browser/net/devtools_network_protocol_handler.h"
 #include "brightray/common/content_client.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_frontend_host.h"
@@ -93,9 +92,7 @@ void DevToolsManagerDelegate::StartHttpHandler() {
       base::FilePath());
 }
 
-DevToolsManagerDelegate::DevToolsManagerDelegate()
+DevToolsManagerDelegate::DevToolsManagerDelegate() {}
-    : handler_(new DevToolsNetworkProtocolHandler) {
-}
 
 DevToolsManagerDelegate::~DevToolsManagerDelegate() {
 }
@@ -107,9 +104,6 @@ bool DevToolsManagerDelegate::HandleCommand(
     content::DevToolsAgentHost* agent_host,
     int session_id,
     base::DictionaryValue* command) {
-  if (handler_->HandleCommand(agent_host, command)) {
-    return true;
-  }
   return false;
 }
 

brightray/browser/devtools_manager_delegate.h

@@ -13,8 +13,6 @@
 
 namespace brightray {
 
-class DevToolsNetworkProtocolHandler;
-
 class DevToolsManagerDelegate : public content::DevToolsManagerDelegate {
  public:
   static void StartHttpHandler();
@@ -34,8 +32,6 @@ class DevToolsManagerDelegate : public content::DevToolsManagerDelegate {
   std::string GetFrontendResource(const std::string& path) override;
 
  private:
-  std::unique_ptr<DevToolsNetworkProtocolHandler> handler_;
-
   DISALLOW_COPY_AND_ASSIGN(DevToolsManagerDelegate);
 };
 

brightray/browser/net/devtools_network_conditions.cc

@@ -1,35 +0,0 @@
-// 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 "brightray/browser/net/devtools_network_conditions.h"
-
-namespace brightray {
-
-DevToolsNetworkConditions::DevToolsNetworkConditions(bool offline)
-    : offline_(offline),
-      latency_(0),
-      download_throughput_(0),
-      upload_throughput_(0) {
-}
-
-DevToolsNetworkConditions::DevToolsNetworkConditions(
-    bool offline,
-    double latency,
-    double download_throughput,
-    double upload_throughput)
-    : offline_(offline),
-      latency_(latency),
-      download_throughput_(download_throughput),
-      upload_throughput_(upload_throughput) {
-}
-
-DevToolsNetworkConditions::~DevToolsNetworkConditions() {
-}
-
-bool DevToolsNetworkConditions::IsThrottling() const {
-  return !offline_ && ((latency_ != 0.0) || (download_throughput_ != 0.0) ||
-      (upload_throughput_ != 0.0));
-}
-
-}  // namespace brightray

brightray/browser/net/devtools_network_conditions.h

@@ -1,39 +0,0 @@
-// 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.
-
-#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONDITIONS_H_
-#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONDITIONS_H_
-
-#include "base/macros.h"
-
-namespace brightray {
-
-class DevToolsNetworkConditions {
- public:
-  explicit DevToolsNetworkConditions(bool offline);
-  DevToolsNetworkConditions(bool offline,
-                            double latency,
-                            double download_throughput,
-                            double upload_throughput);
-  ~DevToolsNetworkConditions();
-
-  bool IsThrottling() const;
-
-  bool offline() const { return offline_; }
-  double latency() const { return latency_; }
-  double download_throughput() const { return download_throughput_; }
-  double upload_throughput() const { return upload_throughput_; }
-
- private:
-  const bool offline_;
-  const double latency_;
-  const double download_throughput_;
-  const double upload_throughput_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkConditions);
-};
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONDITIONS_H_

brightray/browser/net/devtools_network_controller.cc

@@ -1,78 +0,0 @@
-// Copyright (c) 2015 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-CHROMIUM file.
-
-#include "brightray/browser/net/devtools_network_controller.h"
-
-#include "base/bind.h"
-#include "brightray/browser/net/devtools_network_conditions.h"
-#include "brightray/browser/net/devtools_network_interceptor.h"
-#include "brightray/browser/net/devtools_network_transaction.h"
-#include "content/public/browser/browser_thread.h"
-
-using content::BrowserThread;
-
-namespace brightray {
-
-DevToolsNetworkController::DevToolsNetworkController()
-    : appcache_interceptor_(new DevToolsNetworkInterceptor) {
-}
-
-DevToolsNetworkController::~DevToolsNetworkController() {
-}
-
-void DevToolsNetworkController::SetNetworkState(
-    const std::string& client_id,
-    std::unique_ptr<DevToolsNetworkConditions> conditions) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  auto it = interceptors_.find(client_id);
-  if (it == interceptors_.end()) {
-    if (!conditions)
-      return;
-    std::unique_ptr<DevToolsNetworkInterceptor> new_interceptor(
-        new DevToolsNetworkInterceptor);
-    new_interceptor->UpdateConditions(std::move(conditions));
-    interceptors_[client_id] = std::move(new_interceptor);
-  } else {
-    if (!conditions) {
-      std::unique_ptr<DevToolsNetworkConditions> online_conditions(
-          new DevToolsNetworkConditions(false));
-      it->second->UpdateConditions(std::move(online_conditions));
-      interceptors_.erase(client_id);
-    } else {
-      it->second->UpdateConditions(std::move(conditions));
-    }
-  }
-
-  bool has_offline_interceptors = false;
-  for (const auto& interceptor : interceptors_) {
-    if (interceptor.second->IsOffline()) {
-      has_offline_interceptors = true;
-      break;
-    }
-  }
-
-  bool is_appcache_offline = appcache_interceptor_->IsOffline();
-  if (is_appcache_offline != has_offline_interceptors) {
-    std::unique_ptr<DevToolsNetworkConditions> appcache_conditions(
-        new DevToolsNetworkConditions(has_offline_interceptors));
-    appcache_interceptor_->UpdateConditions(std::move(appcache_conditions));
-  }
-}
-
-DevToolsNetworkInterceptor*
-DevToolsNetworkController::GetInterceptor(const std::string& client_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (interceptors_.empty() || client_id.empty())
-    return nullptr;
-
-  auto it = interceptors_.find(client_id);
-  if (it == interceptors_.end())
-    return nullptr;
-
-  return it->second.get();
-}
-
-}  // namespace brightray

brightray/browser/net/devtools_network_controller.h

@@ -1,44 +0,0 @@
-// Copyright (c) 2015 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-CHROMIUM file.
-
-#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_H_
-#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_H_
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-
-#include "base/macros.h"
-#include "base/threading/thread_checker.h"
-
-namespace brightray {
-
-class DevToolsNetworkConditions;
-class DevToolsNetworkInterceptor;
-class DevToolsNetworkTransaction;
-
-class DevToolsNetworkController {
- public:
-  DevToolsNetworkController();
-  virtual ~DevToolsNetworkController();
-
-  void SetNetworkState(const std::string& client_id,
-                       std::unique_ptr<DevToolsNetworkConditions> conditions);
-
-  DevToolsNetworkInterceptor* GetInterceptor(const std::string& client_id);
-
- private:
-  using InterceptorMap =
-      std::unordered_map<std::string,
-                         std::unique_ptr<DevToolsNetworkInterceptor>>;
-
-  std::unique_ptr<DevToolsNetworkInterceptor> appcache_interceptor_;
-  InterceptorMap interceptors_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkController);
-};
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_H_

brightray/browser/net/devtools_network_controller_handle.cc

@@ -1,60 +0,0 @@
-// Copyright (c) 2015 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-CHROMIUM file.
-
-#include "brightray/browser/net/devtools_network_controller_handle.h"
-
-#include "base/bind.h"
-#include "brightray/browser/net/devtools_network_conditions.h"
-#include "brightray/browser/net/devtools_network_controller.h"
-#include "content/public/browser/browser_thread.h"
-
-using content::BrowserThread;
-
-namespace brightray {
-
-DevToolsNetworkControllerHandle::DevToolsNetworkControllerHandle() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-}
-
-DevToolsNetworkControllerHandle::~DevToolsNetworkControllerHandle() {
-  BrowserThread::DeleteSoon(BrowserThread::IO,
-                            FROM_HERE,
-                            controller_.release());
-}
-
-void DevToolsNetworkControllerHandle::SetNetworkState(
-    const std::string& client_id,
-    std::unique_ptr<DevToolsNetworkConditions> conditions) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&DevToolsNetworkControllerHandle::SetNetworkStateOnIO,
-                 base::Unretained(this), client_id, base::Passed(&conditions)));
-}
-
-DevToolsNetworkController* DevToolsNetworkControllerHandle::GetController() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  LazyInitialize();
-  return controller_.get();
-}
-
-void DevToolsNetworkControllerHandle::LazyInitialize() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (!controller_)
-    controller_.reset(new DevToolsNetworkController);
-}
-
-void DevToolsNetworkControllerHandle::SetNetworkStateOnIO(
-    const std::string& client_id,
-    std::unique_ptr<DevToolsNetworkConditions> conditions) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  LazyInitialize();
-  controller_->SetNetworkState(client_id, std::move(conditions));
-}
-
-}  // namespace brightray

brightray/browser/net/devtools_network_controller_handle.h

@@ -1,45 +0,0 @@
-// Copyright (c) 2015 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-CHROMIUM file.
-
-#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_HANDLE_H_
-#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_HANDLE_H_
-
-#include <memory>
-#include <string>
-
-#include "base/macros.h"
-
-namespace brightray {
-
-class DevToolsNetworkConditions;
-class DevToolsNetworkController;
-
-// A handle to manage an IO-thread DevToolsNetworkController on the IO thread
-// while allowing SetNetworkState to be called from the UI thread.
-class DevToolsNetworkControllerHandle {
- public:
-  DevToolsNetworkControllerHandle();
-  ~DevToolsNetworkControllerHandle();
-
-  // Called on the UI thread.
-  void SetNetworkState(const std::string& client_id,
-                       std::unique_ptr<DevToolsNetworkConditions> conditions);
-
-  // Called on the IO thread.
-  DevToolsNetworkController* GetController();
-
- private:
-  void LazyInitialize();
-  void SetNetworkStateOnIO(
-      const std::string& client_id,
-      std::unique_ptr<DevToolsNetworkConditions> conditions);
-
-  std::unique_ptr<DevToolsNetworkController> controller_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkControllerHandle);
-};
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_HANDLE_H_

brightray/browser/net/devtools_network_interceptor.cc

@@ -1,293 +0,0 @@
-// 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 "brightray/browser/net/devtools_network_interceptor.h"
-
-#include <algorithm>
-#include <limits>
-
-#include "base/time/time.h"
-#include "brightray/browser/net/devtools_network_conditions.h"
-#include "net/base/net_errors.h"
-
-namespace brightray {
-
-namespace {
-
-int64_t kPacketSize = 1500;
-
-base::TimeDelta CalculateTickLength(double throughput) {
-  if (!throughput)
-    return base::TimeDelta();
-
-  int64_t us_tick_length = (1000000L * kPacketSize) / throughput;
-  if (us_tick_length == 0)
-    us_tick_length = 1;
-  return base::TimeDelta::FromMicroseconds(us_tick_length);
-}
-
-}  // namespace
-
-DevToolsNetworkInterceptor::ThrottleRecord::ThrottleRecord() {
-}
-
-DevToolsNetworkInterceptor::ThrottleRecord::ThrottleRecord(
-    const ThrottleRecord& other) = default;
-
-DevToolsNetworkInterceptor::ThrottleRecord::~ThrottleRecord() {
-}
-
-DevToolsNetworkInterceptor::DevToolsNetworkInterceptor()
-    : conditions_(new DevToolsNetworkConditions(false)),
-      download_last_tick_(0),
-      upload_last_tick_(0),
-      weak_ptr_factory_(this) {
-}
-
-DevToolsNetworkInterceptor::~DevToolsNetworkInterceptor() {
-}
-
-base::WeakPtr<DevToolsNetworkInterceptor>
-DevToolsNetworkInterceptor::GetWeakPtr() {
-  return weak_ptr_factory_.GetWeakPtr();
-}
-
-void DevToolsNetworkInterceptor::FinishRecords(
-    ThrottleRecords* records, bool offline) {
-  ThrottleRecords temp;
-  temp.swap(*records);
-  for (const ThrottleRecord& record : temp) {
-    bool failed = offline && !record.is_upload;
-    record.callback.Run(
-        failed ? net::ERR_INTERNET_DISCONNECTED : record.result,
-        record.bytes);
-  }
-}
-
-void DevToolsNetworkInterceptor::UpdateConditions(
-    std::unique_ptr<DevToolsNetworkConditions> conditions) {
-  DCHECK(conditions);
-  base::TimeTicks now = base::TimeTicks::Now();
-  if (conditions_->IsThrottling())
-    UpdateThrottled(now);
-
-  conditions_ = std::move(conditions);
-
-  bool offline = conditions_->offline();
-  if (offline || !conditions_->IsThrottling()) {
-    timer_.Stop();
-    FinishRecords(&download_, offline);
-    FinishRecords(&upload_, offline);
-    FinishRecords(&suspended_, offline);
-    return;
-  }
-
-  // Throttling.
-  DCHECK(conditions_->download_throughput() != 0 ||
-         conditions_->upload_throughput() != 0);
-  offset_ = now;
-
-  download_last_tick_ = 0;
-  download_tick_length_ = CalculateTickLength(
-      conditions_->download_throughput());
-
-  upload_last_tick_ = 0;
-  upload_tick_length_ = CalculateTickLength(conditions_->upload_throughput());
-
-  latency_length_ = base::TimeDelta();
-  double latency = conditions_->latency();
-  if (latency > 0)
-    latency_length_ = base::TimeDelta::FromMillisecondsD(latency);
-  ArmTimer(now);
-}
-
-uint64_t DevToolsNetworkInterceptor::UpdateThrottledRecords(
-    base::TimeTicks now,
-    ThrottleRecords* records,
-    uint64_t last_tick,
-    base::TimeDelta tick_length) {
-  if (tick_length.is_zero()) {
-    DCHECK(records->empty());
-    return last_tick;
-  }
-
-  int64_t new_tick = (now - offset_) / tick_length;
-  int64_t ticks = new_tick - last_tick;
-
-  int64_t length = records->size();
-  if (!length)
-    return new_tick;
-
-  int64_t shift = ticks % length;
-  for (int64_t i = 0; i < length; ++i) {
-    (*records)[i].bytes -=
-        (ticks / length) * kPacketSize + (i < shift ? kPacketSize : 0);
-  }
-  std::rotate(records->begin(), records->begin() + shift, records->end());
-  return new_tick;
-}
-
-void DevToolsNetworkInterceptor::UpdateThrottled(base::TimeTicks now) {
-  download_last_tick_ = UpdateThrottledRecords(
-      now, &download_, download_last_tick_, download_tick_length_);
-  upload_last_tick_ = UpdateThrottledRecords(
-      now, &upload_, upload_last_tick_, upload_tick_length_);
-  UpdateSuspended(now);
-}
-
-void DevToolsNetworkInterceptor::UpdateSuspended(base::TimeTicks now) {
-  int64_t activation_baseline =
-      (now - latency_length_ - base::TimeTicks()).InMicroseconds();
-  ThrottleRecords suspended;
-  for (const ThrottleRecord& record : suspended_) {
-    if (record.send_end <= activation_baseline) {
-      if (record.is_upload)
-        upload_.push_back(record);
-      else
-        download_.push_back(record);
-    } else {
-      suspended.push_back(record);
-    }
-  }
-  suspended_.swap(suspended);
-}
-
-void DevToolsNetworkInterceptor::CollectFinished(
-    ThrottleRecords* records, ThrottleRecords* finished) {
-  ThrottleRecords active;
-  for (const ThrottleRecord& record : *records) {
-    if (record.bytes < 0)
-      finished->push_back(record);
-    else
-      active.push_back(record);
-  }
-  records->swap(active);
-}
-
-void DevToolsNetworkInterceptor::OnTimer() {
-  base::TimeTicks now = base::TimeTicks::Now();
-  UpdateThrottled(now);
-
-  ThrottleRecords finished;
-  CollectFinished(&download_, &finished);
-  CollectFinished(&upload_, &finished);
-  for (const ThrottleRecord& record : finished)
-    record.callback.Run(record.result, record.bytes);
-
-  ArmTimer(now);
-}
-
-base::TimeTicks DevToolsNetworkInterceptor::CalculateDesiredTime(
-    const ThrottleRecords& records,
-    uint64_t last_tick,
-    base::TimeDelta tick_length) {
-  int64_t min_ticks_left = 0x10000L;
-  size_t count = records.size();
-  for (size_t i = 0; i < count; ++i) {
-    int64_t packets_left = (records[i].bytes + kPacketSize - 1) / kPacketSize;
-    int64_t ticks_left = (i + 1) + count * (packets_left - 1);
-    if (i == 0 || ticks_left < min_ticks_left)
-      min_ticks_left = ticks_left;
-  }
-  return offset_ + tick_length * (last_tick + min_ticks_left);
-}
-
-void DevToolsNetworkInterceptor::ArmTimer(base::TimeTicks now) {
-  size_t suspend_count = suspended_.size();
-  if (download_.empty() && upload_.empty() && !suspend_count) {
-    timer_.Stop();
-    return;
-  }
-
-  base::TimeTicks desired_time = CalculateDesiredTime(
-      download_, download_last_tick_, download_tick_length_);
-  if (desired_time == offset_) {
-    FinishRecords(&download_, false);
-  }
-
-  base::TimeTicks upload_time = CalculateDesiredTime(
-      upload_, upload_last_tick_, upload_tick_length_);
-  if (upload_time != offset_ && upload_time < desired_time)
-    desired_time = upload_time;
-
-  int64_t min_baseline = std::numeric_limits<int64_t>::max();
-  for (size_t i = 0; i < suspend_count; ++i) {
-    if (suspended_[i].send_end < min_baseline)
-      min_baseline = suspended_[i].send_end;
-  }
-  if (suspend_count) {
-    base::TimeTicks activation_time = base::TimeTicks() +
-        base::TimeDelta::FromMicroseconds(min_baseline) + latency_length_;
-    if (activation_time < desired_time)
-      desired_time = activation_time;
-  }
-
-  timer_.Start(
-      FROM_HERE, (desired_time - now).magnitude(),
-      base::Bind(&DevToolsNetworkInterceptor::OnTimer, base::Unretained(this)));
-}
-
-int DevToolsNetworkInterceptor::StartThrottle(
-    int result,
-    int64_t bytes,
-    base::TimeTicks send_end,
-    bool start,
-    bool is_upload,
-    const ThrottleCallback& callback) {
-  if (result < 0)
-    return result;
-
-  if (conditions_->offline())
-    return is_upload ? result : net::ERR_INTERNET_DISCONNECTED;
-
-  if ((is_upload && !conditions_->upload_throughput()) ||
-      (!is_upload && !conditions_->download_throughput())) {
-    return result;
-  }
-
-  ThrottleRecord record;
-  record.result = result;
-  record.bytes = bytes;
-  record.callback = callback;
-  record.is_upload = is_upload;
-
-  base::TimeTicks now = base::TimeTicks::Now();
-  UpdateThrottled(now);
-  if (start && latency_length_ != base::TimeDelta()) {
-    record.send_end = (send_end - base::TimeTicks()).InMicroseconds();
-    suspended_.push_back(record);
-    UpdateSuspended(now);
-  } else {
-    if (is_upload)
-      upload_.push_back(record);
-    else
-      download_.push_back(record);
-  }
-  ArmTimer(now);
-
-  return net::ERR_IO_PENDING;
-}
-
-void DevToolsNetworkInterceptor::StopThrottle(
-    const ThrottleCallback& callback) {
-  RemoveRecord(&download_, callback);
-  RemoveRecord(&upload_, callback);
-  RemoveRecord(&suspended_, callback);
-}
-
-void DevToolsNetworkInterceptor::RemoveRecord(
-    ThrottleRecords* records, const ThrottleCallback& callback) {
-  records->erase(
-      std::remove_if(records->begin(), records->end(),
-                     [&callback](const ThrottleRecord& record){
-                       return record.callback.Equals(callback);
-                     }),
-      records->end());
-}
-
-bool DevToolsNetworkInterceptor::IsOffline() {
-  return conditions_->offline();
-}
-
-}  // namespace brightray

brightray/browser/net/devtools_network_interceptor.h

@@ -1,107 +0,0 @@
-// 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.
-
-#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_INTERCEPTOR_H_
-#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_INTERCEPTOR_H_
-
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/timer/timer.h"
-
-namespace base {
-class TimeDelta;
-class TimeTicks;
-}
-
-namespace brightray {
-
-class DevToolsNetworkConditions;
-class DevToolsNetworkTransaction;
-
-class DevToolsNetworkInterceptor {
- public:
-  using ThrottleCallback = base::Callback<void(int, int64_t)>;
-
-  DevToolsNetworkInterceptor();
-  virtual ~DevToolsNetworkInterceptor();
-
-  base::WeakPtr<DevToolsNetworkInterceptor> GetWeakPtr();
-
-  // Applies network emulation configuration.
-  void UpdateConditions(std::unique_ptr<DevToolsNetworkConditions> conditions);
-
-  // Throttles with |is_upload == true| always succeed, even in offline mode.
-  int StartThrottle(int result,
-                    int64_t bytes,
-                    base::TimeTicks send_end,
-                    bool start,
-                    bool is_upload,
-                    const ThrottleCallback& callback);
-  void StopThrottle(const ThrottleCallback& callback);
-
-  bool IsOffline();
-
- private:
-  struct ThrottleRecord {
-   public:
-    ThrottleRecord();
-    ThrottleRecord(const ThrottleRecord& other);
-    ~ThrottleRecord();
-
-    int result;
-    int64_t bytes;
-    int64_t send_end;
-    bool is_upload;
-    ThrottleCallback callback;
-  };
-
-  using ThrottleRecords = std::vector<ThrottleRecord>;
-
-  void FinishRecords(ThrottleRecords* records, bool offline);
-
-  uint64_t UpdateThrottledRecords(base::TimeTicks now,
-                                  ThrottleRecords* records,
-                                  uint64_t last_tick,
-                                  base::TimeDelta tick_length);
-  void UpdateThrottled(base::TimeTicks now);
-  void UpdateSuspended(base::TimeTicks now);
-
-  void CollectFinished(ThrottleRecords* records, ThrottleRecords* finished);
-  void OnTimer();
-
-  base::TimeTicks CalculateDesiredTime(const ThrottleRecords& records,
-                                       uint64_t last_tick,
-                                       base::TimeDelta tick_length);
-  void ArmTimer(base::TimeTicks now);
-
-  void RemoveRecord(ThrottleRecords* records, const ThrottleCallback& callback);
-
-  std::unique_ptr<DevToolsNetworkConditions> conditions_;
-
-  // Throttables suspended for a "latency" period.
-  ThrottleRecords suspended_;
-
-  // Throttables waiting for certain amount of transfer to be "accounted".
-  ThrottleRecords download_;
-  ThrottleRecords upload_;
-
-  base::OneShotTimer timer_;
-  base::TimeTicks offset_;
-  base::TimeDelta download_tick_length_;
-  base::TimeDelta upload_tick_length_;
-  base::TimeDelta latency_length_;
-  uint64_t download_last_tick_;
-  uint64_t upload_last_tick_;
-
-  base::WeakPtrFactory<DevToolsNetworkInterceptor> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkInterceptor);
-};
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_INTERCEPTOR_H_

brightray/browser/net/devtools_network_protocol_handler.cc

@@ -1,173 +0,0 @@
-// Copyright (c) 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-CHROMIUM file.
-
-#include "brightray/browser/net/devtools_network_protocol_handler.h"
-
-#include <string>
-#include <utility>
-
-#include "base/memory/ptr_util.h"
-#include "base/strings/stringprintf.h"
-#include "brightray/browser/browser_context.h"
-#include "brightray/browser/net/devtools_network_conditions.h"
-#include "brightray/browser/net/devtools_network_controller.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/devtools_agent_host.h"
-
-namespace brightray {
-
-namespace {
-
-namespace params {
-
-const char kDownloadThroughput[] = "downloadThroughput";
-const char kLatency[] = "latency";
-const char kOffline[] = "offline";
-const char kUploadThroughput[] = "uploadThroughput";
-const char kResult[] = "result";
-const char kErrorCode[] = "code";
-const char kErrorMessage[] = "message";
-
-}  //  namespace params
-
-const char kEmulateNetworkConditions[] = "Network.emulateNetworkConditions";
-const char kCanEmulateNetworkConditions[] =
-    "Network.canEmulateNetworkConditions";
-const char kId[] = "id";
-const char kMethod[] = "method";
-const char kParams[] = "params";
-const char kError[] = "error";
-// JSON RPC 2.0 spec: http://www.jsonrpc.org/specification#error_object
-const int kErrorInvalidParams = -32602;
-
-bool ParseCommand(const base::DictionaryValue* command,
-                  int* id,
-                  std::string* method,
-                  const base::DictionaryValue** params) {
-  if (!command)
-    return false;
-
-  if (!command->GetInteger(kId, id) || *id < 0)
-    return false;
-
-  if (!command->GetString(kMethod, method))
-    return false;
-
-  if (!command->GetDictionary(kParams, params))
-    *params = nullptr;
-
-  return true;
-}
-
-std::unique_ptr<base::DictionaryValue>
-CreateSuccessResponse(int id, std::unique_ptr<base::DictionaryValue> result) {
-  auto response = base::MakeUnique<base::DictionaryValue>();
-  response->SetInteger(kId, id);
-  response->Set(params::kResult, std::move(result));
-  return response;
-}
-
-std::unique_ptr<base::DictionaryValue>
-CreateFailureResponse(int id, const std::string& param) {
-  auto response = base::MakeUnique<base::DictionaryValue>();
-  auto error_object = base::MakeUnique<base::DictionaryValue>();
-  error_object->SetInteger(params::kErrorCode, kErrorInvalidParams);
-  error_object->SetString(params::kErrorMessage,
-      base::StringPrintf("Missing or Invalid '%s' parameter", param.c_str()));
-  response->Set(kError, std::move(error_object));
-  return response;
-}
-
-}  // namespace
-
-DevToolsNetworkProtocolHandler::DevToolsNetworkProtocolHandler() {
-}
-
-DevToolsNetworkProtocolHandler::~DevToolsNetworkProtocolHandler() {
-}
-
-base::DictionaryValue* DevToolsNetworkProtocolHandler::HandleCommand(
-    content::DevToolsAgentHost* agent_host,
-    base::DictionaryValue* command) {
-  int id = 0;
-  std::string method;
-  const base::DictionaryValue* params = nullptr;
-
-  if (!ParseCommand(command, &id, &method, &params))
-    return nullptr;
-
-  if (method == kEmulateNetworkConditions)
-    return EmulateNetworkConditions(agent_host, id, params).release();
-
-  if (method == kCanEmulateNetworkConditions)
-    return CanEmulateNetworkConditions(agent_host, id, params).release();
-
-  return nullptr;
-}
-
-void DevToolsNetworkProtocolHandler::DevToolsAgentStateChanged(
-    content::DevToolsAgentHost* agent_host,
-    bool attached) {
-  std::unique_ptr<DevToolsNetworkConditions> conditions;
-  if (attached)
-    conditions.reset(new DevToolsNetworkConditions(false));
-  UpdateNetworkState(agent_host, std::move(conditions));
-}
-
-std::unique_ptr<base::DictionaryValue>
-DevToolsNetworkProtocolHandler::CanEmulateNetworkConditions(
-    content::DevToolsAgentHost* agent_host,
-    int id,
-    const base::DictionaryValue* params) {
-  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
-  result->SetBoolean(params::kResult, true);
-  return CreateSuccessResponse(id, std::move(result));
-}
-
-std::unique_ptr<base::DictionaryValue>
-DevToolsNetworkProtocolHandler::EmulateNetworkConditions(
-    content::DevToolsAgentHost* agent_host,
-    int id,
-    const base::DictionaryValue* params) {
-  bool offline = false;
-  if (!params || !params->GetBoolean(params::kOffline, &offline))
-    return CreateFailureResponse(id, params::kOffline);
-
-  double latency = 0.0;
-  if (!params->GetDouble(params::kLatency, &latency))
-    return CreateFailureResponse(id, params::kLatency);
-  if (latency < 0.0)
-    latency = 0.0;
-
-  double download_throughput = 0.0;
-  if (!params->GetDouble(params::kDownloadThroughput, &download_throughput))
-    return CreateFailureResponse(id, params::kDownloadThroughput);
-  if (download_throughput < 0.0)
-    download_throughput = 0.0;
-
-  double upload_throughput = 0.0;
-  if (!params->GetDouble(params::kUploadThroughput, &upload_throughput))
-    return CreateFailureResponse(id, params::kUploadThroughput);
-  if (upload_throughput < 0.0)
-    upload_throughput = 0.0;
-
-  std::unique_ptr<DevToolsNetworkConditions> conditions(
-      new DevToolsNetworkConditions(offline,
-                                    latency,
-                                    download_throughput,
-                                    upload_throughput));
-  UpdateNetworkState(agent_host, std::move(conditions));
-  return std::unique_ptr<base::DictionaryValue>();
-}
-
-void DevToolsNetworkProtocolHandler::UpdateNetworkState(
-    content::DevToolsAgentHost* agent_host,
-    std::unique_ptr<DevToolsNetworkConditions> conditions) {
-  auto browser_context =
-      static_cast<brightray::BrowserContext*>(agent_host->GetBrowserContext());
-  browser_context->network_controller_handle()->SetNetworkState(
-      agent_host->GetId(), std::move(conditions));
-}
-
-}  // namespace brightray

brightray/browser/net/devtools_network_protocol_handler.h

@@ -1,48 +0,0 @@
-// 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.
-
-#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_PROTOCOL_HANDLER_H_
-#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_PROTOCOL_HANDLER_H_
-
-#include "base/macros.h"
-#include "base/values.h"
-
-namespace content {
-class DevToolsAgentHost;
-}
-
-namespace brightray {
-
-class DevToolsNetworkConditions;
-
-class DevToolsNetworkProtocolHandler {
- public:
-  DevToolsNetworkProtocolHandler();
-  ~DevToolsNetworkProtocolHandler();
-
-  base::DictionaryValue* HandleCommand(
-      content::DevToolsAgentHost* agent_host,
-      base::DictionaryValue* command);
-  void DevToolsAgentStateChanged(content::DevToolsAgentHost* agent_host,
-                                 bool attached);
-
- private:
-  std::unique_ptr<base::DictionaryValue> CanEmulateNetworkConditions(
-      content::DevToolsAgentHost* agent_host,
-      int command_id,
-      const base::DictionaryValue* params);
-  std::unique_ptr<base::DictionaryValue> EmulateNetworkConditions(
-      content::DevToolsAgentHost* agent_host,
-      int command_id,
-      const base::DictionaryValue* params);
-  void UpdateNetworkState(
-      content::DevToolsAgentHost* agent_host,
-      std::unique_ptr<DevToolsNetworkConditions> conditions);
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkProtocolHandler);
-};
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_PROTOCOL_HANDLER_H_

brightray/browser/net/devtools_network_transaction.cc

@@ -1,302 +0,0 @@
-// Copyright (c) 2015 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-CHROMIUM file.
-
-#include "brightray/browser/net/devtools_network_transaction.h"
-
-#include <string>
-#include <utility>
-
-#include "brightray/browser/net/devtools_network_controller.h"
-#include "brightray/browser/net/devtools_network_upload_data_stream.h"
-#include "net/base/load_timing_info.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"
-#include "net/socket/connection_attempts.h"
-
-namespace brightray {
-
-// static
-const char
-    DevToolsNetworkTransaction::kDevToolsEmulateNetworkConditionsClientId[] =
-        "X-DevTools-Emulate-Network-Conditions-Client-Id";
-
-DevToolsNetworkTransaction::DevToolsNetworkTransaction(
-    DevToolsNetworkController* controller,
-    std::unique_ptr<net::HttpTransaction> transaction)
-    : throttled_byte_count_(0),
-      controller_(controller),
-      transaction_(std::move(transaction)),
-      request_(nullptr),
-      failed_(false) {
-  DCHECK(controller);
-}
-
-DevToolsNetworkTransaction::~DevToolsNetworkTransaction() {
-  if (interceptor_ && !throttle_callback_.is_null())
-    interceptor_->StopThrottle(throttle_callback_);
-}
-
-void DevToolsNetworkTransaction::IOCallback(
-    const net::CompletionCallback& callback, bool start, int result) {
-  result = Throttle(callback, start, result);
-  if (result != net::ERR_IO_PENDING)
-    callback.Run(result);
-}
-
-int DevToolsNetworkTransaction::Throttle(
-    const net::CompletionCallback& callback, bool start, int result) {
-  if (failed_)
-    return net::ERR_INTERNET_DISCONNECTED;
-  if (!interceptor_ || result < 0)
-    return result;
-
-  base::TimeTicks send_end;
-  if (start) {
-    throttled_byte_count_ += transaction_->GetTotalReceivedBytes();
-    net::LoadTimingInfo load_timing_info;
-    if (GetLoadTimingInfo(&load_timing_info))
-      send_end = load_timing_info.send_end;
-    if (send_end.is_null())
-      send_end = base::TimeTicks::Now();
-  }
-  if (result > 0)
-    throttled_byte_count_ += result;
-
-  throttle_callback_ = base::Bind(&DevToolsNetworkTransaction::ThrottleCallback,
-                                  base::Unretained(this),
-                                  callback);
-  int rv = interceptor_->StartThrottle(result, throttled_byte_count_, send_end,
-                                       start, false, throttle_callback_);
-  if (rv != net::ERR_IO_PENDING)
-    throttle_callback_.Reset();
-  if (rv == net::ERR_INTERNET_DISCONNECTED)
-    Fail();
-  return rv;
-}
-
-void DevToolsNetworkTransaction::ThrottleCallback(
-    const net::CompletionCallback& callback, int result, int64_t bytes) {
-  DCHECK(!throttle_callback_.is_null());
-  throttle_callback_.Reset();
-  if (result == net::ERR_INTERNET_DISCONNECTED)
-    Fail();
-  throttled_byte_count_ = bytes;
-  callback.Run(result);
-}
-
-void DevToolsNetworkTransaction::Fail() {
-  DCHECK(request_);
-  DCHECK(!failed_);
-  failed_ = true;
-  transaction_->SetBeforeNetworkStartCallback(BeforeNetworkStartCallback());
-  if (interceptor_)
-    interceptor_.reset();
-}
-
-bool DevToolsNetworkTransaction::CheckFailed() {
-  if (failed_)
-    return true;
-  if (interceptor_ && interceptor_->IsOffline()) {
-    Fail();
-    return true;
-  }
-  return false;
-}
-
-int DevToolsNetworkTransaction::Start(const net::HttpRequestInfo* request,
-                                      const net::CompletionCallback& callback,
-                                      const net::NetLogWithSource& net_log) {
-  DCHECK(request);
-  request_ = request;
-
-  std::string client_id;
-  bool has_devtools_client_id = request_->extra_headers.HasHeader(
-      kDevToolsEmulateNetworkConditionsClientId);
-  if (has_devtools_client_id) {
-    custom_request_.reset(new net::HttpRequestInfo(*request_));
-    custom_request_->extra_headers.GetHeader(
-        kDevToolsEmulateNetworkConditionsClientId, &client_id);
-    custom_request_->extra_headers.RemoveHeader(
-        kDevToolsEmulateNetworkConditionsClientId);
-
-    if (request_->upload_data_stream) {
-      custom_upload_data_stream_.reset(
-          new DevToolsNetworkUploadDataStream(request_->upload_data_stream));
-      custom_request_->upload_data_stream = custom_upload_data_stream_.get();
-    }
-
-    request_ = custom_request_.get();
-  }
-
-  DevToolsNetworkInterceptor* interceptor =
-      controller_->GetInterceptor(client_id);
-  if (interceptor) {
-    interceptor_ = interceptor->GetWeakPtr();
-    if (custom_upload_data_stream_)
-      custom_upload_data_stream_->SetInterceptor(interceptor);
-  }
-
-  if (CheckFailed())
-    return net::ERR_INTERNET_DISCONNECTED;
-
-  if (!interceptor_)
-    return transaction_->Start(request_, callback, net_log);
-
-  int result = transaction_->Start(request_,
-      base::Bind(&DevToolsNetworkTransaction::IOCallback,
-                 base::Unretained(this), callback, true),
-      net_log);
-  return Throttle(callback, true, result);
-}
-
-int DevToolsNetworkTransaction::RestartIgnoringLastError(
-    const net::CompletionCallback& callback) {
-  if (CheckFailed())
-    return net::ERR_INTERNET_DISCONNECTED;
-  if (!interceptor_)
-    return transaction_->RestartIgnoringLastError(callback);
-
-  int result = transaction_->RestartIgnoringLastError(
-      base::Bind(&DevToolsNetworkTransaction::IOCallback,
-                 base::Unretained(this), callback, true));
-  return Throttle(callback, true, result);
-}
-
-int DevToolsNetworkTransaction::RestartWithCertificate(
-    scoped_refptr<net::X509Certificate> client_cert,
-    scoped_refptr<net::SSLPrivateKey> client_private_key,
-    const net::CompletionCallback& callback) {
-  if (CheckFailed())
-    return net::ERR_INTERNET_DISCONNECTED;
-  if (!interceptor_) {
-    return transaction_->RestartWithCertificate(
-        std::move(client_cert), std::move(client_private_key), callback);
-  }
-
-  int result = transaction_->RestartWithCertificate(
-      std::move(client_cert), std::move(client_private_key),
-      base::Bind(&DevToolsNetworkTransaction::IOCallback,
-                 base::Unretained(this), callback, true));
-  return Throttle(callback, true, result);
-}
-
-int DevToolsNetworkTransaction::RestartWithAuth(
-    const net::AuthCredentials& credentials,
-    const net::CompletionCallback& callback) {
-  if (CheckFailed())
-    return net::ERR_INTERNET_DISCONNECTED;
-  if (!interceptor_)
-    return transaction_->RestartWithAuth(credentials, callback);
-
-  int result = transaction_->RestartWithAuth(credentials,
-      base::Bind(&DevToolsNetworkTransaction::IOCallback,
-                 base::Unretained(this), callback, true));
-  return Throttle(callback, true, result);
-}
-
-bool DevToolsNetworkTransaction::IsReadyToRestartForAuth() {
-  return transaction_->IsReadyToRestartForAuth();
-}
-
-int DevToolsNetworkTransaction::Read(
-    net::IOBuffer* buf,
-    int buf_len,
-    const net::CompletionCallback& callback) {
-  if (CheckFailed())
-    return net::ERR_INTERNET_DISCONNECTED;
-  if (!interceptor_)
-    return transaction_->Read(buf, buf_len, callback);
-
-  int result = transaction_->Read(buf, buf_len,
-      base::Bind(&DevToolsNetworkTransaction::IOCallback,
-                 base::Unretained(this), callback, false));
-  // URLRequestJob relies on synchronous end-of-stream notification.
-  if (result == 0)
-    return result;
-  return Throttle(callback, false, result);
-}
-
-void DevToolsNetworkTransaction::StopCaching() {
-  transaction_->StopCaching();
-}
-
-bool DevToolsNetworkTransaction::GetFullRequestHeaders(
-    net::HttpRequestHeaders* headers) const {
-  return transaction_->GetFullRequestHeaders(headers);
-}
-
-int64_t DevToolsNetworkTransaction::GetTotalReceivedBytes() const {
-  return transaction_->GetTotalReceivedBytes();
-}
-
-int64_t DevToolsNetworkTransaction::GetTotalSentBytes() const {
-  return transaction_->GetTotalSentBytes();
-}
-
-void DevToolsNetworkTransaction::DoneReading() {
-  transaction_->DoneReading();
-}
-
-const net::HttpResponseInfo*
-DevToolsNetworkTransaction::GetResponseInfo() const {
-  return transaction_->GetResponseInfo();
-}
-
-net::LoadState DevToolsNetworkTransaction::GetLoadState() const {
-  return transaction_->GetLoadState();
-}
-
-void DevToolsNetworkTransaction::SetQuicServerInfo(
-    net::QuicServerInfo* info) {
-  transaction_->SetQuicServerInfo(info);
-}
-
-bool DevToolsNetworkTransaction::GetLoadTimingInfo(
-    net::LoadTimingInfo* info) const {
-  return transaction_->GetLoadTimingInfo(info);
-}
-
-bool DevToolsNetworkTransaction::GetRemoteEndpoint(
-    net::IPEndPoint* endpoint) const {
-  return transaction_->GetRemoteEndpoint(endpoint);
-}
-
-void DevToolsNetworkTransaction::PopulateNetErrorDetails(
-    net::NetErrorDetails* details) const {
-  return transaction_->PopulateNetErrorDetails(details);
-}
-
-void DevToolsNetworkTransaction::SetPriority(net::RequestPriority priority) {
-  transaction_->SetPriority(priority);
-}
-
-void DevToolsNetworkTransaction::SetWebSocketHandshakeStreamCreateHelper(
-    net::WebSocketHandshakeStreamBase::CreateHelper* helper) {
-  transaction_->SetWebSocketHandshakeStreamCreateHelper(helper);
-}
-
-void DevToolsNetworkTransaction::SetBeforeNetworkStartCallback(
-    const BeforeNetworkStartCallback& callback) {
-  transaction_->SetBeforeNetworkStartCallback(callback);
-}
-
-void DevToolsNetworkTransaction::SetBeforeHeadersSentCallback(
-    const BeforeHeadersSentCallback& callback) {
-  transaction_->SetBeforeHeadersSentCallback(callback);
-}
-
-int DevToolsNetworkTransaction::ResumeNetworkStart() {
-  if (CheckFailed())
-    return net::ERR_INTERNET_DISCONNECTED;
-  return transaction_->ResumeNetworkStart();
-}
-
-void DevToolsNetworkTransaction::GetConnectionAttempts(
-    net::ConnectionAttempts* out) const {
-  transaction_->GetConnectionAttempts(out);
-}
-
-}  // namespace brightray

brightray/browser/net/devtools_network_transaction.h

@@ -1,113 +0,0 @@
-// 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.
-
-#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_H_
-#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_H_
-
-#include <stdint.h>
-
-#include "base/memory/weak_ptr.h"
-#include "brightray/browser/net/devtools_network_interceptor.h"
-#include "net/base/completion_callback.h"
-#include "net/base/load_states.h"
-#include "net/base/request_priority.h"
-#include "net/http/http_raw_request_headers.h"
-#include "net/http/http_transaction.h"
-
-namespace brightray {
-
-class DevToolsNetworkController;
-class DevToolsNetworkUploadDataStream;
-
-class DevToolsNetworkTransaction : public net::HttpTransaction {
- public:
-  static const char kDevToolsEmulateNetworkConditionsClientId[];
-
-  DevToolsNetworkTransaction(
-      DevToolsNetworkController* controller,
-      std::unique_ptr<net::HttpTransaction> network_transaction);
-  ~DevToolsNetworkTransaction() override;
-
-  // HttpTransaction methods:
-  int Start(const net::HttpRequestInfo* request,
-            const net::CompletionCallback& callback,
-            const net::NetLogWithSource& net_log) override;
-  int RestartIgnoringLastError(
-      const net::CompletionCallback& callback) override;
-  int RestartWithCertificate(
-      scoped_refptr<net::X509Certificate> client_cert,
-      scoped_refptr<net::SSLPrivateKey> client_private_key,
-      const net::CompletionCallback& callback) override;
-  int RestartWithAuth(const net::AuthCredentials& credentials,
-                      const net::CompletionCallback& callback) override;
-  bool IsReadyToRestartForAuth() override;
-
-  int Read(net::IOBuffer* buf,
-           int buf_len,
-           const net::CompletionCallback& callback) override;
-  void StopCaching() override;
-  bool GetFullRequestHeaders(net::HttpRequestHeaders* headers) const override;
-  int64_t GetTotalReceivedBytes() const override;
-  int64_t GetTotalSentBytes() const override;
-  void DoneReading() override;
-  const net::HttpResponseInfo* GetResponseInfo() const override;
-  net::LoadState GetLoadState() const override;
-  void SetQuicServerInfo(net::QuicServerInfo* quic_server_info) override;
-  bool GetLoadTimingInfo(net::LoadTimingInfo* load_timing_info) const override;
-  bool GetRemoteEndpoint(net::IPEndPoint* endpoint) const override;
-  void PopulateNetErrorDetails(net::NetErrorDetails* details) const override;
-  void SetPriority(net::RequestPriority priority) override;
-  void SetWebSocketHandshakeStreamCreateHelper(
-      net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) override;
-  void SetBeforeNetworkStartCallback(
-      const BeforeNetworkStartCallback& callback) override;
-  void SetBeforeHeadersSentCallback(
-      const BeforeHeadersSentCallback& callback) override;
-  int ResumeNetworkStart() override;
-  void GetConnectionAttempts(net::ConnectionAttempts* out) const override;
-
-  // FIXME(torycl) Implement these methods properly
-  void SetRequestHeadersCallback(net::RequestHeadersCallback callback) {}
-  void SetResponseHeadersCallback(net::ResponseHeadersCallback callback) {}
-
- private:
-  void Fail();
-  bool CheckFailed();
-
-  void IOCallback(const net::CompletionCallback& callback,
-                  bool start,
-                  int result);
-  int Throttle(const net::CompletionCallback& callback,
-               bool start,
-               int result);
-  void ThrottleCallback(const net::CompletionCallback& callback,
-                        int result,
-                        int64_t bytes);
-
-  DevToolsNetworkInterceptor::ThrottleCallback throttle_callback_;
-  int64_t throttled_byte_count_;
-
-  DevToolsNetworkController* controller_;
-  base::WeakPtr<DevToolsNetworkInterceptor> interceptor_;
-
-  // Modified upload data stream. Should be destructed after |custom_request_|.
-  std::unique_ptr<DevToolsNetworkUploadDataStream> custom_upload_data_stream_;
-
-  // Modified request. Should be destructed after |transaction_|.
-  std::unique_ptr<net::HttpRequestInfo> custom_request_;
-
-  // Original network transaction.
-  std::unique_ptr<net::HttpTransaction> transaction_;
-
-  const net::HttpRequestInfo* request_;
-
-  // True if Fail was already invoked.
-  bool failed_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkTransaction);
-};
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_H_

brightray/browser/net/devtools_network_transaction_factory.cc

@@ -1,53 +0,0 @@
-// Copyright (c) 2015 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-CHROMIUM file.
-
-#include "brightray/browser/net/devtools_network_transaction_factory.h"
-
-#include <set>
-#include <string>
-
-#include "brightray/browser/net/devtools_network_controller.h"
-#include "brightray/browser/net/devtools_network_transaction.h"
-#include "content/public/browser/service_worker_context.h"
-#include "net/base/net_errors.h"
-#include "net/http/http_network_layer.h"
-#include "net/http/http_network_transaction.h"
-
-namespace brightray {
-
-DevToolsNetworkTransactionFactory::DevToolsNetworkTransactionFactory(
-    DevToolsNetworkController* controller,
-    net::HttpNetworkSession* session)
-    : controller_(controller),
-      network_layer_(new net::HttpNetworkLayer(session)) {
-  std::set<std::string> headers;
-  headers.insert(
-      DevToolsNetworkTransaction::kDevToolsEmulateNetworkConditionsClientId);
-  content::ServiceWorkerContext::AddExcludedHeadersForFetchEvent(headers);
-}
-
-DevToolsNetworkTransactionFactory::~DevToolsNetworkTransactionFactory() {
-}
-
-int DevToolsNetworkTransactionFactory::CreateTransaction(
-    net::RequestPriority priority,
-    std::unique_ptr<net::HttpTransaction>* transaction) {
-  std::unique_ptr<net::HttpTransaction> new_transaction;
-  int rv = network_layer_->CreateTransaction(priority, &new_transaction);
-  if (rv != net::OK)
-    return rv;
-  transaction->reset(
-      new DevToolsNetworkTransaction(controller_, std::move(new_transaction)));
-  return net::OK;
-}
-
-net::HttpCache* DevToolsNetworkTransactionFactory::GetCache() {
-  return network_layer_->GetCache();
-}
-
-net::HttpNetworkSession* DevToolsNetworkTransactionFactory::GetSession() {
-  return network_layer_->GetSession();
-}
-
-}  // namespace brightray

brightray/browser/net/devtools_network_transaction_factory.h

@@ -1,39 +0,0 @@
-// Copyright (c) 2015 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-CHROMIUM file.
-
-#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_FACTORY_H_
-#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_FACTORY_H_
-
-#include "base/macros.h"
-#include "net/base/request_priority.h"
-#include "net/http/http_transaction_factory.h"
-
-namespace brightray {
-
-class DevToolsNetworkController;
-
-class DevToolsNetworkTransactionFactory : public net::HttpTransactionFactory {
- public:
-  explicit DevToolsNetworkTransactionFactory(
-      DevToolsNetworkController* controller,
-      net::HttpNetworkSession* session);
-  ~DevToolsNetworkTransactionFactory() override;
-
-  // net::HttpTransactionFactory:
-  int CreateTransaction(
-      net::RequestPriority priority,
-      std::unique_ptr<net::HttpTransaction>* transaction) override;
-  net::HttpCache* GetCache() override;
-  net::HttpNetworkSession* GetSession() override;
-
- private:
-  DevToolsNetworkController* controller_;
-  std::unique_ptr<net::HttpTransactionFactory> network_layer_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkTransactionFactory);
-};
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_FACTORY_H_

brightray/browser/net/devtools_network_upload_data_stream.cc

@@ -1,96 +0,0 @@
-// Copyright 2015 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 "brightray/browser/net/devtools_network_upload_data_stream.h"
-
-#include "net/base/net_errors.h"
-
-namespace brightray {
-
-DevToolsNetworkUploadDataStream::DevToolsNetworkUploadDataStream(
-    net::UploadDataStream* upload_data_stream)
-    : net::UploadDataStream(upload_data_stream->is_chunked(),
-                            upload_data_stream->identifier()),
-      throttle_callback_(
-          base::Bind(&DevToolsNetworkUploadDataStream::ThrottleCallback,
-                     base::Unretained(this))),
-      throttled_byte_count_(0),
-      upload_data_stream_(upload_data_stream) {
-}
-
-DevToolsNetworkUploadDataStream::~DevToolsNetworkUploadDataStream() {
-  if (interceptor_)
-    interceptor_->StopThrottle(throttle_callback_);
-}
-
-void DevToolsNetworkUploadDataStream::SetInterceptor(
-    DevToolsNetworkInterceptor* interceptor) {
-  DCHECK(!interceptor_);
-  if (interceptor)
-    interceptor_ = interceptor->GetWeakPtr();
-}
-
-bool DevToolsNetworkUploadDataStream::IsInMemory() const {
-  return false;
-}
-
-int DevToolsNetworkUploadDataStream::InitInternal(
-    const net::NetLogWithSource& net_log) {
-  throttled_byte_count_ = 0;
-  int result = upload_data_stream_->Init(
-      base::Bind(&DevToolsNetworkUploadDataStream::StreamInitCallback,
-                 base::Unretained(this)),
-      net_log);
-  if (result == net::OK && !is_chunked())
-    SetSize(upload_data_stream_->size());
-  return result;
-}
-
-void DevToolsNetworkUploadDataStream::StreamInitCallback(int result) {
-  if (!is_chunked())
-    SetSize(upload_data_stream_->size());
-  OnInitCompleted(result);
-}
-
-int DevToolsNetworkUploadDataStream::ReadInternal(
-    net::IOBuffer* buf, int buf_len) {
-  int result = upload_data_stream_->Read(buf, buf_len,
-      base::Bind(&DevToolsNetworkUploadDataStream::StreamReadCallback,
-                 base::Unretained(this)));
-  return ThrottleRead(result);
-}
-
-void DevToolsNetworkUploadDataStream::StreamReadCallback(int result) {
-  result = ThrottleRead(result);
-  if (result != net::ERR_IO_PENDING)
-    OnReadCompleted(result);
-}
-
-int DevToolsNetworkUploadDataStream::ThrottleRead(int result) {
-  if (is_chunked() && upload_data_stream_->IsEOF())
-    SetIsFinalChunk();
-
-  if (!interceptor_ || result < 0)
-    return result;
-
-  if (result > 0)
-    throttled_byte_count_ += result;
-  return interceptor_->StartThrottle(result, throttled_byte_count_,
-      base::TimeTicks(), false, true, throttle_callback_);
-}
-
-void DevToolsNetworkUploadDataStream::ThrottleCallback(
-    int result, int64_t bytes) {
-  throttled_byte_count_ = bytes;
-  OnReadCompleted(result);
-}
-
-void DevToolsNetworkUploadDataStream::ResetInternal() {
-  upload_data_stream_->Reset();
-  throttled_byte_count_ = 0;
-  if (interceptor_)
-    interceptor_->StopThrottle(throttle_callback_);
-}
-
-}  // namespace brightray

brightray/browser/net/devtools_network_upload_data_stream.h

@@ -1,50 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_UPLOAD_DATA_STREAM_H_
-#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_UPLOAD_DATA_STREAM_H_
-
-#include <stdint.h>
-
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "brightray/browser/net/devtools_network_interceptor.h"
-#include "net/base/upload_data_stream.h"
-
-namespace brightray {
-
-class DevToolsNetworkUploadDataStream : public net::UploadDataStream {
- public:
-  // Supplied |upload_data_stream| must outlive this object.
-  explicit DevToolsNetworkUploadDataStream(
-      net::UploadDataStream* upload_data_stream);
-  ~DevToolsNetworkUploadDataStream() override;
-
-  void SetInterceptor(DevToolsNetworkInterceptor* interceptor);
-
- private:
-  // net::UploadDataStream implementation.
-  bool IsInMemory() const override;
-  int InitInternal(const net::NetLogWithSource& net_log) override;
-  int ReadInternal(net::IOBuffer* buf, int buf_len) override;
-  void ResetInternal() override;
-
-  void StreamInitCallback(int result);
-  void StreamReadCallback(int result);
-
-  int ThrottleRead(int result);
-  void ThrottleCallback(int result, int64_t bytes);
-
-  DevToolsNetworkInterceptor::ThrottleCallback throttle_callback_;
-  int64_t throttled_byte_count_;
-
-  net::UploadDataStream* upload_data_stream_;
-  base::WeakPtr<DevToolsNetworkInterceptor> interceptor_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkUploadDataStream);
-};
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_UPLOAD_DATA_STREAM_H_

brightray/browser/url_request_context_getter.cc

@@ -13,8 +13,6 @@
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "brightray/browser/browser_client.h"
-#include "brightray/browser/net/devtools_network_controller_handle.h"
-#include "brightray/browser/net/devtools_network_transaction_factory.h"
 #include "brightray/browser/net/require_ct_delegate.h"
 #include "brightray/browser/net_log.h"
 #include "brightray/browser/network_delegate.h"
@@ -22,6 +20,7 @@
 #include "components/network_session_configurator/common/network_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cookie_store_factory.h"
+#include "content/public/browser/devtools_network_transaction_factory.h"
 #include "content/public/common/content_switches.h"
 #include "net/base/host_mapping_rules.h"
 #include "net/cert/cert_verifier.h"
@@ -120,7 +119,6 @@ URLRequestContextGetter::Delegate::GetCookieableSchemes() {
 
 URLRequestContextGetter::URLRequestContextGetter(
     Delegate* delegate,
-    DevToolsNetworkControllerHandle* handle,
     NetLog* net_log,
     const base::FilePath& base_path,
     bool in_memory,
@@ -128,7 +126,6 @@ URLRequestContextGetter::URLRequestContextGetter(
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector protocol_interceptors)
     : delegate_(delegate),
-      network_controller_handle_(handle),
       net_log_(net_log),
       base_path_(base_path),
       in_memory_(in_memory),
@@ -335,20 +332,10 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
       backend.reset(delegate_->CreateHttpCacheBackendFactory(base_path_));
     }
 
-    if (network_controller_handle_) {
+    storage_->set_http_transaction_factory(base::MakeUnique<net::HttpCache>(
-      storage_->set_http_transaction_factory(base::WrapUnique(
+        content::CreateDevToolsNetworkTransactionFactory(
-          new net::HttpCache(
+            http_network_session_.get()),
-              base::WrapUnique(new DevToolsNetworkTransactionFactory(
+        std::move(backend), false));
-                  network_controller_handle_->GetController(),
-                  http_network_session_.get())),
-              std::move(backend),
-              false)));
-    } else {
-      storage_->set_http_transaction_factory(base::WrapUnique(
-          new net::HttpCache(http_network_session_.get(),
-                             std::move(backend),
-                             false)));
-    }
 
     std::unique_ptr<net::URLRequestJobFactory> job_factory =
         delegate_->CreateURLRequestJobFactory(&protocol_handlers_);

brightray/browser/url_request_context_getter.h

@@ -35,7 +35,6 @@ class URLRequestJobFactory;
 namespace brightray {
 
 class RequireCTDelegate;
-class DevToolsNetworkControllerHandle;
 class NetLog;
 
 class URLRequestContextGetter : public net::URLRequestContextGetter {
@@ -64,7 +63,6 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
 
   URLRequestContextGetter(
       Delegate* delegate,
-      DevToolsNetworkControllerHandle* handle,
       NetLog* net_log,
       const base::FilePath& base_path,
       bool in_memory,
@@ -88,7 +86,6 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
  private:
   Delegate* delegate_;
 
-  DevToolsNetworkControllerHandle* network_controller_handle_;
   NetLog* net_log_;
   base::FilePath base_path_;
   bool in_memory_;

brightray/filenames.gypi

@@ -47,22 +47,6 @@
       'browser/media/media_device_id_salt.h',
       'browser/media/media_stream_devices_controller.cc',
       'browser/media/media_stream_devices_controller.h',
-      'browser/net/devtools_network_conditions.cc',
-      'browser/net/devtools_network_conditions.h',
-      'browser/net/devtools_network_controller.cc',
-      'browser/net/devtools_network_controller.h',
-      'browser/net/devtools_network_controller_handle.cc',
-      'browser/net/devtools_network_controller_handle.h',
-      'browser/net/devtools_network_interceptor.cc',
-      'browser/net/devtools_network_interceptor.h',
-      'browser/net/devtools_network_protocol_handler.cc',
-      'browser/net/devtools_network_protocol_handler.h',
-      'browser/net/devtools_network_transaction_factory.cc',
-      'browser/net/devtools_network_transaction_factory.h',
-      'browser/net/devtools_network_transaction.cc',
-      'browser/net/devtools_network_transaction.h',
-      'browser/net/devtools_network_upload_data_stream.cc',
-      'browser/net/devtools_network_upload_data_stream.h',
       'browser/net/require_ct_delegate.cc',
       'browser/net/require_ct_delegate.h',
       'browser/net_log.cc',