DevTools: untangle device discovery request from the devtools android bridge.

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 <stddef.h>
 #include <algorithm>
 #include <map>
 #include <set>
@@ skipping 57 matching lines @@
 const int kAdbPollingIntervalMs = 1000;
 
 const char kPageReloadCommand[] = "Page.reload";
 
 const char kWebViewSocketPrefix[] = "webview_devtools_remote";
 
 const char kChromeDiscoveryURL[] = "localhost:9222";
 const char kNodeDiscoveryURL[] = "localhost:9229";
 
 bool BrowserIdFromString(const std::string& browser_id_str,
-                         DevToolsAndroidBridge::BrowserId* browser_id) {
+                         std::string* serial,
+                         std::string* browser_id) {
   size_t colon_pos = browser_id_str.find(':');
   if (colon_pos == std::string::npos)
     return false;
-  browser_id->first = browser_id_str.substr(0, colon_pos);
-  browser_id->second = browser_id_str.substr(colon_pos + 1);
+  *serial = browser_id_str.substr(0, colon_pos);
+  *browser_id = browser_id_str.substr(colon_pos + 1);
   return true;
 }
 
 static void NoOp(int, const std::string&) {}
 
 }  // namespace
 
 // DiscoveryRequest -----------------------------------------------------
 
 class DevToolsAndroidBridge::DiscoveryRequest
     : public base::RefCountedThreadSafe<DiscoveryRequest,
                                         BrowserThread::DeleteOnUIThread> {
  public:
   DiscoveryRequest(AndroidDeviceManager* device_manager,
                    const DeviceListCallback& callback);
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class base::DeleteHelper<DiscoveryRequest>;
   virtual ~DiscoveryRequest();
 
   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>,
+  void ReceivedPages(scoped_refptr<AndroidDeviceManager::Device> device,
+                     scoped_refptr<RemoteBrowser>,
                      int result,
                      const std::string& response);
 
   DeviceListCallback callback_;
   CompleteDevices complete_devices_;
 };
 
 DevToolsAndroidBridge::DiscoveryRequest::DiscoveryRequest(
     AndroidDeviceManager* device_manager,
     const DeviceListCallback& callback)
