[WIP] Support opening an inspector window for ServiceWorker running on Android (chromium)

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 <set>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 271 matching lines @@
   }
 
   return new DevToolsAndroidBridge(
       profile, signin_manager, token_service);
 }
 
 // AgentHostDelegate ----------------------------------------------------------
 
 class DevToolsAndroidBridge::AgentHostDelegate
     : public content::DevToolsExternalAgentProxyDelegate,
-      public AndroidDeviceManager::AndroidWebSocket::Delegate {
+      public AndroidDeviceManager::AndroidWebSocket::Delegate,
+      public DevToolsAndroidBridge::DeviceListListener {
  public:
   static scoped_refptr<content::DevToolsAgentHost> GetOrCreateAgentHost(
       DevToolsAndroidBridge* bridge,
       const std::string& id,
       const BrowserId& browser_id,
       const std::string& debug_url);
 
  private:
   AgentHostDelegate(
       DevToolsAndroidBridge* bridge,
       const std::string& id,
       const BrowserId& browser_id,
       const std::string& debug_url);
   ~AgentHostDelegate() override;
   void Attach(content::DevToolsExternalAgentProxy* proxy) override;
   void Detach() override;
   void SendMessageToBackend(const std::string& message) override;
+  void OpenWorkerInspector(content::BrowserContext* context,
+                           const std::string& id) override;
   void OnSocketOpened() override;
   void OnFrameRead(const std::string& message) override;
   void OnSocketClosed() override;
 
+  // DevToolsAndroidBridge::Listener overrides.
+  void DeviceListChanged(
+      const DevToolsAndroidBridge::RemoteDevices& devices) override;
+
   std::string id_;
   base::WeakPtr<DevToolsAndroidBridge> bridge_;
   BrowserId browser_id_;
   std::string debug_url_;
   bool socket_opened_;
   std::vector<std::string> pending_messages_;
   scoped_refptr<AndroidDeviceManager::Device> device_;
   scoped_ptr<AndroidDeviceManager::AndroidWebSocket> web_socket_;
   content::DevToolsAgentHost* agent_host_;
   content::DevToolsExternalAgentProxy* proxy_;
+  content::BrowserContext* context_;
+  std::set<std::string> pending_workers_;
+  base::WeakPtrFactory<DevToolsAndroidBridge::AgentHostDelegate> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(AgentHostDelegate);
 };
 
 // static
 scoped_refptr<content::DevToolsAgentHost>
 DevToolsAndroidBridge::AgentHostDelegate::GetOrCreateAgentHost(
     DevToolsAndroidBridge* bridge,
     const std::string& id,
     const BrowserId& browser_id,
     const std::string& debug_url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   AgentHostDelegates::iterator it = bridge->host_delegates_.find(id);
-  if (it != bridge->host_delegates_.end())
+  if (it != bridge->host_delegates_.end()) {
+    it->second->debug_url_ = debug_url;
     return it->second->agent_host_;
+  }
 
   AgentHostDelegate* delegate =
       new AgentHostDelegate(bridge, id, browser_id, debug_url);
   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& debug_url)
     : id_(id),
       bridge_(bridge->AsWeakPtr()),
       browser_id_(browser_id),
       debug_url_(debug_url),
       socket_opened_(false),
       agent_host_(NULL),
-      proxy_(NULL) {
+      proxy_(NULL),
+      context_(NULL),
+      weak_factory_(this) {
   bridge_->host_delegates_[id] = this;
 }
 
 DevToolsAndroidBridge::AgentHostDelegate::~AgentHostDelegate() {
-  if (bridge_)
+  if (bridge_) {
+    if (pending_workers_.size()) {
+      bridge_->RemoveDeviceListListener(this);
+    }
     bridge_->host_delegates_.erase(id_);
+  }
 }
 
 void DevToolsAndroidBridge::AgentHostDelegate::Attach(
     content::DevToolsExternalAgentProxy* proxy) {
   proxy_ = proxy;
   content::RecordAction(browser_id_.second.find(kWebViewSocketPrefix) == 0 ?
       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, debug_url_, this));
 }
 
 void DevToolsAndroidBridge::AgentHostDelegate::Detach() {
   web_socket_.reset();
   device_ = nullptr;
 }
 
 void DevToolsAndroidBridge::AgentHostDelegate::SendMessageToBackend(
     const std::string& message) {
   if (socket_opened_)
     web_socket_->SendFrame(message);
   else
     pending_messages_.push_back(message);
 }
 
+void DevToolsAndroidBridge::AgentHostDelegate::OpenWorkerInspector(
+    content::BrowserContext* context,
+    const std::string& id) {
+  if (!bridge_)
+    return;
+  const std::string full_id =
+      base::StringPrintf("%s:%s:%s", browser_id_.first.c_str(),
+                         browser_id_.second.c_str(), id.c_str());
+  if (pending_workers_.size()) {
+    pending_workers_.insert(full_id);
+  } else {
+    pending_workers_.insert(full_id);
+    context_ = context;
+    bridge_->AddDeviceListListener(this);
+  }
+}
+
+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 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 = std::string();
+  return debug_url;
+}
+
+void DevToolsAndroidBridge::AgentHostDelegate::DeviceListChanged(
+    const DevToolsAndroidBridge::RemoteDevices& devices) {
+  if (!bridge_) {
+    pending_workers_.clear();
+    return;
+  }
+  for (const auto& device : devices) {
+    for (const auto& browser : device->browsers()) {
+      for (const auto& page : browser->pages()) {
+        scoped_ptr<DevToolsTargetImpl> target(bridge_->CreatePageTarget(page));
+        if (pending_workers_.count(target->GetId())) {
+          if (GetDebugURL(*page->dict_).length()) {
+            target->Inspect(Profile::FromBrowserContext(context_));
+          }
+        }
+      }
+    }
+  }
+  pending_workers_.clear();
+  if (bridge_)
+    bridge_->RemoveDeviceListListener(this);
+}
+
 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(
@@ skipping 28 matching lines @@
   base::WeakPtr<DevToolsAndroidBridge> bridge_;
   BrowserId browser_id_;
   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(
-    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 (frontend_url.find("http:") == 0)
     frontend_url = "https:" + frontend_url.substr(5);
   return frontend_url;
 }
 
-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 = std::string();
-  return debug_url;
-}
 
 DevToolsAndroidBridge::RemotePageTarget::RemotePageTarget(
     DevToolsAndroidBridge* bridge,
     const BrowserId& browser_id,
     const base::DictionaryValue& value)
     : DevToolsTargetImpl(AgentHostDelegate::GetOrCreateAgentHost(
                              bridge,
                              BuildUniqueTargetId(browser_id, value),
                              browser_id,
                              GetDebugURL(value))),
@@ skipping 432 matching lines @@
     device_providers.push_back(
         new WebRTCDeviceProvider(profile_, signin_manager_, token_service_));
   }
 
   device_manager_->SetDeviceProviders(device_providers);
   if (NeedsDeviceListPolling()) {
     StopDeviceListPolling();
     StartDeviceListPolling();
   }
 }