[DevTools] Narrow down DevToolsNetworkInterceptor::Throttable.

chrome/browser/devtools/devtools_network_transaction.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/devtools/devtools_network_transaction.h"
 
 #include "chrome/browser/devtools/devtools_network_controller.h"
 #include "chrome/browser/devtools/devtools_network_interceptor.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/net_errors.h"
@@ skipping 20 matching lines @@
       proxy_callback_(base::Bind(&DevToolsNetworkTransaction::OnCallback,
                                  base::Unretained(this))) {
   DCHECK(controller);
 }
 
 DevToolsNetworkTransaction::~DevToolsNetworkTransaction() {
   if (interceptor_)
     interceptor_->RemoveThrottable(this);
 }
 
-bool DevToolsNetworkTransaction::HasStarted() {
-  return !!request_;
-}
-
-bool DevToolsNetworkTransaction::HasFailed() {
-  return failed_;
-}
-
 int64_t DevToolsNetworkTransaction::ThrottledByteCount() {
   return throttled_byte_count_;
 }
 
 void DevToolsNetworkTransaction::Throttled(int64_t count) {
   throttled_byte_count_ -= count;
 }
 
 void DevToolsNetworkTransaction::GetSendEndTiming(base::TimeTicks* send_end) {
   net::LoadTimingInfo load_timing_info;
@@ skipping 61 matching lines @@
   Throttle(result);
   return net::ERR_IO_PENDING;
 }
 
 void DevToolsNetworkTransaction::Fail() {
   DCHECK(request_);
   DCHECK(!failed_);
   failed_ = true;
   network_transaction_->SetBeforeNetworkStartCallback(
       BeforeNetworkStartCallback());
+  if (interceptor_) {
+    interceptor_->RemoveThrottable(this);
+    interceptor_.reset();
+  }
   if (callback_.is_null())
     return;
   net::CompletionCallback callback = callback_;
   callback_.Reset();
   callback_type_ = NONE;
   callback.Run(net::ERR_INTERNET_DISCONNECTED);
 }
 
 int DevToolsNetworkTransaction::Start(
     const net::HttpRequestInfo* request,
     const net::CompletionCallback& callback,
     const net::BoundNetLog& net_log) {
   DCHECK(request);
   request_ = request;
 
   std::string client_id;
   ProcessRequest(&client_id);
   interceptor_ = controller_->GetInterceptor(client_id);
-  if (interceptor_)
-    interceptor_->AddThrottable(this);
 
   if (interceptor_ && interceptor_->ShouldFail()) {
     failed_ = true;
     network_transaction_->SetBeforeNetworkStartCallback(
         BeforeNetworkStartCallback());
+    interceptor_.reset();
     return net::ERR_INTERNET_DISCONNECTED;
   }
+
+  if (interceptor_)
+    interceptor_->AddThrottable(this);
   int rv = network_transaction_->Start(request_, proxy_callback_, net_log);
   return SetupCallback(callback, rv, START);
 }
 
 void DevToolsNetworkTransaction::ProcessRequest(std::string* client_id) {
   DCHECK(request_);
   bool has_devtools_client_id = request_->extra_headers.HasHeader(
       kDevToolsEmulateNetworkConditionsClientId);
   if (!has_devtools_client_id)
     return;
@@ skipping 128 matching lines @@
 }
 
 void DevToolsNetworkTransaction::ThrottleFinished() {
   DCHECK(!callback_.is_null());
   DCHECK(callback_type_ == READ || callback_type_ == START);
   net::CompletionCallback callback = callback_;
   callback_.Reset();
   callback_type_ = NONE;
   callback.Run(throttled_result_);
 }