@@ skipping 26 matching lines @@
   complete_devices_.push_back(std::make_pair(device, remote_device));
   for (RemoteBrowsers::iterator it = remote_device->browsers().begin();
        it != remote_device->browsers().end(); ++it) {
     device->SendJsonRequest(
         (*it)->socket(),
         kVersionRequest,
         base::Bind(&DiscoveryRequest::ReceivedVersion, this, *it));
     device->SendJsonRequest(
         (*it)->socket(),
         kPageListRequest,
-        base::Bind(&DiscoveryRequest::ReceivedPages, this, *it));
+        base::Bind(&DiscoveryRequest::ReceivedPages, this, device, *it));
   }
 }
 
 void DevToolsAndroidBridge::DiscoveryRequest::ReceivedVersion(
     scoped_refptr<RemoteBrowser> browser,
     int result,
     const std::string& response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (result < 0)
     return;
@@ skipping 12 matching lines @@
     }
     std::string package;
     if (dict->GetString("Android-Package", &package)) {
       browser->display_name_ =
           AndroidDeviceManager::GetBrowserName(browser->socket(), package);
     }
   }
 }
 
 void DevToolsAndroidBridge::DiscoveryRequest::ReceivedPages(
+    scoped_refptr<AndroidDeviceManager::Device> device,
     scoped_refptr<RemoteBrowser> browser,
     int result,
     const std::string& response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (result < 0)
     return;
   std::unique_ptr<base::Value> value = base::JSONReader::Read(response);
   base::ListValue* list_value;
   if (value && value->GetAsList(&list_value)) {
     for (const auto& page_value : *list_value) {
       base::DictionaryValue* dict;
       if (page_value->GetAsDictionary(&dict))
-        browser->pages_.push_back(new RemotePage(browser->browser_id_, *dict));
+        browser->pages_.push_back(
+            new RemotePage(device, browser->browser_id_, *dict));
     }
   }
 }
 
 // ProtocolCommand ------------------------------------------------------------
 
 namespace {
 
 class ProtocolCommand
     : public AndroidDeviceManager::AndroidWebSocket::Delegate {
@@ skipping 75 matching lines @@
   return new DevToolsAndroidBridge(profile);
 }
 
 // AgentHostDelegate ----------------------------------------------------------
 
 class DevToolsAndroidBridge::AgentHostDelegate
     : public content::DevToolsExternalAgentProxyDelegate,
       public AndroidDeviceManager::AndroidWebSocket::Delegate {
  public:
   static scoped_refptr<content::DevToolsAgentHost> GetOrCreateAgentHost(
-      DevToolsAndroidBridge* bridge,
-      const BrowserId& browser_id,
+      scoped_refptr<AndroidDeviceManager::Device> device,
+      const std::string& browser_id,
       const std::string& local_id,
       const std::string& target_path,
       const std::string& type,
       base::DictionaryValue* value);
   ~AgentHostDelegate() override;
 
  private:
   AgentHostDelegate(
-      DevToolsAndroidBridge* bridge,
-      const BrowserId& browser_id,
+      scoped_refptr<AndroidDeviceManager::Device> device,
+      const std::string& browser_id,
       const std::string& local_id,
       const std::string& target_path,
       const std::string& type,
       base::DictionaryValue* value);
   // DevToolsExternalAgentProxyDelegate overrides.
   void Attach(content::DevToolsExternalAgentProxy* proxy) override;
   void Detach() override;
   std::string GetType() override;
   std::string GetTitle() override;
   std::string GetDescription() override;
   GURL GetURL() override;
   GURL GetFaviconURL() override;
   bool Activate() override;
-  bool Inspect() override;
+  bool Inspect(content::BrowserContext* context) override;
   void Reload() override;
   bool Close() override;
   void SendMessageToBackend(const std::string& message) override;
 
   void OnSocketOpened() override;
   void OnFrameRead(const std::string& message) override;
   void OnSocketClosed() override;
 
-  base::WeakPtr<DevToolsAndroidBridge> bridge_;
-  BrowserId browser_id_;
+  void SendProtocolCommand(const std::string& target_path,
+                           const std::string& method,
+                           std::unique_ptr<base::DictionaryValue> params,
+                           const base::Closure callback);
+
+  scoped_refptr<AndroidDeviceManager::Device> device_;
+  std::string browser_id_;
   std::string local_id_;
   std::string target_path_;
   std::string remote_type_;
   std::string remote_id_;
   std::string frontend_url_;
   std::string title_;
   std::string description_;
   GURL url_;
   GURL favicon_url_;
   bool socket_opened_;
   std::vector<std::string> pending_messages_;
   std::unique_ptr<AndroidDeviceManager::AndroidWebSocket> web_socket_;
   content::DevToolsAgentHost* agent_host_;
   content::DevToolsExternalAgentProxy* proxy_;
   DISALLOW_COPY_AND_ASSIGN(AgentHostDelegate);
 };
 
 static std::string GetStringProperty(base::DictionaryValue* value,
                                      const std::string& name) {
   std::string result;
   value->GetString(name, &result);
   return result;
 }
 
 static std::string BuildUniqueTargetId(
-    const DevToolsAndroidBridge::BrowserId& browser_id,
+    const std::string& serial,
+    const std::string& browser_id,
     base::DictionaryValue* value) {
-  return base::StringPrintf("%s:%s:%s", browser_id.first.c_str(),
-      browser_id.second.c_str(), GetStringProperty(value, "id").c_str());
+  return base::StringPrintf("%s:%s:%s", serial.c_str(),
+      browser_id.c_str(), GetStringProperty(value, "id").c_str());
 }
 
 static std::string GetFrontendURL(base::DictionaryValue* value) {
   std::string 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 (base::StartsWith(frontend_url, "http:", base::CompareCase::SENSITIVE))
     frontend_url = "https:" + frontend_url.substr(5);
   return frontend_url;
 }
 
 static std::string GetTargetPath(base::DictionaryValue* value) {
   std::string target_path = GetStringProperty(value, "webSocketDebuggerUrl");
 
   if (base::StartsWith(target_path, "ws://", base::CompareCase::SENSITIVE)) {
     size_t pos = target_path.find("/", 5);
     if (pos == std::string::npos)
       pos = 5;
     target_path = target_path.substr(pos);
   } else {
     target_path = std::string();
   }
   return target_path;
 }
 
 // static
 scoped_refptr<content::DevToolsAgentHost>
 DevToolsAndroidBridge::AgentHostDelegate::GetOrCreateAgentHost(
-    DevToolsAndroidBridge* bridge,
-    const BrowserId& browser_id,
+    scoped_refptr<AndroidDeviceManager::Device> device,
+    const std::string& browser_id,
     const std::string& local_id,
     const std::string& target_path,
     const std::string& type,
     base::DictionaryValue* value) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  AgentHostDelegates::iterator it = bridge->host_delegates_.find(local_id);
-  if (it != bridge->host_delegates_.end())
-    return it->second->agent_host_;
+  scoped_refptr<DevToolsAgentHost> result =
+      DevToolsAgentHost::GetForId(local_id);

[dgozman, 2016/09/22 17:13:59]

This essentially makes it cross-profile.

+  if (result)
+    return result;
 
   AgentHostDelegate* delegate = new AgentHostDelegate(
-      bridge, browser_id, local_id, target_path, type, value);
-  scoped_refptr<content::DevToolsAgentHost> result =
-      content::DevToolsAgentHost::Forward(local_id, base::WrapUnique(delegate));
+      device, browser_id, local_id, target_path, type, value);
+  result = content::DevToolsAgentHost::Forward(
+      local_id, base::WrapUnique(delegate));
   delegate->agent_host_ = result.get();
   return result;
 }
 
 DevToolsAndroidBridge::AgentHostDelegate::AgentHostDelegate(
-    DevToolsAndroidBridge* bridge,
-    const BrowserId& browser_id,
+    scoped_refptr<AndroidDeviceManager::Device> device,
+    const std::string& browser_id,
     const std::string& local_id,
     const std::string& target_path,
     const std::string& type,
     base::DictionaryValue* value)
