[chromedriver] Implement reconnection to DevTools.

chrome/test/chromedriver/net/sync_websocket_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/net/sync_websocket_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context_getter.h"
 
 SyncWebSocketImpl::SyncWebSocketImpl(
     net::URLRequestContextGetter* context_getter)
     : core_(new Core(context_getter)) {}
 
 SyncWebSocketImpl::~SyncWebSocketImpl() {}
 
+bool SyncWebSocketImpl::IsConnected() {
+  return core_->IsConnected();
+}
+
 bool SyncWebSocketImpl::Connect(const GURL& url) {
   return core_->Connect(url);
 }
 
 bool SyncWebSocketImpl::Send(const std::string& message) {
   return core_->Send(message);
 }
 
 bool SyncWebSocketImpl::ReceiveNextMessage(std::string* message) {
   return core_->ReceiveNextMessage(message);
 }
 
 bool SyncWebSocketImpl::HasNextMessage() {
   return core_->HasNextMessage();
 }
 
 SyncWebSocketImpl::Core::Core(net::URLRequestContextGetter* context_getter)
     : context_getter_(context_getter),
-      closed_(false),
+      open_(false),
       on_update_event_(&lock_) {}
 
+bool SyncWebSocketImpl::Core::IsConnected() {
+  base::AutoLock lock(lock_);
+  return open_;
+}
+
 bool SyncWebSocketImpl::Core::Connect(const GURL& url) {
   bool success = false;
   base::WaitableEvent event(false, false);
   context_getter_->GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&SyncWebSocketImpl::Core::ConnectOnIO,
                  this, url, &success, &event));
   event.Wait();
   return success;
 }
 
 bool SyncWebSocketImpl::Core::Send(const std::string& message) {
   bool success = false;
   base::WaitableEvent event(false, false);
   context_getter_->GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&SyncWebSocketImpl::Core::SendOnIO,
                  this, message, &success, &event));
   event.Wait();
   return success;
 }
 
 bool SyncWebSocketImpl::Core::ReceiveNextMessage(std::string* message) {
   base::AutoLock lock(lock_);
-  while (received_queue_.empty() && !closed_) on_update_event_.Wait();
-  if (closed_)
+  while (received_queue_.empty() && open_) on_update_event_.Wait();
+  if (!open_)
     return false;
   *message = received_queue_.front();
   received_queue_.pop_front();
   return true;
 }
 
 bool SyncWebSocketImpl::Core::HasNextMessage() {
   base::AutoLock lock(lock_);
   return !received_queue_.empty();
 }
 
 void SyncWebSocketImpl::Core::OnMessageReceived(const std::string& message) {
   base::AutoLock lock(lock_);
   received_queue_.push_back(message);
   on_update_event_.Signal();
 }
 
 void SyncWebSocketImpl::Core::OnClose() {
   base::AutoLock lock(lock_);
-  closed_ = true;
+  open_ = false;
   on_update_event_.Signal();
 }
 
 SyncWebSocketImpl::Core::~Core() { }
 
 void SyncWebSocketImpl::Core::ConnectOnIO(
     const GURL& url,
     bool* success,
     base::WaitableEvent* event) {
+  base::AutoLock lock(lock_);

[kkania, 2013/03/04 23:33:57]

unlock after the queue is cleared, in case WebSocket::Connect calls the callback
synchronously

[chrisgao (Use stgao instead), 2013/03/05 06:58:17]

Done.

+  received_queue_.clear();
   socket_.reset(new WebSocket(context_getter_, url, this));
   socket_->Connect(base::Bind(
       &SyncWebSocketImpl::Core::OnConnectCompletedOnIO,
       this, success, event));
 }
 
 void SyncWebSocketImpl::Core::OnConnectCompletedOnIO(
     bool* success,
     base::WaitableEvent* event,
     int error) {
   *success = (error == net::OK);
+  if (*success) {
+    base::AutoLock lock(lock_);
+    open_ = true;
+  }
   event->Signal();
 }
 
 void SyncWebSocketImpl::Core::SendOnIO(
     const std::string& message,
     bool* success,
     base::WaitableEvent* event) {
   *success = socket_->Send(message);
   event->Signal();
 }
 
 void SyncWebSocketImpl::Core::OnDestruct() const {
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner =
       context_getter_->GetNetworkTaskRunner();
   if (network_task_runner->BelongsToCurrentThread())
     delete this;
   else
     network_task_runner->DeleteSoon(FROM_HERE, this);
 }