Revert of DevTools: Removed refcounting from AndroidWebSocket

chrome/browser/devtools/device/devtools_android_bridge.cc

 // 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 "chrome/browser/devtools/device/devtools_android_bridge.h"
 
 #include <map>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 168 matching lines @@
  public:
   ProtocolCommand(
       scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
       const std::string& debug_url,
       const std::string& command,
       const base::Closure callback);
 
  private:
   virtual void OnSocketOpened() OVERRIDE;
   virtual void OnFrameRead(const std::string& message) OVERRIDE;
-  virtual void OnSocketClosed() OVERRIDE;
-  virtual ~ProtocolCommand();
+  virtual void OnSocketClosed(bool closed_by_device) OVERRIDE;
 
   const std::string command_;
   const base::Closure callback_;
-  scoped_ptr<DevToolsAndroidBridge::AndroidWebSocket> web_socket_;
+  scoped_refptr<DevToolsAndroidBridge::AndroidWebSocket> web_socket_;
 
   DISALLOW_COPY_AND_ASSIGN(ProtocolCommand);
 };
 
 ProtocolCommand::ProtocolCommand(
     scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
     const std::string& debug_url,
     const std::string& command,
     const base::Closure callback)
     : command_(command),
-      callback_(callback),
-      web_socket_(browser->CreateWebSocket(debug_url, this)) {
+      callback_(callback){
+  web_socket_ = browser->CreateWebSocket(debug_url, this);
+  web_socket_->Connect();
 }
 
 void ProtocolCommand::OnSocketOpened() {
   web_socket_->SendFrame(command_);
 }
 
 void ProtocolCommand::OnFrameRead(const std::string& message) {
+  web_socket_->Disconnect();
+}
+
+void ProtocolCommand::OnSocketClosed(bool closed_by_device) {
+  if (!callback_.is_null()) {
+    callback_.Run();
+  }
   delete this;
 }
 
-void ProtocolCommand::OnSocketClosed() {
-  delete this;
-}
-
-ProtocolCommand::~ProtocolCommand() {
-  if (!callback_.is_null())
-    callback_.Run();
-}
-
 }  // namespace
 
 class AgentHostDelegate;
 
 typedef std::map<std::string, AgentHostDelegate*> AgentHostDelegates;
 
 base::LazyInstance<AgentHostDelegates>::Leaky g_host_delegates =
     LAZY_INSTANCE_INITIALIZER;
 
 DevToolsAndroidBridge::Wrapper::Wrapper(content::BrowserContext* context) {
@@ skipping 50 matching lines @@
       const std::string& id,
       scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
       const std::string& debug_url);
   virtual ~AgentHostDelegate();
   virtual void Attach(content::DevToolsExternalAgentProxy* proxy) OVERRIDE;
   virtual void Detach() OVERRIDE;
   virtual void SendMessageToBackend(
       const std::string& message) OVERRIDE;
   virtual void OnSocketOpened() OVERRIDE;
   virtual void OnFrameRead(const std::string& message) OVERRIDE;
-  virtual void OnSocketClosed() OVERRIDE;
+  virtual void OnSocketClosed(bool closed_by_device) OVERRIDE;
 
   const std::string id_;
-  scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser_;
-  const std::string debug_url_;
   bool socket_opened_;
+  bool detached_;
   bool is_web_view_;
   std::vector<std::string> pending_messages_;
-  scoped_ptr<DevToolsAndroidBridge::AndroidWebSocket> web_socket_;
+  scoped_refptr<DevToolsAndroidBridge::AndroidWebSocket> web_socket_;
   content::DevToolsAgentHost* agent_host_;
   content::DevToolsExternalAgentProxy* proxy_;
   DISALLOW_COPY_AND_ASSIGN(AgentHostDelegate);
 };
 
 // static
 scoped_refptr<content::DevToolsAgentHost>
 AgentHostDelegate::GetOrCreateAgentHost(
     const std::string& id,
     scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
     const std::string& debug_url) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    AgentHostDelegates::iterator it = g_host_delegates.Get().find(id);
    if (it != g_host_delegates.Get().end())
      return it->second->agent_host_;
 
   AgentHostDelegate* delegate = new AgentHostDelegate(id, browser, debug_url);
   scoped_refptr<content::DevToolsAgentHost> result =
       content::DevToolsAgentHost::Create(delegate);
   delegate->agent_host_ = result.get();
   return result;
 }
 
 AgentHostDelegate::AgentHostDelegate(
     const std::string& id,
     scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
     const std::string& debug_url)
     : id_(id),
