[chromedriver] Implement reconnection to DevTools.

chrome/test/chromedriver/devtools_client_impl_unittest.cc

 // Copyright (c) 2012 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 <list>
 #include <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/devtools_client_impl.h"
 #include "chrome/test/chromedriver/devtools_event_listener.h"
 #include "chrome/test/chromedriver/net/sync_websocket.h"
 #include "chrome/test/chromedriver/net/sync_websocket_factory.h"
 #include "chrome/test/chromedriver/status.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
+Status CloserFunc() {
+  return Status(kOk);
+}
+
 class MockSyncWebSocket : public SyncWebSocket {
  public:
   MockSyncWebSocket() : connected_(false), id_(-1), queued_messages_(1) {}
   virtual ~MockSyncWebSocket() {}
 
   virtual bool Connect(const GURL& url) OVERRIDE {
     EXPECT_STREQ("http://url/", url.possibly_invalid_spec().c_str());
     connected_ = true;
     return true;
   }
@@ skipping 43 matching lines @@
 template <typename T>
 scoped_ptr<SyncWebSocket> CreateMockSyncWebSocket() {
   return scoped_ptr<SyncWebSocket>(new T());
 }
 
 }  // namespace
 
 TEST(DevToolsClientImpl, SendCommand) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket>);
-  DevToolsClientImpl client(factory, "http://url");
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc));
   base::DictionaryValue params;
   params.SetInteger("param", 1);
   ASSERT_EQ(kOk, client.SendCommand("method", params).code());
 }
 
 TEST(DevToolsClientImpl, SendCommandAndGetResult) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket>);
-  DevToolsClientImpl client(factory, "http://url");
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc));
   base::DictionaryValue params;
   params.SetInteger("param", 1);
   scoped_ptr<base::DictionaryValue> result;
   Status status = client.SendCommandAndGetResult("method", params, &result);
   ASSERT_EQ(kOk, status.code());
   std::string json;
   base::JSONWriter::Write(result.get(), &json);
   ASSERT_STREQ("{\"param\":1}", json.c_str());
 }
 
@@ skipping 21 matching lines @@
   virtual bool HasNextMessage() OVERRIDE {
     return true;
   }
 };
 
 }  // namespace
 
 TEST(DevToolsClientImpl, SendCommandConnectFails) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket2>);
-  DevToolsClientImpl client(factory, "http://url");
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc));
   base::DictionaryValue params;
   ASSERT_TRUE(client.SendCommand("method", params).IsError());
 }
 
 namespace {
 
 class MockSyncWebSocket3 : public SyncWebSocket {
  public:
   MockSyncWebSocket3() {}
   virtual ~MockSyncWebSocket3() {}
@@ skipping 14 matching lines @@
   virtual bool HasNextMessage() OVERRIDE {
     return true;
   }
 };
 
 }  // namespace
 
 TEST(DevToolsClientImpl, SendCommandSendFails) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket3>);
-  DevToolsClientImpl client(factory, "http://url");
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc));
   base::DictionaryValue params;
   ASSERT_TRUE(client.SendCommand("method", params).IsError());
 }
 
 namespace {
 
 class MockSyncWebSocket4 : public SyncWebSocket {
  public:
   MockSyncWebSocket4() {}
   virtual ~MockSyncWebSocket4() {}
@@ skipping 13 matching lines @@
   virtual bool HasNextMessage() OVERRIDE {
     return true;
   }
 };
 
 }  // namespace
 
 TEST(DevToolsClientImpl, SendCommandReceiveNextMessageFails) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket4>);
-  DevToolsClientImpl client(factory, "http://url");
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc));
   base::DictionaryValue params;
   ASSERT_TRUE(client.SendCommand("method", params).IsError());
 }
 
 namespace {
 
 class FakeSyncWebSocket : public SyncWebSocket {
  public:
   FakeSyncWebSocket() : connected_(false) {}
   virtual ~FakeSyncWebSocket() {}
@@ skipping 171 matching lines @@
 
 bool AlwaysTrue() {
   return true;
 }
 
 }  // namespace
 
 TEST(DevToolsClientImpl, SendCommandOnlyConnectsOnce) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<FakeSyncWebSocket>);
-  DevToolsClientImpl client(factory, "http://url", base::Bind(
-      &ReturnCommand));
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc),
+                            base::Bind(&ReturnCommand));
   base::DictionaryValue params;
   ASSERT_TRUE(client.SendCommand("method", params).IsOk());
   ASSERT_TRUE(client.SendCommand("method", params).IsOk());
 }
 
 TEST(DevToolsClientImpl, SendCommandBadResponse) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<FakeSyncWebSocket>);
-  DevToolsClientImpl client(factory, "http://url", base::Bind(
-      &ReturnBadResponse));
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc),
+                            base::Bind(&ReturnBadResponse));
   base::DictionaryValue params;
   ASSERT_TRUE(client.SendCommand("method", params).IsError());
 }
 
 TEST(DevToolsClientImpl, SendCommandBadId) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<FakeSyncWebSocket>);
-  DevToolsClientImpl client(factory, "http://url", base::Bind(
-      &ReturnCommandBadId));
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc),
+                            base::Bind(&ReturnCommandBadId));
   base::DictionaryValue params;
   ASSERT_TRUE(client.SendCommand("method", params).IsError());
 }
 
 TEST(DevToolsClientImpl, SendCommandResponseError) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<FakeSyncWebSocket>);
