[chromedriver] Implement reconnection to DevTools.

chrome/test/chromedriver/devtools_client_impl.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 "chrome/test/chromedriver/devtools_client_impl.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 30 matching lines @@
 InspectorEvent::~InspectorEvent() {}
 
 InspectorCommandResponse::InspectorCommandResponse() {}
 
 InspectorCommandResponse::~InspectorCommandResponse() {}
 
 }  // namespace internal
 
 DevToolsClientImpl::DevToolsClientImpl(
     const SyncWebSocketFactory& factory,
-    const std::string& url)
+    const std::string& url,
+    const FrontendCloserFunc& frontend_closer_func)
     : socket_(factory.Run().Pass()),
       url_(url),
+      frontend_closer_func_(frontend_closer_func),
       parser_func_(base::Bind(&internal::ParseInspectorMessage)),
-      connected_(false),
       next_id_(1) {}
 
 DevToolsClientImpl::DevToolsClientImpl(
     const SyncWebSocketFactory& factory,
     const std::string& url,
+    const FrontendCloserFunc& frontend_closer_func,
     const ParserFunc& parser_func)
     : socket_(factory.Run().Pass()),
       url_(url),
+      frontend_closer_func_(frontend_closer_func),
       parser_func_(parser_func),
-      connected_(false),
       next_id_(1) {}
 
 DevToolsClientImpl::~DevToolsClientImpl() {
   for (ResponseMap::iterator iter = cmd_response_map_.begin();
        iter != cmd_response_map_.end(); ++iter) {
     LOG(WARNING) << "Finished with no response for command " << iter->first;
     delete iter->second;
   }
 }
 
 void DevToolsClientImpl::SetParserFuncForTesting(
     const ParserFunc& parser_func) {
   parser_func_ = parser_func;
 }
 
+Status DevToolsClientImpl::ConnectIfNecessary() {
+  if (!socket_->IsConnected()) {
+    if (!socket_->Connect(url_)) {
+      // Try to close devtools frontend and then reconnect.
+      Status status = frontend_closer_func_.Run();
+      if (status.IsError())
+        return status;
+      if (!socket_->Connect(url_))
+        return Status(kDisconnected, "unable to connect to renderer");
+    }
+
+    // OnConnected notification will be sent out in method ReceiveNextMessage.
+    listeners_for_on_connected_ = listeners_;
+  }
+  return Status(kOk);
+}
+
 Status DevToolsClientImpl::SendCommand(
     const std::string& method,
     const base::DictionaryValue& params) {
   scoped_ptr<base::DictionaryValue> result;
   return SendCommandInternal(method, params, &result);
 }
 
 Status DevToolsClientImpl::SendCommandAndGetResult(
     const std::string& method,
     const base::DictionaryValue& params,
@@ skipping 24 matching lines @@
     if (status.IsError())
       return status;
   }
   return Status(kOk);
 }
 
 Status DevToolsClientImpl::SendCommandInternal(
     const std::string& method,
     const base::DictionaryValue& params,
     scoped_ptr<base::DictionaryValue>* result) {
-  if (!connected_) {
-    if (!socket_->Connect(url_))
-      return Status(kDisconnected, "unable to connect to renderer");
-    connected_ = true;
-
-    // OnConnected notification will be sent out in method ReceiveNextMessage.
-    listeners_for_on_connected_ = listeners_;
-  }
+  if (!socket_->IsConnected())
+    return Status(kDisconnected, "disconnected from DevTools");
 
   int command_id = next_id_++;
   base::DictionaryValue command;
   command.SetInteger("id", command_id);
   command.SetString("method", method);
   command.Set("params", params.DeepCopy());
   std::string message;
   base::JSONWriter::Write(&command, &message);
-  if (!socket_->Send(message)) {
-    connected_ = false;
+  if (!socket_->Send(message))
     return Status(kDisconnected, "unable to send message to renderer");
-  }
   return ReceiveCommandResponse(command_id, result);
 }
 
 Status DevToolsClientImpl::ReceiveCommandResponse(
     int command_id,
     scoped_ptr<base::DictionaryValue>* result) {
   internal::InspectorMessageType type;
   internal::InspectorEvent event;
   internal::InspectorCommandResponse response;
   cmd_response_map_[command_id] = NULL;
@@ skipping 18 matching lines @@
     Status status = listener->OnConnected();
     if (status.IsError())
       return status;
   }
   // The message might be received already when processing other commands sent
   // from DevToolsEventListener::OnConnected.
   if (HasReceivedCommandResponse(expected_id))
     return Status(kOk);
 
   std::string message;
-  if (!socket_->ReceiveNextMessage(&message)) {
-    connected_ = false;
-    return Status(kDisconnected,
-                  "unable to receive message from renderer");
-  }
+  if (!socket_->ReceiveNextMessage(&message))
+    return Status(kDisconnected, "unable to receive message from renderer");
   if (!parser_func_.Run(message, expected_id, type, event, response))
     return Status(kUnknownError, "bad inspector message: " + message);
   if (*type == internal::kEventMessageType)
     return NotifyEventListeners(event->method, *event->params);
   if (*type == internal::kCommandResponseMessageType) {
     if (cmd_response_map_.count(response->id) == 0) {
       return Status(kUnknownError, "unexpected command message");
     } else if (response->result) {
       cmd_response_map_[response->id] = response->result.release();
     } else {
       cmd_response_map_.erase(response->id);
       return ParseInspectorError(response->error);
     }
   }
   return Status(kOk);
 }
 
 bool DevToolsClientImpl::HasReceivedCommandResponse(int cmd_id) {
   return cmd_response_map_.find(cmd_id) != cmd_response_map_.end()
       && cmd_response_map_[cmd_id] != NULL;
 }
 
 Status DevToolsClientImpl::NotifyEventListeners(
     const std::string& method,
     const base::DictionaryValue& params) {
   for (std::list<DevToolsEventListener*>::iterator iter = listeners_.begin();
        iter != listeners_.end(); ++iter) {
     (*iter)->OnEvent(method, params);
   }
-  if (method == "Inspector.detached") {
-    connected_ = false;
+  if (method == "Inspector.detached")
     return Status(kDisconnected, "received Inspector.detached event");
-  }
   return Status(kOk);
 }
 
 namespace internal {
 
 bool ParseInspectorMessage(
     const std::string& message,
     int expected_id,
     InspectorMessageType* type,
     InspectorEvent* event,
@@ skipping 30 matching lines @@
     if (unscoped_result)
       command_response->result.reset(unscoped_result->DeepCopy());
     else
       base::JSONWriter::Write(unscoped_error, &command_response->error);
     return true;
   }
   return false;
 }
 
 }  // namespace internal