Add the ability for DevTools to wrap network transactions.

chrome/browser/devtools/devtools_network_controller_unittest.cc

Index: chrome/browser/devtools/devtools_network_controller_unittest.cc
diff --git a/chrome/browser/devtools/devtools_network_controller_unittest.cc b/chrome/browser/devtools/devtools_network_controller_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c3a70681deffeecd6b92b9974f4a0b5112217a71
--- /dev/null
+++ b/chrome/browser/devtools/devtools_network_controller_unittest.cc
@@ -0,0 +1,178 @@
+// 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"
+#include "chrome/browser/devtools/devtools_network_controller.h"
+#include "chrome/browser/devtools/devtools_network_transaction.h"
+#include "net/http/http_transaction_unittest.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+namespace {
+
+  class TestCallback {

[mmenke, 2014/04/21 17:16:51]

Shouldn't indent code in a namespace.

[eustas, 2014/04/22 14:23:09]

Done.

+   public:
+    TestCallback() : run_count_(0), value_(0) {}
+    void Run(int value) {
+      run_count_++;
+      value_ = value;
+    }
+    int run_count() { return run_count_; }
+    int value() { return value_; }
+
+   private:
+    int run_count_;
+    int value_;
+  };
+
+  class TransactionHelper {
+   public:
+    TransactionHelper() :
+        completion_callback_(
+            base::Bind(&TestCallback::Run, base::Unretained(&callback_))),
+        mock_transaction_(kSimpleGET_Transaction),
+        buffer_(new net::IOBuffer(64)) {
+      mock_transaction_.test_mode = TEST_MODE_SYNC_NET_START;
+      mock_transaction_.url = "http://dot.com";
+      AddMockTransaction(&mock_transaction_);
+
+      scoped_ptr<net::HttpTransaction> network_transaction;
+      network_layer_.CreateTransaction(
+          net::DEFAULT_PRIORITY, &network_transaction);
+      transaction_.reset(new DevToolsNetworkTransaction(
+          &controller_, network_transaction.Pass()));
+    }
+
+    int Start() {
+        MockHttpRequest request(mock_transaction_);
+        return transaction_->Start(

[mmenke, 2014/04/21 17:16:51]

nit:  -2 indent

[eustas, 2014/04/22 14:23:09]

Done.

+            &request, completion_callback_, net::BoundNetLog());
+    }
+
+    int Read() {
+      return transaction_->Read(buffer_.get(), 64, completion_callback_);
+    }
+
+    ~TransactionHelper() {
+      RemoveMockTransaction(&mock_transaction_);
+    }
+
+    TestCallback* callback() { return &callback_; }
+    MockTransaction* mock_transaction() { return &mock_transaction_; }
+    DevToolsNetworkController* controller() { return &controller_; }
+    DevToolsNetworkTransaction* transaction() { return transaction_.get(); }
+
+   private:
+    base::MessageLoop message_loop_;
+    MockNetworkLayer network_layer_;
+    TestCallback callback_;
+    net::CompletionCallback completion_callback_;
+    MockTransaction mock_transaction_;
+    DevToolsNetworkController controller_;
+    scoped_ptr<DevToolsNetworkTransaction> transaction_;
+    scoped_refptr<net::IOBuffer> buffer_;
+  };
+
+}  // namespace

[mmenke, 2014/04/21 17:16:51]

Sorry, should have been clearer - can the rest of the file also go in the
anonymous namespace?

Shouldn't be conflicts in names of tests anyways, but there's no need for them
to be in the global namespace, unless they are friends of classes in other
files.

[eustas, 2014/04/22 14:23:09]

Done.

