DevTools: merge devtools target with devtools host, part 1

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 37 matching lines @@
 #include "content/public/browser/user_metrics.h"
 #include "net/base/escape.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 
 #if defined(ENABLE_SERVICE_DISCOVERY)
 #include "chrome/browser/devtools/device/cast_device_provider.h"
 #endif
 
 using content::BrowserThread;
+using content::DevToolsAgentHost;
 
 namespace {
 
 const char kPageListRequest[] = "/json";
 const char kVersionRequest[] = "/json/version";
 const char kClosePageRequest[] = "/json/close/%s";
 const char kNewPageRequestWithURL[] = "/json/new?%s";
 const char kActivatePageRequest[] = "/json/activate/%s";
 const char kBrowserTargetSocket[] = "/devtools/browser";
 const int kAdbPollingIntervalMs = 1000;
 
 const char kPageReloadCommand[] = "Page.reload";
 
 const char kWebViewSocketPrefix[] = "webview_devtools_remote";
 
 bool BrowserIdFromString(const std::string& browser_id_str,
                          DevToolsAndroidBridge::BrowserId* 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);
   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);
@@ skipping 190 matching lines @@
 }
 
 // AgentHostDelegate ----------------------------------------------------------
 
 class DevToolsAndroidBridge::AgentHostDelegate
     : public content::DevToolsExternalAgentProxyDelegate,
       public AndroidDeviceManager::AndroidWebSocket::Delegate {
  public:
   static scoped_refptr<content::DevToolsAgentHost> GetOrCreateAgentHost(
       DevToolsAndroidBridge* bridge,
-      const std::string& id,
       const BrowserId& browser_id,
-      const std::string& target_path);
+      const std::string& local_id,
+      const std::string& target_path,
+      const std::string& type,
+      base::DictionaryValue* value);
 
  private:
   AgentHostDelegate(
       DevToolsAndroidBridge* bridge,
-      const std::string& id,
       const BrowserId& browser_id,
-      const std::string& target_path);
+      const std::string& local_id,
+      const std::string& target_path,
+      const std::string& type,
+      base::DictionaryValue* value);
   ~AgentHostDelegate() override;
+  // DevToolsExternalAgentProxyDelegate overrides.
   void Attach(content::DevToolsExternalAgentProxy* proxy) override;
   void Detach() override;
+  std::string GetId() 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;
+  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;
 
-  std::string id_;
   base::WeakPtr<DevToolsAndroidBridge> bridge_;
   BrowserId 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_;
   scoped_refptr<AndroidDeviceManager::Device> device_;
   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,
+    base::DictionaryValue* value) {
+  return base::StringPrintf("%s:%s:%s", browser_id.first.c_str(),
+      browser_id.second.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 std::string& id,
     const BrowserId& browser_id,
-    const std::string& target_path) {
+    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(id);
+  AgentHostDelegates::iterator it = bridge->host_delegates_.find(local_id);
   if (it != bridge->host_delegates_.end())
     return it->second->agent_host_;
 
-  AgentHostDelegate* delegate =
-      new AgentHostDelegate(bridge, id, browser_id, target_path);
+  AgentHostDelegate* delegate = new AgentHostDelegate(
+      bridge, browser_id, local_id, target_path, type, value);
   scoped_refptr<content::DevToolsAgentHost> result =
       content::DevToolsAgentHost::Create(delegate);
   delegate->agent_host_ = result.get();
   return result;
 }
 
 DevToolsAndroidBridge::AgentHostDelegate::AgentHostDelegate(
     DevToolsAndroidBridge* bridge,
-    const std::string& id,
     const BrowserId& browser_id,
-    const std::string& target_path)
-    : id_(id),
-      bridge_(bridge->AsWeakPtr()),
+    const std::string& local_id,
+    const std::string& target_path,
+    const std::string& type,
+    base::DictionaryValue* value)
+    : bridge_(bridge->AsWeakPtr()),
       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_(NULL),
       proxy_(NULL) {
-  bridge_->host_delegates_[id] = this;
+  bridge_->host_delegates_[local_id_] = this;
 }
 
 DevToolsAndroidBridge::AgentHostDelegate::~AgentHostDelegate() {
   if (bridge_)
-    bridge_->host_delegates_.erase(id_);
+    bridge_->host_delegates_.erase(local_id_);
 }
 
 void DevToolsAndroidBridge::AgentHostDelegate::Attach(
     content::DevToolsExternalAgentProxy* proxy) {
   proxy_ = proxy;
   content::RecordAction(
       base::StartsWith(browser_id_.second, kWebViewSocketPrefix,
                        base::CompareCase::SENSITIVE)
           ? base::UserMetricsAction("DevTools_InspectAndroidWebView")
           : base::UserMetricsAction("DevTools_InspectAndroidPage"));
 
   // Retain the device so it's not released until AgentHost is detached.
   if (bridge_)
     device_ = bridge_->FindDevice(browser_id_.first);
   if (!device_.get())
     return;
 
   web_socket_.reset(
       device_->CreateWebSocket(browser_id_.second, target_path_, this));
 }
 
 void DevToolsAndroidBridge::AgentHostDelegate::Detach() {
   web_socket_.reset();
   device_ = nullptr;
   proxy_ = nullptr;
 }
 