-    : bridge_(bridge->AsWeakPtr()),
+    : device_(device),
       browser_id_(browser_id),
       local_id_(local_id),
       target_path_(target_path),
       remote_type_(type),
       remote_id_(value ? GetStringProperty(value, "id") : ""),
       frontend_url_(value ? GetFrontendURL(value) : ""),
       title_(value ? base::UTF16ToUTF8(net::UnescapeForHTML(base::UTF8ToUTF16(
           GetStringProperty(value, "title")))) : ""),
       description_(value ? GetStringProperty(value, "description") : ""),
       url_(GURL(value ? GetStringProperty(value, "url") : "")),
       favicon_url_(GURL(value ? GetStringProperty(value, "faviconUrl") : "")),
       socket_opened_(false),
       agent_host_(nullptr),
       proxy_(nullptr) {
-  bridge_->host_delegates_[local_id_] = this;
 }
 
 DevToolsAndroidBridge::AgentHostDelegate::~AgentHostDelegate() {
-  if (bridge_)
-    bridge_->host_delegates_.erase(local_id_);
 }
 
 void DevToolsAndroidBridge::AgentHostDelegate::Attach(
     content::DevToolsExternalAgentProxy* proxy) {
   proxy_ = proxy;
   content::RecordAction(
-      base::StartsWith(browser_id_.second, kWebViewSocketPrefix,
+      base::StartsWith(browser_id_, kWebViewSocketPrefix,
                        base::CompareCase::SENSITIVE)
           ? base::UserMetricsAction("DevTools_InspectAndroidWebView")
           : base::UserMetricsAction("DevTools_InspectAndroidPage"));
   web_socket_.reset(
-      bridge_->CreateWebSocket(browser_id_, target_path_, this));
+      device_->CreateWebSocket(browser_id_, target_path_, this));
 }
 
 void DevToolsAndroidBridge::AgentHostDelegate::Detach() {
   web_socket_.reset();
   proxy_ = nullptr;
 }
 
 std::string DevToolsAndroidBridge::AgentHostDelegate::GetType() {
   return remote_type_;
 }
 
 std::string DevToolsAndroidBridge::AgentHostDelegate::GetTitle() {
   return title_;
 }
 
 std::string DevToolsAndroidBridge::AgentHostDelegate::GetDescription() {
   return description_;
 }
 
 GURL DevToolsAndroidBridge::AgentHostDelegate::GetURL() {
   return url_;
 }
 
 GURL DevToolsAndroidBridge::AgentHostDelegate::GetFaviconURL() {
   return favicon_url_;
 }
 
 bool DevToolsAndroidBridge::AgentHostDelegate::Activate() {
-  if (!bridge_)
-    return false;
-
   std::string request = base::StringPrintf(kActivatePageRequest,
                                            remote_id_.c_str());
-  bridge_->SendJsonRequest(browser_id_, request, base::Bind(&NoOp));
+  device_->SendJsonRequest(browser_id_, request, base::Bind(&NoOp));
   return true;
 }
 