+
+TEST(DevToolsNetworkControllerTest, SingleDisableEnable) {
+  TransactionHelper helper;
+  DevToolsNetworkController* controller = helper.controller();
+  DevToolsNetworkTransaction* transaction = helper.transaction();
+  std::string test_id = "42";

[mmenke, 2014/04/21 17:16:51]

These should probably be:

const char kTestId[] = "42";

(Or maybe kTestClientId to be more explicit)

[eustas, 2014/04/22 14:23:09]

Done.

+  helper.Start();
+
+  EXPECT_FALSE(controller->ShouldFail(transaction));
+  controller->DisableNetwork(test_id, true);
+  EXPECT_TRUE(controller->ShouldFail(transaction));
+  controller->DisableNetwork(test_id, false);
+  EXPECT_FALSE(controller->ShouldFail(transaction));
+}
+
+TEST(DevToolsNetworkControllerTest, DoubleDisableEnable) {
+  TransactionHelper helper;
+  DevToolsNetworkController* controller = helper.controller();
+  DevToolsNetworkTransaction* transaction = helper.transaction();
+  std::string test_id_1 = "42";
+  std::string test_id_2 = "24";
+  helper.Start();
+
+  EXPECT_FALSE(controller->ShouldFail(transaction));
+  controller->DisableNetwork(test_id_1, true);
+  EXPECT_TRUE(controller->ShouldFail(transaction));
+  controller->DisableNetwork(test_id_2, true);
+  EXPECT_TRUE(controller->ShouldFail(transaction));
+  controller->DisableNetwork(test_id_1, false);
+  EXPECT_TRUE(controller->ShouldFail(transaction));
+  controller->DisableNetwork(test_id_2, false);
+  EXPECT_FALSE(controller->ShouldFail(transaction));
+}
+
+TEST(DevToolsNetworkControllerTest, FailOnStart) {
+  TransactionHelper helper;
+  helper.controller()->DisableNetwork("42", true);
+
+  int rv = helper.Start();
+  EXPECT_EQ(rv, net::ERR_INTERNET_DISCONNECTED);
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(helper.callback()->run_count(), 0);
+}
+
+TEST(DevToolsNetworkControllerTest, FailRunningTransaction) {
+  TransactionHelper helper;
+  DevToolsNetworkController* controller = helper.controller();
+  TestCallback* callback = helper.callback();
+  std::string test_id = "42";
+
+  int rv = helper.Start();
+  EXPECT_EQ(rv, net::OK);
+
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(64));
+  rv = helper.Read();
+  EXPECT_EQ(rv, net::ERR_IO_PENDING);
+  EXPECT_EQ(callback->run_count(), 0);
+
+  controller->DisableNetwork(test_id, true);
+  EXPECT_EQ(callback->run_count(), 1);
+  EXPECT_EQ(callback->value(), net::ERR_INTERNET_DISCONNECTED);
+
+  base::RunLoop().RunUntilIdle();

[mmenke, 2014/04/21 17:16:51]

Think this is worth a comment (Just something along the lines of the
HttpTransaction should complete successfully, but the DevToolsTransaction should
ignore it)

[eustas, 2014/04/22 14:23:09]

Done.

+  EXPECT_EQ(callback->run_count(), 1);
+
+  // Check that transaction in not failed second time.
+  controller->DisableNetwork(test_id, false);
+  controller->DisableNetwork(test_id, true);
+  EXPECT_EQ(callback->run_count(), 1);
+}
+
+TEST(DevToolsNetworkControllerTest, ReadAfterFail) {

[mmenke, 2014/04/21 17:16:51]

This shouldn't happen - should test when a fail with no callback pending
instead.

Should run Start(), run the message loop and make sure you get back success. 
Then shut off the network, then read, and make sure you get
ERR_INTERNET_DISCONNECTED.

[eustas, 2014/04/22 14:23:09]

Done.

+  TransactionHelper helper;
+  helper.controller()->DisableNetwork("42", true);
+
+  int rv = helper.Start();
+  EXPECT_EQ(rv, net::ERR_INTERNET_DISCONNECTED);
+
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(64));
+  rv = helper.Read();
+  EXPECT_EQ(rv, net::ERR_INTERNET_DISCONNECTED);
+}
+
+TEST(DevToolsNetworkControllerTest, BypassDevToolsRequests) {

[mmenke, 2014/04/21 17:16:51]

nit:  Think this name is confusing.  Maybe AllowsDevToolsRequests?  Or
IgnoresDevToolsRequests?

[eustas, 2014/04/22 14:23:09]

Done.

+  TransactionHelper helper;
+  helper.mock_transaction()->request_headers =
+      "X-DevTools-Request-Initiator: frontend\r\n";
+  DevToolsNetworkController* controller = helper.controller();
+  DevToolsNetworkTransaction* transaction = helper.transaction();
+  helper.Start();
+
+  EXPECT_FALSE(controller->ShouldFail(transaction));
+  controller->DisableNetwork("42", true);
+  EXPECT_FALSE(controller->ShouldFail(transaction));
+}