[DevTools] Narrow down DevToolsNetworkInterceptor::Throttable.

chrome/browser/devtools/devtools_network_controller_unittest.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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 66 matching lines @@
   int Start() {
     return transaction_->Start(
         GetRequest(), completion_callback_, net::BoundNetLog());
   }
 
   int Read() {
     return transaction_->Read(buffer_.get(), 64, completion_callback_);
   }
 
   bool ShouldFail() {
-    return transaction_->interceptor_->ShouldFail();
+    if (transaction_->interceptor_)
+      return transaction_->interceptor_->ShouldFail();
+    base::WeakPtr<DevToolsNetworkInterceptor> interceptor =
+        controller_.GetInterceptor(kClientId);
+    EXPECT_TRUE(!!interceptor);
+    return interceptor->ShouldFail();
+  }
+
+  bool HasStarted() {
+    return !!transaction_->request_;
+  }
+
+  bool HasFailed() {
+    return transaction_->failed_;
   }
 
   ~DevToolsNetworkControllerHelper() {
     RemoveMockTransaction(&mock_transaction_);
   }
 
   TestCallback* callback() { return &callback_; }
   MockTransaction* mock_transaction() { return &mock_transaction_; }
   DevToolsNetworkController* controller() { return &controller_; }
   DevToolsNetworkTransaction* transaction() { return transaction_.get(); }
@@ skipping 79 matching lines @@
   helper.SetNetworkState(kClientId, true);
   EXPECT_EQ(callback->run_count(), 1);
 }
 
 TEST(DevToolsNetworkControllerTest, ReadAfterFail) {
   DevToolsNetworkControllerHelper helper;
   helper.SetNetworkState(kClientId, false);
 
   int rv = helper.Start();
   EXPECT_EQ(rv, net::OK);
-  EXPECT_TRUE(helper.transaction()->HasStarted());
+  EXPECT_TRUE(helper.HasStarted());
 
   helper.SetNetworkState(kClientId, true);
-  EXPECT_TRUE(helper.transaction()->HasFailed());
+  EXPECT_TRUE(helper.HasFailed());
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(64));
   rv = helper.Read();
   EXPECT_EQ(rv, net::ERR_INTERNET_DISCONNECTED);
 
   // Check that callback is never invoked.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(helper.callback()->run_count(), 0);
 }
 
 }  // namespace test