-bool DevToolsAndroidBridge::AgentHostDelegate::Inspect() {
+bool DevToolsAndroidBridge::AgentHostDelegate::Inspect(
+    content::BrowserContext* context) {
   Activate();
   bool is_worker = remote_type_ == DevToolsAgentHost::kTypeServiceWorker ||
                    remote_type_ == DevToolsAgentHost::kTypeSharedWorker;
   bool is_v8_only = remote_type_ == "node";
-  DevToolsWindow::OpenExternalFrontend(bridge_->profile_, frontend_url_,
-                                       agent_host_, is_worker, is_v8_only);
+  DevToolsWindow::OpenExternalFrontend(Profile::FromBrowserContext(context),
+                                       frontend_url_, agent_host_, is_worker,
+                                       is_v8_only);
   return true;
 }
 
 void DevToolsAndroidBridge::AgentHostDelegate::Reload() {
-  if (!bridge_)
-    return;
-
-  bridge_->SendProtocolCommand(browser_id_, target_path_, kPageReloadCommand,
-                               nullptr, base::Closure());
+  SendProtocolCommand(target_path_, kPageReloadCommand, nullptr,
+                      base::Closure());
 }
 
 bool DevToolsAndroidBridge::AgentHostDelegate::Close() {
-  if (!bridge_)
-    return false;
-
   std::string request = base::StringPrintf(kClosePageRequest,
                                            remote_id_.c_str());
-  bridge_->SendJsonRequest(browser_id_, request, base::Bind(&NoOp));
+  device_->SendJsonRequest(browser_id_, request, base::Bind(&NoOp));
   return true;
 }
 
 void DevToolsAndroidBridge::AgentHostDelegate::SendMessageToBackend(
     const std::string& message) {
   // We could have detached due to physical connection being closed.
   if (!proxy_)
     return;
   if (socket_opened_)
     web_socket_->SendFrame(message);
@@ skipping 18 matching lines @@
 
 void DevToolsAndroidBridge::AgentHostDelegate::OnSocketClosed() {
   if (proxy_) {
     std::string message = "{ \"method\": \"Inspector.detached\", "
         "\"params\": { \"reason\": \"Connection lost.\"} }";
     proxy_->DispatchOnClientHost(message);
     Detach();
   }
 }
 
+void DevToolsAndroidBridge::AgentHostDelegate::SendProtocolCommand(
+    const std::string& target_path,
+    const std::string& method,
+    std::unique_ptr<base::DictionaryValue> params,
+    const base::Closure callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (target_path.empty())
+    return;
+  new ProtocolCommand(
+      device_, browser_id_, target_path,
+      DevToolsProtocol::SerializeCommand(1, method, std::move(params)),
+      callback);
+}
+
 // DevToolsAndroidBridge::RemotePage ------------------------------------------
 
-DevToolsAndroidBridge::RemotePage::RemotePage(const BrowserId& browser_id,
-                                              const base::DictionaryValue& dict)
-    : browser_id_(browser_id),
+DevToolsAndroidBridge::RemotePage::RemotePage(
+    scoped_refptr<AndroidDeviceManager::Device> device,
+    const std::string& browser_id,
+    const base::DictionaryValue& dict)
+    : device_(device),
+      browser_id_(browser_id),
       dict_(dict.DeepCopy()) {
 }
 
 DevToolsAndroidBridge::RemotePage::~RemotePage() {
 }
 
+scoped_refptr<content::DevToolsAgentHost>
+DevToolsAndroidBridge::RemotePage::CreateTarget() {

[dgozman, 2016/09/22 17:13:59]

CreateAgentHost

+  std::string local_id = BuildUniqueTargetId(device_->serial(),
+                                             browser_id_,
+                                             dict_.get());
+  std::string target_path = GetTargetPath(dict_.get());
+  std::string type = GetStringProperty(dict_.get(), "type");

[dgozman, 2016/09/22 17:13:59]

kTypeProperty

+
+  return AgentHostDelegate::GetOrCreateAgentHost(
+      device_, browser_id_, local_id, target_path, type, dict_.get());
+}
+
 // DevToolsAndroidBridge::RemoteBrowser ---------------------------------------
 
 DevToolsAndroidBridge::RemoteBrowser::RemoteBrowser(
     const std::string& serial,
     const AndroidDeviceManager::BrowserInfo& browser_info)
-    : browser_id_(std::make_pair(serial, browser_info.socket_name)),
+    : serial_(serial),
+      browser_id_(browser_info.socket_name),
       display_name_(browser_info.display_name),
       user_(browser_info.user),
       type_(browser_info.type) {
 }
 
 bool DevToolsAndroidBridge::RemoteBrowser::IsChrome() {
   return type_ == AndroidDeviceManager::BrowserInfo::kTypeChrome;
 }
 
 std::string DevToolsAndroidBridge::RemoteBrowser::GetId() {
   return serial() + ":" + socket();
 }
 
 DevToolsAndroidBridge::RemoteBrowser::ParsedVersion
 DevToolsAndroidBridge::RemoteBrowser::GetParsedVersion() {
   ParsedVersion result;
   for (const base::StringPiece& part :
        base::SplitStringPiece(
            version_, ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
     int value = 0;
     base::StringToInt(part, &value);
     result.push_back(value);
   }
   return result;
 }
 
 scoped_refptr<content::DevToolsAgentHost>
-DevToolsAndroidBridge::CreatePageTarget(scoped_refptr<RemotePage> page) {
-  std::string local_id = BuildUniqueTargetId(page->browser_id_,
-                                             page->dict_.get());
-  std::string target_path = GetTargetPath(page->dict_.get());
-  std::string type = GetStringProperty(page->dict_.get(), "type");
-  return AgentHostDelegate::GetOrCreateAgentHost(
-      this, page->browser_id_, local_id, target_path, type, page->dict_.get());
-}
-
-void DevToolsAndroidBridge::SendJsonRequest(
-    const BrowserId& browser_id,
-    const std::string& request,
-    const JsonRequestCallback& callback) {
-  DeviceMap::iterator it = device_map_.find(browser_id.first);
-  if (it == device_map_.end()) {
-    callback.Run(net::ERR_FAILED, std::string());
-    return;
-  }
-  it->second->SendJsonRequest(browser_id.second, request, callback);
-}
-
-void DevToolsAndroidBridge::SendProtocolCommand(
-    const BrowserId& browser_id,
-    const std::string& target_path,
-    const std::string& method,
-    std::unique_ptr<base::DictionaryValue> params,
-    const base::Closure callback) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (target_path.empty())
-    return;
-  DeviceMap::iterator it = device_map_.find(browser_id.first);
-  if (it == device_map_.end()) {
-    callback.Run();
-    return;
-  }
-  new ProtocolCommand(
-      it->second, browser_id.second, target_path,
-      DevToolsProtocol::SerializeCommand(1, method, std::move(params)),
-      callback);
-}
-
-scoped_refptr<content::DevToolsAgentHost>
 DevToolsAndroidBridge::GetBrowserAgentHost(
     scoped_refptr<RemoteBrowser> browser) {
+  DeviceMap::iterator it = device_map_.find(browser->serial());
+  if (it == device_map_.end())
+    return nullptr;
+
   return AgentHostDelegate::GetOrCreateAgentHost(
-      this,
+      it->second,
       browser->browser_id_,
       "adb:" + browser->serial() + ":" + browser->socket(),
       kBrowserTargetSocket, DevToolsAgentHost::kTypeBrowser, nullptr);
 }
 
 void DevToolsAndroidBridge::SendJsonRequest(
     const std::string& browser_id_str,
     const std::string& url,
     const JsonRequestCallback& callback) {
-  BrowserId browser_id;
-  if (!BrowserIdFromString(browser_id_str, &browser_id)) {
+  std::string serial;
+  std::string browser_id;
+  if (!BrowserIdFromString(browser_id_str, &serial, &browser_id)) {
     callback.Run(net::ERR_FAILED, std::string());
     return;
   }
-  SendJsonRequest(browser_id, url, callback);
-}
-
-AndroidDeviceManager::AndroidWebSocket*
-DevToolsAndroidBridge::CreateWebSocket(
-    const BrowserId& browser_id,
-    const std::string& url,
-    AndroidDeviceManager::AndroidWebSocket::Delegate* delegate) {
-  DeviceMap::iterator it = device_map_.find(browser_id.first);
-  if (it == device_map_.end())
-    return nullptr;
-  return it->second->CreateWebSocket(browser_id.second, url, delegate);
+  DeviceMap::iterator it = device_map_.find(serial);
+  if (it == device_map_.end()) {
+    callback.Run(net::ERR_FAILED, std::string());
+    return;
+  }
+  it->second->SendJsonRequest(browser_id, url, callback);
 }
 
 void DevToolsAndroidBridge::OpenRemotePage(scoped_refptr<RemoteBrowser> browser,
                                            const std::string& input_url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   GURL gurl(input_url);
   if (!gurl.is_valid()) {
     gurl = GURL("http://" + input_url);
     if (!gurl.is_valid())
       return;
@@ skipping 109 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();
 }
 
-bool DevToolsAndroidBridge::HasDevToolsWindow(const std::string& agent_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  return host_delegates_.find(agent_id) != host_delegates_.end();
-}
-
 DevToolsAndroidBridge::~DevToolsAndroidBridge() {
   DCHECK_CURRENTLY_ON(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, AsWeakPtr()));
@@ skipping 175 matching lines @@
     StopDeviceListPolling();
     StartDeviceListPolling();
   }
 }
 
 void DevToolsAndroidBridge::set_tcp_provider_callback_for_test(
     TCPProviderCallback callback) {
   tcp_provider_callback_ = callback;
   CreateDeviceProviders();
 }