-  DevToolsClientImpl client(factory, "http://url", base::Bind(
-      &ReturnCommandError));
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc),
+                            base::Bind(&ReturnCommandError));
   base::DictionaryValue params;
   ASSERT_TRUE(client.SendCommand("method", params).IsError());
 }
 
 TEST(DevToolsClientImpl, SendCommandEventBeforeResponse) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<FakeSyncWebSocket>);
   MockListener listener;
   bool first = true;
-  DevToolsClientImpl client(factory, "http://url", base::Bind(
-      &ReturnEventThenResponse, &first));
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc),
+                            base::Bind(&ReturnEventThenResponse, &first));
   client.AddListener(&listener);
   base::DictionaryValue params;
   scoped_ptr<base::DictionaryValue> result;
   ASSERT_TRUE(client.SendCommandAndGetResult("method", params, &result).IsOk());
   ASSERT_TRUE(result);
   int key;
   ASSERT_TRUE(result->GetInteger("key", &key));
   ASSERT_EQ(2, key);
 }
 
@@ skipping 69 matching lines @@
   ASSERT_FALSE(response.error.length());
   int key;
   ASSERT_TRUE(response.result->GetInteger("key", &key));
   ASSERT_EQ(1, key);
 }
 
 TEST(DevToolsClientImpl, HandleEventsUntil) {
   MockListener listener;
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket>);
-  DevToolsClientImpl client(factory, "http://url", base::Bind(
-      &ReturnEvent));
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc),
+                            base::Bind(&ReturnEvent));
   client.AddListener(&listener);
   Status status = client.HandleEventsUntil(base::Bind(&AlwaysTrue));
   ASSERT_EQ(kOk, status.code());
 }
 
 TEST(DevToolsClientImpl, WaitForNextEventCommand) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket>);
-  DevToolsClientImpl client(factory, "http://url", base::Bind(
-      &ReturnCommand));
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc),
+                            base::Bind(&ReturnCommand));
   Status status = client.HandleEventsUntil(base::Bind(&AlwaysTrue));
   ASSERT_EQ(kUnknownError, status.code());
 }
 
 TEST(DevToolsClientImpl, WaitForNextEventError) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket>);
-  DevToolsClientImpl client(factory, "http://url", base::Bind(
-      &ReturnError));
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc),
+                            base::Bind(&ReturnError));
   Status status = client.HandleEventsUntil(base::Bind(&AlwaysTrue));
   ASSERT_EQ(kUnknownError, status.code());
 }
 
 TEST(DevToolsClientImpl, NestedCommandsWithOutOfOrderResults) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket>);
   int recurse_count = 0;
-  DevToolsClientImpl client(factory, "http://url");
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc));
   client.SetParserFuncForTesting(
       base::Bind(&ReturnOutOfOrderResponses, &recurse_count, &client));
   base::DictionaryValue params;
   params.SetInteger("param", 1);
   scoped_ptr<base::DictionaryValue> result;
   ASSERT_TRUE(client.SendCommandAndGetResult("method", params, &result).IsOk());
   ASSERT_TRUE(result);
   int key;
   ASSERT_TRUE(result->GetInteger("key", &key));
   ASSERT_EQ(2, key);
@@ skipping 93 matching lines @@
  private:
   bool connected_;
   std::list<std::string> queued_response_;
 };
 
 }  // namespace
 
 TEST(DevToolsClientImpl, ProcessOnConnectedBeforeOnEvent) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<OnConnectedSyncWebSocket>);
-  DevToolsClientImpl client(factory, "http://url");
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc));
   OnConnectedListener listener1("DOM.getDocument", &client);
   OnConnectedListener listener2("Runtime.enable", &client);
   OnConnectedListener listener3("Page.enable", &client);
   base::DictionaryValue params;
   EXPECT_EQ(kOk, client.SendCommand("Runtime.execute", params).code());
   listener1.VerifyCalled();
   listener2.VerifyCalled();
   listener3.VerifyCalled();
 }
+
+namespace {
+
+class DisconnectedSyncWebSocket : public MockSyncWebSocket {
+ public:
+  DisconnectedSyncWebSocket() : command_count_(0) {}
+  virtual ~DisconnectedSyncWebSocket() {}
+
+  virtual bool Send(const std::string& message) OVERRIDE {
+    command_count_++;
+    if (command_count_ == 2)
+      return false;
+    return MockSyncWebSocket::Send(message);
+  }
+
+ private:
+  int command_count_;
+};
+
+Status CheckCloserFuncCalled(bool* is_called) {
+  *is_called = true;
+  return Status(kOk);
+}
+
+}  // namespace
+
+TEST(DevToolsClientImpl, Reconnect) {
+  SyncWebSocketFactory factory =
+      base::Bind(&CreateMockSyncWebSocket<DisconnectedSyncWebSocket>);
+  bool is_called = false;
+  DevToolsClientImpl client(factory, "http://url",
+                            base::Bind(&CheckCloserFuncCalled, &is_called));
+  base::DictionaryValue params;
+  params.SetInteger("param", 1);
+  EXPECT_EQ(kOk, client.SendCommand("method", params).code());
+  EXPECT_FALSE(is_called);
+  EXPECT_EQ(kOk, client.SendCommand("method", params).code());
+  EXPECT_TRUE(is_called);
+}