-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);
-  else
-    pending_messages_.push_back(message);
-}
-
-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 DevToolsAndroidBridge::AgentHostDelegate::OnFrameRead(
-    const std::string& message) {
-  if (proxy_)
-      proxy_->DispatchOnClientHost(message);
-}
-
-void DevToolsAndroidBridge::AgentHostDelegate::OnSocketClosed() {
-  if (proxy_) {
-    std::string message = "{ \"method\": \"Inspector.detached\", "
-        "\"params\": { \"reason\": \"Connection lost.\"} }";
-    proxy_->DispatchOnClientHost(message);
-    Detach();
-  }
-}
-
-//// RemotePageTarget ----------------------------------------------
-
-class DevToolsAndroidBridge::RemotePageTarget : public DevToolsTargetImpl {
- public:
-  RemotePageTarget(DevToolsAndroidBridge* bridge,
-                   const BrowserId& browser_id,
-                   const base::DictionaryValue& value);
-  ~RemotePageTarget() override;
-
-  // DevToolsTargetImpl overrides.
-  std::string GetId() const override;
-  bool IsAttached() const override;
-  bool Activate() const override;
-  bool Close() const override;
-  void Inspect(Profile* profile) const override;
-  void Reload() const override;
-
- private:
-  base::WeakPtr<DevToolsAndroidBridge> bridge_;
-  BrowserId browser_id_;
-  std::string target_path_;
-  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(
-    const DevToolsAndroidBridge::BrowserId& browser_id,
-    const base::DictionaryValue& value) {
-  return base::StringPrintf("%s:%s:%s", browser_id.first.c_str(),
-      browser_id.second.c_str(), GetStringProperty(value, "id").c_str());
-}
-
-static std::string GetFrontendURL(const 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(const 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;
-}
-
-DevToolsAndroidBridge::RemotePageTarget::RemotePageTarget(
-    DevToolsAndroidBridge* bridge,
-    const BrowserId& browser_id,
-    const base::DictionaryValue& value)
-    : DevToolsTargetImpl(AgentHostDelegate::GetOrCreateAgentHost(
-                             bridge,
-                             BuildUniqueTargetId(browser_id, value),
-                             browser_id,
-                             GetTargetPath(value))),
-      bridge_(bridge->AsWeakPtr()),
-      browser_id_(browser_id),
-      target_path_(GetTargetPath(value)),
-      frontend_url_(GetFrontendURL(value)),
-      remote_id_(GetStringProperty(value, "id")),
-      remote_type_(GetStringProperty(value, "type")),
-      local_id_(BuildUniqueTargetId(browser_id, 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")));
-  target_path_ = GetTargetPath(value);
-}
-
-DevToolsAndroidBridge::RemotePageTarget::~RemotePageTarget() {
-}
-
-std::string DevToolsAndroidBridge::RemotePageTarget::GetId() const {
+std::string DevToolsAndroidBridge::AgentHostDelegate::GetId() {
   return local_id_;
 }
 
-bool DevToolsAndroidBridge::RemotePageTarget::IsAttached() const {
-  return target_path_.empty();
+std::string DevToolsAndroidBridge::AgentHostDelegate::GetType() {
+  return remote_type_;
 }
 
-static void NoOp(int, const std::string&) {}
-
-void DevToolsAndroidBridge::RemotePageTarget::Inspect(Profile* profile) const {
-  Activate();
-  bool is_worker = remote_type_ == kTargetTypeWorker ||
-                   remote_type_ == kTargetTypeServiceWorker;
-  bool is_v8_only = remote_type_ == kTargetTypeNode;
-  DevToolsWindow::OpenExternalFrontend(profile, frontend_url_, GetAgentHost(),
-                                       is_worker, is_v8_only);
+std::string DevToolsAndroidBridge::AgentHostDelegate::GetTitle() {
+  return title_;
 }
 
-bool DevToolsAndroidBridge::RemotePageTarget::Activate() const {
+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));
   return true;
 }
 
-bool DevToolsAndroidBridge::RemotePageTarget::Close() const {
+bool DevToolsAndroidBridge::AgentHostDelegate::Inspect() {
+  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);
+  return true;
+}
+
+void DevToolsAndroidBridge::AgentHostDelegate::Reload() {
+  if (!bridge_)
+    return;
+
+  bridge_->SendProtocolCommand(browser_id_, 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));
   return true;
 }
 
-void DevToolsAndroidBridge::RemotePageTarget::Reload() const {
-  if (!bridge_)
+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);
+  else
+    pending_messages_.push_back(message);
+}
 
-  bridge_->SendProtocolCommand(browser_id_, target_path_, kPageReloadCommand,
-                               NULL, base::Closure());
+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 DevToolsAndroidBridge::AgentHostDelegate::OnFrameRead(
+    const std::string& message) {
+  if (proxy_)
+      proxy_->DispatchOnClientHost(message);
+}
+
+void DevToolsAndroidBridge::AgentHostDelegate::OnSocketClosed() {
+  if (proxy_) {
+    std::string message = "{ \"method\": \"Inspector.detached\", "
+        "\"params\": { \"reason\": \"Connection lost.\"} }";
+    proxy_->DispatchOnClientHost(message);
+    Detach();
+  }
 }
 
 // DevToolsAndroidBridge::RemotePage ------------------------------------------
 
 DevToolsAndroidBridge::RemotePage::RemotePage(const BrowserId& browser_id,
                                               const base::DictionaryValue& dict)
     : browser_id_(browser_id),
-      frontend_url_(GetFrontendURL(dict)),
       dict_(dict.DeepCopy()) {
 }
 
 DevToolsAndroidBridge::RemotePage::~RemotePage() {
 }
 
 // DevToolsAndroidBridge::RemoteBrowser ---------------------------------------
 
 DevToolsAndroidBridge::RemoteBrowser::RemoteBrowser(
     const std::string& serial,
@@ skipping 20 matching lines @@
            version_, ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
     int value = 0;
     base::StringToInt(part, &value);
     result.push_back(value);
   }
   return result;
 }
 
 DevToolsTargetImpl*
 DevToolsAndroidBridge::CreatePageTarget(scoped_refptr<RemotePage> page) {
-  return new RemotePageTarget(this, page->browser_id_, *page->dict_);
+  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");
+  scoped_refptr<DevToolsAgentHost> host =
+      AgentHostDelegate::GetOrCreateAgentHost(this, page->browser_id_, local_id,
+                                              target_path, type,
+                                              page->dict_.get());
+  return new DevToolsTargetImpl(host);
 }
 
 void DevToolsAndroidBridge::SendJsonRequest(
     const BrowserId& browser_id,
     const std::string& request,
     const JsonRequestCallback& callback) {
   scoped_refptr<AndroidDeviceManager::Device> device(
       FindDevice(browser_id.first));
   if (!device.get()) {
     callback.Run(net::ERR_FAILED, std::string());
@@ skipping 21 matching lines @@
       device, browser_id.second, target_path,
       DevToolsProtocol::SerializeCommand(1, method, std::move(params)),
       callback);
 }
 
 scoped_refptr<content::DevToolsAgentHost>
 DevToolsAndroidBridge::GetBrowserAgentHost(
     scoped_refptr<RemoteBrowser> browser) {
   return AgentHostDelegate::GetOrCreateAgentHost(
       this,
+      browser->browser_id_,
       "adb:" + browser->serial() + ":" + browser->socket(),
-      browser->browser_id_,
-      kBrowserTargetSocket);
+      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)) {
     callback.Run(net::ERR_FAILED, std::string());
     return;
@@ skipping 316 matching lines @@
     StopDeviceListPolling();
     StartDeviceListPolling();
   }
 }
 
 void DevToolsAndroidBridge::set_tcp_provider_callback_for_test(
     TCPProviderCallback callback) {
   tcp_provider_callback_ = callback;
   CreateDeviceProviders();
 }