-      browser_(browser),
-      debug_url_(debug_url),
       socket_opened_(false),
+      detached_(false),
       is_web_view_(browser->IsWebView()),
+      web_socket_(browser->CreateWebSocket(debug_url, this)),
       agent_host_(NULL),
       proxy_(NULL) {
   g_host_delegates.Get()[id] = this;
 }
 
 AgentHostDelegate::~AgentHostDelegate() {
   g_host_delegates.Get().erase(id_);
+  web_socket_->ClearDelegate();
 }
 
 void AgentHostDelegate::Attach(content::DevToolsExternalAgentProxy* proxy) {
   proxy_ = proxy;
   content::RecordAction(base::UserMetricsAction(is_web_view_ ?
       "DevTools_InspectAndroidWebView" : "DevTools_InspectAndroidPage"));
-  web_socket_.reset(browser_->CreateWebSocket(debug_url_, this));
+  web_socket_->Connect();
 }
 
 void AgentHostDelegate::Detach() {
-  web_socket_.reset();
+  detached_ = true;
+  if (socket_opened_)
+    web_socket_->Disconnect();
 }
 
 void AgentHostDelegate::SendMessageToBackend(const std::string& message) {
   if (socket_opened_)
     web_socket_->SendFrame(message);
   else
     pending_messages_.push_back(message);
 }
 
 void AgentHostDelegate::OnSocketOpened() {
+  if (detached_) {
+    web_socket_->Disconnect();
+    return;
+  }
+
   socket_opened_ = true;
   for (std::vector<std::string>::iterator it = pending_messages_.begin();
        it != pending_messages_.end(); ++it) {
     SendMessageToBackend(*it);
   }
   pending_messages_.clear();
 }
 
 void AgentHostDelegate::OnFrameRead(const std::string& message) {
   if (proxy_)
       proxy_->DispatchOnClientHost(message);
 }
 
-void AgentHostDelegate::OnSocketClosed() {
-  if (proxy_)
+void AgentHostDelegate::OnSocketClosed(bool closed_by_device) {
+  if (proxy_ && closed_by_device)
     proxy_->ConnectionClosed();
 }
 
 //// RemotePageTarget ----------------------------------------------
 
 class RemotePageTarget : public DevToolsTargetImpl,
                          public DevToolsAndroidBridge::RemotePage {
  public:
   RemotePageTarget(scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
                    const base::DictionaryValue& value);
@@ skipping 212 matching lines @@
   InnerOpen(url, base::Bind(&RemoteBrowser::RespondToOpenOnUIThread,
                             this, callback));
 }
 
 scoped_refptr<content::DevToolsAgentHost>
 DevToolsAndroidBridge::RemoteBrowser::GetAgentHost() {
   return AgentHostDelegate::GetOrCreateAgentHost(
       "adb:" + device_->serial() + ":" + socket_, this, kBrowserTargetSocket);
 }
 
-DevToolsAndroidBridge::AndroidWebSocket*
+scoped_refptr<DevToolsAndroidBridge::AndroidWebSocket>
 DevToolsAndroidBridge::RemoteBrowser::CreateWebSocket(
     const std::string& url,
     DevToolsAndroidBridge::AndroidWebSocket::Delegate* delegate) {
   return device_->CreateWebSocket(socket_, url, delegate);
 }
 
 void DevToolsAndroidBridge::RemoteBrowser::RespondToOpenOnUIThread(
     const DevToolsAndroidBridge::RemotePageCallback& callback,
     int result,
     const std::string& response) {
@@ skipping 262 matching lines @@
   bool enabled;
   if (pref_value->GetAsBoolean(&enabled) && enabled) {
     device_providers.push_back(new UsbDeviceProvider(profile_));
   }
   device_manager_->SetDeviceProviders(device_providers);
   if (!device_list_listeners_.empty()) {
     StopDeviceListPolling();
     StartDeviceListPolling();
   }
 }