DevTools: RemoteDevice and RemoteBrowser are now value types

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 19 matching lines @@
 #include "chrome/browser/devtools/devtools_target_impl.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_external_agent_proxy.h"
 #include "content/public/browser/devtools_external_agent_proxy_delegate.h"
 #include "content/public/browser/user_metrics.h"
 #include "net/base/escape.h"
+#include "net/base/net_errors.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const char kPageListRequest[] = "/json";
 const char kVersionRequest[] = "/json/version";
 const char kClosePageRequest[] = "/json/close/%s";
 const char kNewPageRequest[] = "/json/new";
 const char kNewPageRequestWithURL[] = "/json/new?%s";
 const char kActivatePageRequest[] = "/json/activate/%s";
 const char kBrowserTargetSocket[] = "/devtools/browser";
 const int kAdbPollingIntervalMs = 1000;
 
 const char kUrlParam[] = "url";
 const char kPageReloadCommand[] = "Page.reload";
 const char kPageNavigateCommand[] = "Page.navigate";
 
 const int kMinVersionNewWithURL = 32;
 const int kNewPageNavigateDelayMs = 500;
 
+}  // namespace
+
 // DiscoveryRequest -----------------------------------------------------
 
-class DiscoveryRequest : public base::RefCountedThreadSafe<
-    DiscoveryRequest,
-    BrowserThread::DeleteOnUIThread> {
+class DevToolsAndroidBridge::DiscoveryRequest
+    : public base::RefCountedThreadSafe<DiscoveryRequest,
+                                        BrowserThread::DeleteOnUIThread> {
  public:
-  typedef AndroidDeviceManager::Device Device;
-  typedef AndroidDeviceManager::Devices Devices;
-  typedef AndroidDeviceManager::DeviceInfo DeviceInfo;
-  typedef DevToolsAndroidBridge::RemoteDevice RemoteDevice;
-  typedef DevToolsAndroidBridge::RemoteDevices RemoteDevices;
-  typedef DevToolsAndroidBridge::RemoteBrowser RemoteBrowser;
-  typedef DevToolsAndroidBridge::RemoteBrowsers RemoteBrowsers;
-  typedef base::Callback<void(const RemoteDevices&)> DiscoveryCallback;
+  typedef base::Callback<void(const AndroidDeviceManager::Devices&,
+                              const RemoteDevices&)> DiscoveryCallback;
 
   DiscoveryRequest(AndroidDeviceManager* device_manager,
                    const DiscoveryCallback& callback);
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class base::DeleteHelper<DiscoveryRequest>;
   virtual ~DiscoveryRequest();
 
-  void ReceivedDevices(const Devices& devices);
-  void ReceivedDeviceInfo(scoped_refptr<Device> device,
-                          const DeviceInfo& device_info);
+  void ReceivedDevices(const AndroidDeviceManager::Devices& devices);
+  void ReceivedDeviceInfo(scoped_refptr<AndroidDeviceManager::Device> device,
+                          const AndroidDeviceManager::DeviceInfo& device_info);
   void ReceivedVersion(scoped_refptr<RemoteBrowser>,
                        int result,
                        const std::string& response);
   void ReceivedPages(scoped_refptr<RemoteBrowser>,
                      int result,
                      const std::string& response);
 
   DiscoveryCallback callback_;
+  AndroidDeviceManager::Devices devices_;
   RemoteDevices remote_devices_;
 };
 
-DiscoveryRequest::DiscoveryRequest(
+DevToolsAndroidBridge::DiscoveryRequest::DiscoveryRequest(
     AndroidDeviceManager* device_manager,
     const DiscoveryCallback& callback)
     : callback_(callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   device_manager->QueryDevices(
       base::Bind(&DiscoveryRequest::ReceivedDevices, this));
 }
 
-DiscoveryRequest::~DiscoveryRequest() {
+DevToolsAndroidBridge::DiscoveryRequest::~DiscoveryRequest() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  callback_.Run(remote_devices_);
+  callback_.Run(devices_, remote_devices_);
 }
 
-void DiscoveryRequest::ReceivedDevices(const Devices& devices) {
+void DevToolsAndroidBridge::DiscoveryRequest::ReceivedDevices(
+    const AndroidDeviceManager::Devices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  for (Devices::const_iterator it = devices.begin();
+  devices_ = devices;
+  for (AndroidDeviceManager::Devices::const_iterator it = devices.begin();
        it != devices.end(); ++it) {
     (*it)->QueryDeviceInfo(
         base::Bind(&DiscoveryRequest::ReceivedDeviceInfo, this, *it));
   }
 }
 
-void DiscoveryRequest::ReceivedDeviceInfo(scoped_refptr<Device> device,
-                                          const DeviceInfo& device_info) {
+void DevToolsAndroidBridge::DiscoveryRequest::ReceivedDeviceInfo(
+    scoped_refptr<AndroidDeviceManager::Device> device,
+    const AndroidDeviceManager::DeviceInfo& device_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_refptr<RemoteDevice> remote_device =
-      new RemoteDevice(device, device_info);
+      new RemoteDevice(device->serial(), device_info);
   remote_devices_.push_back(remote_device);
   for (RemoteBrowsers::iterator it = remote_device->browsers().begin();
        it != remote_device->browsers().end(); ++it) {
-    (*it)->SendJsonRequest(
+    device->SendJsonRequest(
+        (*it)->socket(),
         kVersionRequest,
         base::Bind(&DiscoveryRequest::ReceivedVersion, this, *it));
-    (*it)->SendJsonRequest(
+    device->SendJsonRequest(
+        (*it)->socket(),
         kPageListRequest,
         base::Bind(&DiscoveryRequest::ReceivedPages, this, *it));
   }
 }
 
-void DiscoveryRequest::ReceivedVersion(scoped_refptr<RemoteBrowser> browser,
-                                       int result,
-                                       const std::string& response) {
+void DevToolsAndroidBridge::DiscoveryRequest::ReceivedVersion(
+    scoped_refptr<RemoteBrowser> browser,
+    int result,
+    const std::string& response) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (result < 0)
     return;
   // Parse version, append to package name if available,
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::DictionaryValue* dict;
   if (value && value->GetAsDictionary(&dict)) {
     std::string browser_name;
     if (dict->GetString("Browser", &browser_name)) {
       std::vector<std::string> parts;
       Tokenize(browser_name, "/", &parts);
       if (parts.size() == 2)
-        browser->set_version(parts[1]);
+        browser->version_ = parts[1];
       else
-        browser->set_version(browser_name);
+        browser->version_ = browser_name;
     }
     std::string package;
     if (dict->GetString("Android-Package", &package)) {
-      browser->set_display_name(
-          AdbDeviceInfoQuery::GetDisplayName(browser->socket(), package));
+      browser->display_name_ =
+          AdbDeviceInfoQuery::GetDisplayName(browser->socket(), package);
     }
   }
 }
 
-void DiscoveryRequest::ReceivedPages(scoped_refptr<RemoteBrowser> browser,
-                                     int result,
-                                     const std::string& response) {
+void DevToolsAndroidBridge::DiscoveryRequest::ReceivedPages(
+    scoped_refptr<RemoteBrowser> browser,
+    int result,
+    const std::string& response) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (result < 0)
     return;
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::ListValue* list_value;
   if (value && value->GetAsList(&list_value))
-    browser->SetPageDescriptors(*list_value);
+    browser->page_descriptors_.reset(list_value->DeepCopy());
 }
 
 // ProtocolCommand ------------------------------------------------------------
 
+namespace {
+
 class ProtocolCommand
-    : public DevToolsAndroidBridge::AndroidWebSocket::Delegate {
+    : public AndroidDeviceManager::AndroidWebSocket::Delegate {
  public:
   ProtocolCommand(
-      scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
+      scoped_refptr<AndroidDeviceManager::Device> device,
+      const std::string& socket,
       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();
 
   const std::string command_;
   const base::Closure callback_;
-  scoped_ptr<DevToolsAndroidBridge::AndroidWebSocket> web_socket_;
+  scoped_ptr<AndroidDeviceManager::AndroidWebSocket> web_socket_;
 
   DISALLOW_COPY_AND_ASSIGN(ProtocolCommand);
 };
 
 ProtocolCommand::ProtocolCommand(
-    scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
+    scoped_refptr<AndroidDeviceManager::Device> device,
+    const std::string& socket,
     const std::string& debug_url,
     const std::string& command,
     const base::Closure callback)
     : command_(command),
       callback_(callback),
-      web_socket_(browser->CreateWebSocket(debug_url, this)) {
+      web_socket_(device->CreateWebSocket(socket, debug_url, this)) {
 }
 
 void ProtocolCommand::OnSocketOpened() {
   web_socket_->SendFrame(command_);
 }
 
 void ProtocolCommand::OnFrameRead(const std::string& message) {
   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) {
   bridge_ = new DevToolsAndroidBridge(Profile::FromBrowserContext(context));
 }
 
 DevToolsAndroidBridge::Wrapper::~Wrapper() {
 }
 
 DevToolsAndroidBridge* DevToolsAndroidBridge::Wrapper::Get() {
   return bridge_.get();
 }
@@ skipping 17 matching lines @@
           "DevToolsAndroidBridge",
           BrowserContextDependencyManager::GetInstance()) {}
 
 DevToolsAndroidBridge::Factory::~Factory() {}
 
 KeyedService* DevToolsAndroidBridge::Factory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
   return new DevToolsAndroidBridge::Wrapper(context);
 }
 
-
 // AgentHostDelegate ----------------------------------------------------------
 
-class AgentHostDelegate
+class DevToolsAndroidBridge::AgentHostDelegate
     : public content::DevToolsExternalAgentProxyDelegate,
-      public DevToolsAndroidBridge::AndroidWebSocket::Delegate {
+      public AndroidDeviceManager::AndroidWebSocket::Delegate {
  public:
   static scoped_refptr<content::DevToolsAgentHost> GetOrCreateAgentHost(
+      scoped_refptr<DevToolsAndroidBridge> bridge,
       const std::string& id,
-      scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
+      scoped_refptr<RemoteBrowser> browser,
       const std::string& debug_url);
 
  private:
   AgentHostDelegate(
+      scoped_refptr<DevToolsAndroidBridge> bridge,
       const std::string& id,
-      scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
+      scoped_refptr<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;
 
-  const std::string id_;
-  scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser_;
-  const std::string debug_url_;
+  std::string id_;
+  scoped_refptr<DevToolsAndroidBridge> bridge_;
+  scoped_refptr<RemoteBrowser> browser_;
+  std::string debug_url_;
   bool socket_opened_;
   bool is_web_view_;
   std::vector<std::string> pending_messages_;
-  scoped_ptr<DevToolsAndroidBridge::AndroidWebSocket> web_socket_;
+  scoped_ptr<AndroidDeviceManager::AndroidWebSocket> web_socket_;
   content::DevToolsAgentHost* agent_host_;
   content::DevToolsExternalAgentProxy* proxy_;
   DISALLOW_COPY_AND_ASSIGN(AgentHostDelegate);
 };
 
 // static
 scoped_refptr<content::DevToolsAgentHost>
-AgentHostDelegate::GetOrCreateAgentHost(
+DevToolsAndroidBridge::AgentHostDelegate::GetOrCreateAgentHost(
+    scoped_refptr<DevToolsAndroidBridge> bridge,
     const std::string& id,
-    scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
+    scoped_refptr<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())
+  AgentHostDelegates::iterator it = bridge->host_delegates_.find(id);
+  if (it != bridge->host_delegates_.end())
     return it->second->agent_host_;
 
-  AgentHostDelegate* delegate = new AgentHostDelegate(id, browser, debug_url);
+  AgentHostDelegate* delegate =
+      new AgentHostDelegate(bridge, id, browser, debug_url);
   scoped_refptr<content::DevToolsAgentHost> result =
       content::DevToolsAgentHost::Create(delegate);
   delegate->agent_host_ = result.get();
   return result;
 }
 
-AgentHostDelegate::AgentHostDelegate(
+DevToolsAndroidBridge::AgentHostDelegate::AgentHostDelegate(
+    scoped_refptr<DevToolsAndroidBridge> bridge,
     const std::string& id,
-    scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
+    scoped_refptr<RemoteBrowser> browser,
     const std::string& debug_url)
     : id_(id),
+      bridge_(bridge),
       browser_(browser),
       debug_url_(debug_url),
       socket_opened_(false),
       is_web_view_(browser->IsWebView()),
       agent_host_(NULL),
       proxy_(NULL) {
-  g_host_delegates.Get()[id] = this;
+  bridge_->host_delegates_[id] = this;
 }
 
-AgentHostDelegate::~AgentHostDelegate() {
-  g_host_delegates.Get().erase(id_);
+DevToolsAndroidBridge::AgentHostDelegate::~AgentHostDelegate() {
+  bridge_->host_delegates_.erase(id_);
 }
 
-void AgentHostDelegate::Attach(content::DevToolsExternalAgentProxy* proxy) {
+void DevToolsAndroidBridge::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_.reset(
+      bridge_->CreateWebSocket(browser_, debug_url_, this));
 }
 
-void AgentHostDelegate::Detach() {
+void DevToolsAndroidBridge::AgentHostDelegate::Detach() {
   web_socket_.reset();
 }
 
-void AgentHostDelegate::SendMessageToBackend(const std::string& message) {
+void DevToolsAndroidBridge::AgentHostDelegate::SendMessageToBackend(
+    const std::string& message) {
   if (socket_opened_)
     web_socket_->SendFrame(message);
   else
     pending_messages_.push_back(message);
 }
 
-void AgentHostDelegate::OnSocketOpened() {
+void DevToolsAndroidBridge::AgentHostDelegate::OnSocketOpened() {
   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) {
+void DevToolsAndroidBridge::AgentHostDelegate::OnFrameRead(
+    const std::string& message) {
   if (proxy_)
       proxy_->DispatchOnClientHost(message);
 }
 
-void AgentHostDelegate::OnSocketClosed() {
+void DevToolsAndroidBridge::AgentHostDelegate::OnSocketClosed() {
   if (proxy_)
     proxy_->ConnectionClosed();
 }
 
 //// RemotePageTarget ----------------------------------------------
 
-class RemotePageTarget : public DevToolsTargetImpl,
-                         public DevToolsAndroidBridge::RemotePage {
+class DevToolsAndroidBridge::RemotePageTarget
+    : public DevToolsTargetImpl,
+      public DevToolsAndroidBridge::RemotePage {
  public:
-  RemotePageTarget(scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
+  RemotePageTarget(scoped_refptr<DevToolsAndroidBridge> bridge,
+                   scoped_refptr<RemoteBrowser> browser,
                    const base::DictionaryValue& value);
   virtual ~RemotePageTarget();
 
   // DevToolsAndroidBridge::RemotePage implementation.
   virtual DevToolsTargetImpl* GetTarget() OVERRIDE;
   virtual std::string GetFrontendURL() OVERRIDE;
 
   // DevToolsTargetImpl overrides.
   virtual std::string GetId() const OVERRIDE;
   virtual bool IsAttached() const OVERRIDE;
   virtual bool Activate() const OVERRIDE;
   virtual bool Close() const OVERRIDE;
   virtual void Inspect(Profile* profile) const OVERRIDE;
   virtual void Reload() const OVERRIDE;
 
   void Navigate(const std::string& url, base::Closure callback) const;
 
  private:
-  scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser_;
+  scoped_refptr<DevToolsAndroidBridge> bridge_;
+  scoped_refptr<RemoteBrowser> browser_;
   std::string debug_url_;
   std::string frontend_url_;
   std::string remote_id_;
   std::string remote_type_;
   std::string local_id_;
   DISALLOW_COPY_AND_ASSIGN(RemotePageTarget);
 };
 
 static std::string GetStringProperty(const base::DictionaryValue& value,
                                      const std::string& name) {
   std::string result;
   value.GetString(name, &result);
   return result;
 }
 
 static std::string BuildUniqueTargetId(
     DevToolsAndroidBridge::RemoteBrowser* browser,
     const base::DictionaryValue& value) {
   return base::StringPrintf("%s:%s:%s", browser->serial().c_str(),
       browser->socket().c_str(), GetStringProperty(value, "id").c_str());
 }
 
 static std::string GetDebugURL(const base::DictionaryValue& value) {
   std::string debug_url = GetStringProperty(value, "webSocketDebuggerUrl");
 
   if (debug_url.find("ws://") == 0)
     debug_url = debug_url.substr(5);
   else
-    debug_url = "";
+    debug_url = std::string();
   return debug_url;
 }
 
-RemotePageTarget::RemotePageTarget(
-    scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
+DevToolsAndroidBridge::RemotePageTarget::RemotePageTarget(
+    scoped_refptr<DevToolsAndroidBridge> bridge,
+    scoped_refptr<RemoteBrowser> browser,
     const base::DictionaryValue& value)
     : DevToolsTargetImpl(AgentHostDelegate::GetOrCreateAgentHost(
+                             bridge,
                              BuildUniqueTargetId(browser.get(), value),
-                             browser, GetDebugURL(value))),
+                             browser,
+                             GetDebugURL(value))),
+      bridge_(bridge),
       browser_(browser),
       debug_url_(GetDebugURL(value)),
       remote_id_(GetStringProperty(value, "id")),
       remote_type_(GetStringProperty(value, "type")),
       local_id_(BuildUniqueTargetId(browser.get(), value)) {
   set_type("adb_page");
   set_url(GURL(GetStringProperty(value, "url")));
   set_title(base::UTF16ToUTF8(net::UnescapeForHTML(base::UTF8ToUTF16(
       GetStringProperty(value, "title")))));
   set_description(GetStringProperty(value, "description"));
   set_favicon_url(GURL(GetStringProperty(value, "faviconUrl")));
   debug_url_ = GetDebugURL(value);
   frontend_url_ = GetStringProperty(value, "devtoolsFrontendUrl");
 
   size_t ws_param = frontend_url_.find("?ws");
   if (ws_param != std::string::npos)
     frontend_url_ = frontend_url_.substr(0, ws_param);
   if (frontend_url_.find("http:") == 0)
     frontend_url_ = "https:" + frontend_url_.substr(5);
 }
 
-RemotePageTarget::~RemotePageTarget() {
+DevToolsAndroidBridge::RemotePageTarget::~RemotePageTarget() {
 }
 
-DevToolsTargetImpl* RemotePageTarget::GetTarget() {
+DevToolsTargetImpl* DevToolsAndroidBridge::RemotePageTarget::GetTarget() {
   return this;
 }
 
-std::string RemotePageTarget::GetFrontendURL() {
+std::string DevToolsAndroidBridge::RemotePageTarget::GetFrontendURL() {
   return frontend_url_;
 }
 
-std::string RemotePageTarget::GetId() const {
+std::string DevToolsAndroidBridge::RemotePageTarget::GetId() const {
   return local_id_;
 }
 
-bool RemotePageTarget::IsAttached() const {
+bool DevToolsAndroidBridge::RemotePageTarget::IsAttached() const {
   return debug_url_.empty();
 }
 
 static void NoOp(int, const std::string&) {}
 
-void RemotePageTarget::Inspect(Profile* profile) const {
+void DevToolsAndroidBridge::RemotePageTarget::Inspect(Profile* profile) const {
   Activate();
   bool isWorker = remote_type_ == kTargetTypeWorker ||
                   remote_type_ == kTargetTypeServiceWorker;
   DevToolsWindow::OpenExternalFrontend(profile, frontend_url_, GetAgentHost(),
                                        isWorker);
 }
 
-bool RemotePageTarget::Activate() const {
+bool DevToolsAndroidBridge::RemotePageTarget::Activate() const {
   std::string request = base::StringPrintf(kActivatePageRequest,
                                            remote_id_.c_str());
-  browser_->SendJsonRequest(request, base::Bind(&NoOp));
+  bridge_->SendJsonRequest(browser_, request, base::Bind(&NoOp));
   return true;
 }
 
-bool RemotePageTarget::Close() const {
+bool DevToolsAndroidBridge::RemotePageTarget::Close() const {
   std::string request = base::StringPrintf(kClosePageRequest,
                                            remote_id_.c_str());
-  browser_->SendJsonRequest(request, base::Bind(&NoOp));
+  bridge_->SendJsonRequest(browser_, request, base::Bind(&NoOp));
   return true;
 }
 
-void RemotePageTarget::Reload() const {
-  browser_->SendProtocolCommand(debug_url_, kPageReloadCommand, NULL,
-                                base::Closure());
+void DevToolsAndroidBridge::RemotePageTarget::Reload() const {
+  bridge_->SendProtocolCommand(browser_, debug_url_, kPageReloadCommand,
+                               NULL, base::Closure());
 }
 
-void RemotePageTarget::Navigate(const std::string& url,
-                                base::Closure callback) const {
+void DevToolsAndroidBridge::RemotePageTarget::Navigate(
+    const std::string& url,
+    base::Closure callback) const {
   base::DictionaryValue params;
   params.SetString(kUrlParam, url);
-  browser_->SendProtocolCommand(debug_url_, kPageNavigateCommand, &params,
-                                callback);
+  bridge_->SendProtocolCommand(browser_, debug_url_, kPageNavigateCommand,
+                               &params, callback);
 }
 
 // DevToolsAndroidBridge::RemoteBrowser ---------------------------------------
 
 DevToolsAndroidBridge::RemoteBrowser::RemoteBrowser(
-    scoped_refptr<Device> device,
+    const std::string& serial,
     const AndroidDeviceManager::BrowserInfo& browser_info)
-    : device_(device),
+    : serial_(serial),
       socket_(browser_info.socket_name),
       display_name_(browser_info.display_name),
       type_(browser_info.type),
       page_descriptors_(new base::ListValue()) {
 }
 
-bool DevToolsAndroidBridge::RemoteBrowser::IsChrome() const {
+bool DevToolsAndroidBridge::RemoteBrowser::IsChrome() {
   return type_ == AndroidDeviceManager::BrowserInfo::kTypeChrome;
 }
 
-bool DevToolsAndroidBridge::RemoteBrowser::IsWebView() const {
+bool DevToolsAndroidBridge::RemoteBrowser::IsWebView() {
   return type_ == AndroidDeviceManager::BrowserInfo::kTypeWebView;
 }
 
 DevToolsAndroidBridge::RemoteBrowser::ParsedVersion
-DevToolsAndroidBridge::RemoteBrowser::GetParsedVersion() const {
+DevToolsAndroidBridge::RemoteBrowser::GetParsedVersion() {
   ParsedVersion result;
   std::vector<std::string> parts;
   Tokenize(version_, ".", &parts);
   for (size_t i = 0; i != parts.size(); ++i) {
     int value = 0;
     base::StringToInt(parts[i], &value);
     result.push_back(value);
   }
   return result;
 }
 
 std::vector<DevToolsAndroidBridge::RemotePage*>
-DevToolsAndroidBridge::RemoteBrowser::CreatePages() {
-  std::vector<DevToolsAndroidBridge::RemotePage*> result;
-  for (size_t i = 0; i < page_descriptors_->GetSize(); ++i) {
-    base::Value* item;
-    page_descriptors_->Get(i, &item);
-    if (!item)
-      continue;
+DevToolsAndroidBridge::CreatePages(scoped_refptr<RemoteBrowser> browser) {
+  std::vector<RemotePage*> result;
+  for (base::ListValue::const_iterator it = browser->page_descriptors().begin();
+      it != browser->page_descriptors().end(); ++it) {
     base::DictionaryValue* dict;
-    if (!item->GetAsDictionary(&dict))
-      continue;
-    result.push_back(new RemotePageTarget(this, *dict));
+    if (*it && (*it)->GetAsDictionary(&dict))
+      result.push_back(new RemotePageTarget(this, browser, *dict));
   }
   return result;
 }
 
-void DevToolsAndroidBridge::RemoteBrowser::SetPageDescriptors(
-    const base::ListValue& list) {
-  page_descriptors_.reset(list.DeepCopy());
+const base::ListValue&
+DevToolsAndroidBridge::RemoteBrowser::page_descriptors() {
+  return *page_descriptors_;
 }
 
-static void RespondOnUIThread(
-    const DevToolsAndroidBridge::JsonRequestCallback& callback,
-    int result,
-    const std::string& response) {
-  if (callback.is_null())
+void DevToolsAndroidBridge::SendJsonRequest(
+    scoped_refptr<RemoteBrowser> browser,
+    const std::string& request,
+    const JsonRequestCallback& callback) {
+  DeviceMap::iterator it = device_map_.find(browser->serial());
+  if (it == device_map_.end()) {
+    callback.Run(net::ERR_FAILED, std::string());
     return;
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE, base::Bind(callback, result, response));
+  }
+  it->second->SendJsonRequest(browser->socket(), request, callback);
 }
 
-void DevToolsAndroidBridge::RemoteBrowser::SendJsonRequest(
-    const std::string& request, const JsonRequestCallback& callback) {
-  device_->SendJsonRequest(socket_, request, callback);
-}
-
-void DevToolsAndroidBridge::RemoteBrowser::SendProtocolCommand(
+void DevToolsAndroidBridge::SendProtocolCommand(
+    scoped_refptr<RemoteBrowser> browser,
     const std::string& debug_url,
     const std::string& method,
     base::DictionaryValue* params,
     const base::Closure callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (debug_url.empty())
     return;
+  DeviceMap::iterator it = device_map_.find(browser->serial());
+  if (it == device_map_.end()) {
+    callback.Run();
+    return;
+  }
   DevToolsProtocol::Command command(1, method, params);
-  new ProtocolCommand(this, debug_url, command.Serialize(), callback);
-}
-
-void DevToolsAndroidBridge::RemoteBrowser::Open(
-    const std::string& url,
-    const DevToolsAndroidBridge::RemotePageCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  InnerOpen(url, base::Bind(&RemoteBrowser::RespondToOpenOnUIThread,
-                            this, callback));
+  new ProtocolCommand(it->second, browser->socket(), debug_url,
+                      command.Serialize(), callback);
 }
 
 scoped_refptr<content::DevToolsAgentHost>
-DevToolsAndroidBridge::RemoteBrowser::GetAgentHost() {
+DevToolsAndroidBridge::GetBrowserAgentHost(
+    scoped_refptr<RemoteBrowser> browser) {
   return AgentHostDelegate::GetOrCreateAgentHost(
-      "adb:" + device_->serial() + ":" + socket_, this, kBrowserTargetSocket);
+      this,
+      "adb:" + browser->serial() + ":" + browser->socket(),
+      browser,
+      kBrowserTargetSocket);
 }
 
-DevToolsAndroidBridge::AndroidWebSocket*
-DevToolsAndroidBridge::RemoteBrowser::CreateWebSocket(
+AndroidDeviceManager::AndroidWebSocket*
+DevToolsAndroidBridge::CreateWebSocket(
+    scoped_refptr<RemoteBrowser> browser,
     const std::string& url,
-    DevToolsAndroidBridge::AndroidWebSocket::Delegate* delegate) {
-  return device_->CreateWebSocket(socket_, url, delegate);
+    AndroidDeviceManager::AndroidWebSocket::Delegate* delegate) {
+  DeviceMap::iterator it = device_map_.find(browser->serial());
+  if (it == device_map_.end())
+    return NULL;
+
+  return it->second->CreateWebSocket(browser->socket(), url, delegate);
 }
 
-void DevToolsAndroidBridge::RemoteBrowser::RespondToOpenOnUIThread(
-    const DevToolsAndroidBridge::RemotePageCallback& callback,
+void DevToolsAndroidBridge::RespondToOpenOnUIThread(
+    scoped_refptr<RemoteBrowser> browser,
+    const RemotePageCallback& callback,
     int result,
     const std::string& response) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (result < 0) {
     callback.Run(NULL);
     return;
   }
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::DictionaryValue* dict;
   if (value && value->GetAsDictionary(&dict)) {
-    RemotePageTarget* new_page = new RemotePageTarget(this, *dict);
+    RemotePageTarget* new_page = new RemotePageTarget(this, browser, *dict);
     callback.Run(new_page);
   }
 }
 
-void DevToolsAndroidBridge::RemoteBrowser::InnerOpen(
+void DevToolsAndroidBridge::Open(
+    scoped_refptr<RemoteBrowser> browser,
     const std::string& input_url,
-    const JsonRequestCallback& callback) {
+    const DevToolsAndroidBridge::RemotePageCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   GURL gurl(input_url);
   if (!gurl.is_valid()) {
     gurl = GURL("http://" + input_url);
     if (!gurl.is_valid())
-     return;
+      return;
   }
   std::string url = gurl.spec();
+  RemoteBrowser::ParsedVersion parsed_version = browser->GetParsedVersion();
 
-  ParsedVersion parsed_version = GetParsedVersion();
-  if (IsChrome() &&
+  if (browser->IsChrome() &&
       !parsed_version.empty() &&
       parsed_version[0] >= kMinVersionNewWithURL) {
     std::string query = net::EscapeQueryParamValue(url, false /* use_plus */);
     std::string request =
         base::StringPrintf(kNewPageRequestWithURL, query.c_str());
-    SendJsonRequest(request, callback);
+    SendJsonRequest(browser, request,
+                    base::Bind(&DevToolsAndroidBridge::RespondToOpenOnUIThread,
+                               this, browser, callback));
   } else {
-    SendJsonRequest(kNewPageRequest,
-        base::Bind(&RemoteBrowser::PageCreatedOnUIThread, this,
-                   callback, url));
+    SendJsonRequest(browser, kNewPageRequest,
+                    base::Bind(&DevToolsAndroidBridge::PageCreatedOnUIThread,
+                               this, browser, callback, url));
   }
 }
 
-void DevToolsAndroidBridge::RemoteBrowser::PageCreatedOnUIThread(
-    const JsonRequestCallback& callback,
-    const std::string& url, int result, const std::string& response) {
+void DevToolsAndroidBridge::PageCreatedOnUIThread(
+    scoped_refptr<RemoteBrowser> browser,
+    const RemotePageCallback& callback,
+    const std::string& url,
+    int result,
+    const std::string& response) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (result < 0)
     return;
   // Navigating too soon after the page creation breaks navigation history
   // (crbug.com/311014). This can be avoided by adding a moderate delay.
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&RemoteBrowser::NavigatePageOnUIThread,
-                 this, callback, result, response, url),
+      base::Bind(&DevToolsAndroidBridge::NavigatePageOnUIThread,
+                 this, browser, callback, result, response, url),
       base::TimeDelta::FromMilliseconds(kNewPageNavigateDelayMs));
 }
 
-void DevToolsAndroidBridge::RemoteBrowser::NavigatePageOnUIThread(
-    const JsonRequestCallback& callback,
-    int result, const std::string& response, const std::string& url) {
+void DevToolsAndroidBridge::NavigatePageOnUIThread(
+    scoped_refptr<RemoteBrowser> browser,
+    const RemotePageCallback& callback,
+    int result,
+    const std::string& response,
+    const std::string& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::DictionaryValue* dict;
 
   if (value && value->GetAsDictionary(&dict)) {
-    RemotePageTarget new_page(this, *dict);
+    RemotePageTarget new_page(this, browser, *dict);
     new_page.Navigate(url,
-        base::Bind(&RespondOnUIThread, callback, result, response));
+        base::Bind(&DevToolsAndroidBridge::RespondToOpenOnUIThread,
+                   this, browser, callback, result, response));
   }
 }
 
 DevToolsAndroidBridge::RemoteBrowser::~RemoteBrowser() {
 }
 
 // DevToolsAndroidBridge::RemoteDevice ----------------------------------------
 
 DevToolsAndroidBridge::RemoteDevice::RemoteDevice(
-    scoped_refptr<AndroidDeviceManager::Device> device,
+    const std::string& serial,
     const AndroidDeviceManager::DeviceInfo& device_info)
-    : device_(device),
+    : serial_(serial),
       model_(device_info.model),
       connected_(device_info.connected),
       screen_size_(device_info.screen_size) {
   for (std::vector<AndroidDeviceManager::BrowserInfo>::const_iterator it =
       device_info.browser_info.begin();
       it != device_info.browser_info.end();
       ++it) {
-    browsers_.push_back(new DevToolsAndroidBridge::RemoteBrowser(device, *it));
+    browsers_.push_back(new RemoteBrowser(serial, *it));
   }
 }
 
-void DevToolsAndroidBridge::RemoteDevice::OpenSocket(
-    const std::string& socket_name,
-    const AndroidDeviceManager::SocketCallback& callback) {
-  device_->OpenSocket(socket_name, callback);
-}
-
 DevToolsAndroidBridge::RemoteDevice::~RemoteDevice() {
 }
 
 // DevToolsAndroidBridge ------------------------------------------------------
 
 DevToolsAndroidBridge::DevToolsAndroidBridge(Profile* profile)
     : profile_(profile),
       device_manager_(AndroidDeviceManager::Create()),
       task_scheduler_(base::Bind(&DevToolsAndroidBridge::ScheduleTaskDefault)),
       port_forwarding_controller_(new PortForwardingController(profile)) {
@@ skipping 56 matching lines @@
   PortForwardingListeners::iterator it = std::find(
       port_forwarding_listeners_.begin(),
       port_forwarding_listeners_.end(),
       listener);
   DCHECK(it != port_forwarding_listeners_.end());
   port_forwarding_listeners_.erase(it);
   if (!NeedsDeviceListPolling())
     StopDeviceListPolling();
 }
 
-// static
 bool DevToolsAndroidBridge::HasDevToolsWindow(const std::string& agent_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return g_host_delegates.Get().find(agent_id) != g_host_delegates.Get().end();
+  return host_delegates_.find(agent_id) != host_delegates_.end();
 }
 
 DevToolsAndroidBridge::~DevToolsAndroidBridge() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(device_list_listeners_.empty());
   DCHECK(device_count_listeners_.empty());
   DCHECK(port_forwarding_listeners_.empty());
 }
 
 void DevToolsAndroidBridge::StartDeviceListPolling() {
   device_list_callback_.Reset(
     base::Bind(&DevToolsAndroidBridge::ReceivedDeviceList, this));
   RequestDeviceList(device_list_callback_.callback());
 }
 
 void DevToolsAndroidBridge::StopDeviceListPolling() {
   device_list_callback_.Cancel();
-  devices_.clear();
+  device_map_.clear();
 }
 
 bool DevToolsAndroidBridge::NeedsDeviceListPolling() {
   return !device_list_listeners_.empty() || !port_forwarding_listeners_.empty();
 }
 
 void DevToolsAndroidBridge::RequestDeviceList(
-    const base::Callback<void(const RemoteDevices&)>& callback) {
+    const DeviceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!NeedsDeviceListPolling() ||
       !callback.Equals(device_list_callback_.callback()))
     return;
 
   new DiscoveryRequest(device_manager_.get(), callback);
 }
 
-void DevToolsAndroidBridge::ReceivedDeviceList(const RemoteDevices& devices) {
+void DevToolsAndroidBridge::ReceivedDeviceList(
+    const AndroidDeviceManager::Devices& devices,
+    const RemoteDevices& remote_devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  device_map_.clear();
+  for (AndroidDeviceManager::Devices::const_iterator it = devices.begin();
+      it != devices.end(); ++it) {
+    device_map_[(*it)->serial()] = *it;
+  }
+
   DeviceListListeners copy(device_list_listeners_);
   for (DeviceListListeners::iterator it = copy.begin(); it != copy.end(); ++it)
-    (*it)->DeviceListChanged(devices);
+    (*it)->DeviceListChanged(remote_devices);
 
   DevicesStatus status =
-      port_forwarding_controller_->DeviceListChanged(devices);
+      port_forwarding_controller_->DeviceListChanged(device_map_,
+                                                     remote_devices);
   PortForwardingListeners forwarding_listeners(port_forwarding_listeners_);
   for (PortForwardingListeners::iterator it = forwarding_listeners.begin();
        it != forwarding_listeners.end(); ++it) {
     (*it)->PortStatusChanged(status);
   }
 
   if (!NeedsDeviceListPolling())
     return;
 
-  devices_ = devices;
-
   task_scheduler_.Run(
       base::Bind(&DevToolsAndroidBridge::RequestDeviceList,
                  this, device_list_callback_.callback()));
 }
 
 void DevToolsAndroidBridge::StartDeviceCountPolling() {
   device_count_callback_.Reset(
       base::Bind(&DevToolsAndroidBridge::ReceivedDeviceCount, this));
   RequestDeviceCount(device_count_callback_.callback());
 }
@@ skipping 56 matching lines @@
   bool enabled;
   if (pref_value->GetAsBoolean(&enabled) && enabled) {
     device_providers.push_back(new UsbDeviceProvider(profile_));
   }
   device_manager_->SetDeviceProviders(device_providers);
   if (NeedsDeviceListPolling()) {
     StopDeviceListPolling();
     StartDeviceListPolling();
   }
 }