[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 IsConnected() OVERRIDE {
+    return connected_;
+  }
+
   virtual bool Connect(const GURL& url) OVERRIDE {
     EXPECT_STREQ("http://url/", url.possibly_invalid_spec().c_str());
     connected_ = true;
     return true;
   }
 
   virtual bool Send(const std::string& message) OVERRIDE {
     EXPECT_TRUE(connected_);
     scoped_ptr<base::Value> value(base::JSONReader::Read(message));
     base::DictionaryValue* dict = NULL;
@@ skipping 22 matching lines @@
     response.Set("result", result.DeepCopy());
     base::JSONWriter::Write(&response, message);
     --queued_messages_;
     return true;
   }
 
   virtual bool HasNextMessage() OVERRIDE {
     return queued_messages_ > 0;
   }
 
- private:
+ protected:
   bool connected_;
   int id_;
   int queued_messages_;
 };
 
 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));
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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));
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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());
 }
 
 namespace {
 
 class MockSyncWebSocket2 : public SyncWebSocket {
  public:
   MockSyncWebSocket2() {}
   virtual ~MockSyncWebSocket2() {}
 
+  virtual bool IsConnected() OVERRIDE {
+    return false;
+  }
+
   virtual bool Connect(const GURL& url) OVERRIDE {
     return false;
   }
 
   virtual bool Send(const std::string& message) OVERRIDE {
     EXPECT_TRUE(false);
     return false;
   }
 
   virtual bool ReceiveNextMessage(std::string* message) OVERRIDE {
     EXPECT_TRUE(false);
     return false;
   }
 
   virtual bool HasNextMessage() OVERRIDE {
     return true;
   }
 };
 
 }  // namespace
 
-TEST(DevToolsClientImpl, SendCommandConnectFails) {
+TEST(DevToolsClientImpl, ConnectIfNecessaryConnectFails) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket2>);
-  DevToolsClientImpl client(factory, "http://url");
-  base::DictionaryValue params;
-  ASSERT_TRUE(client.SendCommand("method", params).IsError());
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc));
+  ASSERT_EQ(kDisconnected, client.ConnectIfNecessary().code());
 }
 
 namespace {
 
 class MockSyncWebSocket3 : public SyncWebSocket {
  public:
-  MockSyncWebSocket3() {}
+  MockSyncWebSocket3() : connected_(false) {}
   virtual ~MockSyncWebSocket3() {}
 
+  virtual bool IsConnected() OVERRIDE {
+    return connected_;
+  }
+
   virtual bool Connect(const GURL& url) OVERRIDE {
+    connected_ = true;
     return true;
   }
 
   virtual bool Send(const std::string& message) OVERRIDE {
     return false;
   }
 
   virtual bool ReceiveNextMessage(std::string* message) OVERRIDE {
     EXPECT_TRUE(false);
     return false;
   }
 
   virtual bool HasNextMessage() OVERRIDE {
     return true;
   }
+
+ private:
+  bool connected_;
 };
 
 }  // namespace
 
 TEST(DevToolsClientImpl, SendCommandSendFails) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket3>);
-  DevToolsClientImpl client(factory, "http://url");
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc));
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   base::DictionaryValue params;
   ASSERT_TRUE(client.SendCommand("method", params).IsError());
 }
 
 namespace {
 
 class MockSyncWebSocket4 : public SyncWebSocket {
  public:
-  MockSyncWebSocket4() {}
+  MockSyncWebSocket4() : connected_(false) {}
   virtual ~MockSyncWebSocket4() {}
 
+  virtual bool IsConnected() OVERRIDE {
+    return connected_;
+  }
+
   virtual bool Connect(const GURL& url) OVERRIDE {
+    connected_ = true;
     return true;
   }
 
   virtual bool Send(const std::string& message) OVERRIDE {
     return true;
   }
 
   virtual bool ReceiveNextMessage(std::string* message) OVERRIDE {
     return false;
   }
 
   virtual bool HasNextMessage() OVERRIDE {
     return true;
   }
+
+ private:
+  bool connected_;
 };
 
 }  // namespace
 
 TEST(DevToolsClientImpl, SendCommandReceiveNextMessageFails) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket4>);
-  DevToolsClientImpl client(factory, "http://url");
+  DevToolsClientImpl client(factory, "http://url", base::Bind(&CloserFunc));
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   base::DictionaryValue params;
   ASSERT_TRUE(client.SendCommand("method", params).IsError());
 }
 
 namespace {
 
 class FakeSyncWebSocket : public SyncWebSocket {
  public:
   FakeSyncWebSocket() : connected_(false) {}
   virtual ~FakeSyncWebSocket() {}
 
+  virtual bool IsConnected() OVERRIDE {
+    return connected_;
+  }
+
   virtual bool Connect(const GURL& url) OVERRIDE {
     EXPECT_FALSE(connected_);
     connected_ = true;
     return true;
   }
 
   virtual bool Send(const std::string& message) OVERRIDE {
     return true;
   }
 
@@ skipping 160 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));
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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));
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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));
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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));
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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);
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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);
 }
 
 TEST(ParseInspectorMessage, NonJson) {
@@ skipping 68 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);
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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));
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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));
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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));
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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 36 matching lines @@
   DevToolsClient* client_;
   bool on_connected_called_;
   bool on_event_called_;
 };
 
 class OnConnectedSyncWebSocket : public SyncWebSocket {
  public:
   OnConnectedSyncWebSocket() : connected_(false) {}
   virtual ~OnConnectedSyncWebSocket() {}
 
+  virtual bool IsConnected() OVERRIDE {
+    return connected_;
+  }
+
   virtual bool Connect(const GURL& url) OVERRIDE {
     connected_ = true;
     return true;
   }
 
   virtual bool Send(const std::string& message) OVERRIDE {
     EXPECT_TRUE(connected_);
     scoped_ptr<base::Value> value(base::JSONReader::Read(message));
     base::DictionaryValue* dict = NULL;
     EXPECT_TRUE(value->GetAsDictionary(&dict));
@@ skipping 37 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);
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   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() : connection_count_(0), command_count_(0) {}
+  virtual ~DisconnectedSyncWebSocket() {}
+
+  virtual bool Connect(const GURL& url) OVERRIDE {
+    connection_count_++;
+    connected_ = connection_count_ != 2;
+    return connected_;
+  }
+
+  virtual bool Send(const std::string& message) OVERRIDE {
+    command_count_++;
+    if (command_count_ == 1) {
+      connected_ = false;
+      return false;
+    }
+    return MockSyncWebSocket::Send(message);
+  }
+
+ private:
+  int connection_count_;
+  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));
+  ASSERT_FALSE(is_called);
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
+  ASSERT_FALSE(is_called);
+  base::DictionaryValue params;
+  params.SetInteger("param", 1);
+  is_called = false;
+  ASSERT_EQ(kDisconnected, client.SendCommand("method", params).code());
+  ASSERT_FALSE(is_called);
+  ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
+  ASSERT_TRUE(is_called);
+  is_called = false;
+  ASSERT_EQ(kOk, client.SendCommand("method", params).code());
+  ASSERT_FALSE(is_called);
+}