chrome://inspect: Add "open", "close" and "reload" actions to Devices tab

chrome/browser/devtools/devtools_adb_bridge.cc

 // Copyright (c) 2013 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/devtools_adb_bridge.h"
 
 #include <map>
 #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/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "chrome/browser/devtools/adb/android_rsa.h"
@@ skipping 19 matching lines @@
 static const char kDevToolsAdbBridgeThreadName[] = "Chrome_DevToolsADBThread";
 static const char kHostDevicesCommand[] = "host:devices";
 static const char kHostTransportCommand[] = "host:transport:%s|%s";
 static const char kLocalAbstractCommand[] = "localabstract:%s";
 static const char kDeviceModelCommand[] = "shell:getprop ro.product.model";
 static const char kUnknownModel[] = "Unknown";
 static const char kOpenedUnixSocketsCommand[] = "shell:cat /proc/net/unix";
 
 static const char kPageListRequest[] = "GET /json HTTP/1.1\r\n\r\n";
 static const char kVersionRequest[] = "GET /json/version HTTP/1.1\r\n\r\n";
+static const char kClosePageRequest[] = "GET /json/close/%s HTTP/1.1\r\n\r\n";
+static const char kNewPageRequest[] = "GET /json/new HTTP/1.1\r\n\r\n";
 const int kAdbPort = 5037;
 const int kBufferSize = 16 * 1024;
 const int kAdbPollingIntervalMs = 1000;
 
 typedef DevToolsAdbBridge::Callback Callback;
 typedef std::vector<scoped_refptr<DevToolsAdbBridge::AndroidDevice> >
     AndroidDevices;
 typedef base::Callback<void(const AndroidDevices&)> AndroidDevicesCallback;
 
 class AdbDeviceImpl : public DevToolsAdbBridge::AndroidDevice {
@@ skipping 313 matching lines @@
   }
 
   scoped_refptr<DevToolsAdbBridge> bridge_;
   Callback callback_;
   AndroidDevices devices_;
   std::vector<std::string> sockets_;
   std::map<std::string, std::string> socket_to_package_;
   scoped_ptr<DevToolsAdbBridge::RemoteDevices> remote_devices_;
 };
 
+class AdbRemotePageCommand : public base::RefCountedThreadSafe<

[pfeldman, 2013/08/06 13:33:34]

Wat?

[Vladislav Kaznacheev, 2013/08/07 09:35:12]

Replaced with a bind
On 2013/08/06 13:33:34, pfeldman wrote:

+    AdbRemotePageCommand,
+    content::BrowserThread::DeleteOnUIThread> {
+ public:
+  AdbRemotePageCommand(scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
+                      const std::string& socket,
+                      const std::string& command,
+                      const CommandCallback& callback)
+     : device_(device),
+       socket_(socket),
+       command_(command),
+       callback_(callback) {
+  }
+
+  void Run() {
+    device_->HttpQuery(socket_, command_, callback_);
+  }
+
+ private:
+  friend struct content::BrowserThread::DeleteOnThread<
+      content::BrowserThread::UI>;
+  friend class base::DeleteHelper<AdbRemotePageCommand>;
+
+  virtual ~AdbRemotePageCommand() {}
+
+  scoped_refptr<DevToolsAdbBridge::AndroidDevice> device_;
+  const std::string socket_;
+  const std::string command_;
+  CommandCallback callback_;
+};
+
+class DebuggerCommand : public AdbWebSocket::Delegate {

[pfeldman, 2013/08/06 13:33:34]

Lets split this into declaration and definition with nice comment separators
between classes.

[Vladislav Kaznacheev, 2013/08/07 09:35:12]

Done.

+ public:
+  DebuggerCommand(
+      scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
+      const std::string& socket_name,
+      const std::string& debug_url,
+      base::MessageLoop* adb_message_loop,
+      const std::string& command)
+      : command_(command) {
+    web_socket_ = new AdbWebSocket(
+        device, socket_name, debug_url, adb_message_loop, this);
+  }
+
+ private:
+  virtual ~DebuggerCommand() {}
+
+  virtual void OnSocketOpened() OVERRIDE {
+    web_socket_->SendFrame(command_);
+    web_socket_->Disconnect();
+  }
+
+  virtual void OnFrameRead(const std::string& message) OVERRIDE {}
+
+  virtual void OnSocketClosed(bool closed_by_device) OVERRIDE {
+    delete this;

[pfeldman, 2013/08/06 13:33:34]

This object leaks when message loop closes.

[Vladislav Kaznacheev, 2013/08/07 09:35:12]

Retaining DevToolsAdbBridge instance now to make sure the message loop lives
long enough.

On 2013/08/06 13:33:34, pfeldman wrote:

+  }
+
+  virtual bool ProcessIncomingMessage(const std::string& message) OVERRIDE {
+    return false;
+  }
+
+  const std::string command_;
+  scoped_refptr<AdbWebSocket> web_socket_;
+
+  DISALLOW_COPY_AND_ASSIGN(DebuggerCommand);
+};
+
 }  // namespace
 
 const char kDevToolsChannelNameFormat[] = "%s_devtools_remote";
 
 class AgentHostDelegate;
 
 typedef std::map<std::string, AgentHostDelegate*> AgentHostDelegates;
 
 base::LazyInstance<AgentHostDelegates>::Leaky g_host_delegates =
     LAZY_INSTANCE_INITIALIZER;
@@ skipping 104 matching lines @@
     g_host_delegates.Get()[id] = this;
   }
 
   void OpenFrontend() {
     if (!proxy_)
       return;
     DevToolsWindow::OpenExternalFrontend(
         profile_, frontend_url_, proxy_->GetAgentHost().get());
   }
 
+  void SendCommand(const std::string& command) {
+    SendMessageToBackend(command);
+  }
+
  private:
   virtual ~AgentHostDelegate() {
     g_host_delegates.Get().erase(id_);
   }
 
   virtual void Attach() OVERRIDE {}
 
   virtual void Detach() OVERRIDE {
     web_socket_->Disconnect();
   }
@@ skipping 57 matching lines @@
   else
     debug_url_ = "";
 
   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);
 
   global_id_ = base::StringPrintf(
-      "%s:%s:%s", device->serial().c_str(), socket_.c_str(), id_.c_str());
+      "page:%s:%s:%s", device->serial().c_str(), socket_.c_str(), id_.c_str());
 }
 
 void DevToolsAdbBridge::RemotePage::Inspect(Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   AgentHostDelegates::iterator it =
       g_host_delegates.Get().find(global_id());
   if (it != g_host_delegates.Get().end())
     it->second->OpenFrontend();
   else if (!debug_url_.empty())
     new AgentHostDelegate(
         global_id_, device_, socket_, debug_url_,
         frontend_url_, bridge_->GetAdbMessageLoop(), profile);
 }
 
+static void Noop(int, const std::string&) {}
+
+void DevToolsAdbBridge::RemotePage::Close() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  std::string request = base::StringPrintf(kClosePageRequest, id_.c_str());
+  scoped_refptr<AdbRemotePageCommand> close =
+      new AdbRemotePageCommand(device_, socket_, request, base::Bind(&Noop));
+  bridge_->GetAdbMessageLoop()->PostTask(FROM_HERE,
+      base::Bind(&AdbRemotePageCommand::Run, close));
+}
+
+void DevToolsAdbBridge::RemotePage::Reload() {
+  SendDebuggerCommand("Page.reload", NULL);
+}
+
+static const char kIdAttribute[] = "id";
+static const char kMethodAttribute[] = "method";
+static const char kParamsAttribute[] = "params";
+
+void DevToolsAdbBridge::RemotePage::SendDebuggerCommand(
+    const std::string& method,
+    const base::DictionaryValue* params) {
+  base::DictionaryValue command;
+  command.SetInteger(kIdAttribute, -1);
+  command.SetString(kMethodAttribute, method);
+  if (params)
+    command.Set(kParamsAttribute, params->DeepCopy());
+  std::string json_command;
+  base::JSONWriter::Write(&command, &json_command);
+
+  AgentHostDelegates::iterator it =
+      g_host_delegates.Get().find(global_id());
+  if (it != g_host_delegates.Get().end())

[pfeldman, 2013/08/06 13:33:34]

Please don't

[Vladislav Kaznacheev, 2013/08/07 09:35:12]

Doing no longer.

+    it->second->SendCommand(json_command);
+  else if (!debug_url_.empty())
+    new DebuggerCommand(device_, socket_, debug_url_,
+        bridge_->GetAdbMessageLoop(), json_command);
+}
+
 DevToolsAdbBridge::RemotePage::~RemotePage() {
 }
 
 DevToolsAdbBridge::RemoteBrowser::RemoteBrowser(
     scoped_refptr<DevToolsAdbBridge> bridge,
     scoped_refptr<AndroidDevice> device,
     const std::string& socket,
     const std::string& name)
     : bridge_(bridge),
       device_(device),
       socket_(socket),
       name_(name) {
+  global_id_ = base::StringPrintf(
+      "browser:%s:%s", device_->serial().c_str(), socket_.c_str());
+}
+
+void DevToolsAdbBridge::RemoteBrowser::Open(const std::string& url) {
+  scoped_refptr<AdbRemotePageCommand> command =
+      new AdbRemotePageCommand(

[pfeldman, 2013/08/06 13:33:34]

JsonCommand
ProtocolCommand

[Vladislav Kaznacheev, 2013/08/07 09:35:12]

Done.

+          device_, socket_, kNewPageRequest,
+          base::Bind(&RemoteBrowser::PageCreatedOnHandlerThread, this, url));
+  bridge_->GetAdbMessageLoop()->PostTask(FROM_HERE,
+      base::Bind(&AdbRemotePageCommand::Run, command));
+}
+
+void DevToolsAdbBridge::RemoteBrowser::PageCreatedOnHandlerThread(
+    const std::string& url, int result, const std::string& response) {
+  if (result < 0)
+    return;
+  std::string body = response.substr(result);

[pfeldman, 2013/08/06 13:33:34]

This is insane! Lets factor it out first plz. I know I am the one to blame.

[Vladislav Kaznacheev, 2013/08/07 09:35:12]

see https://chromiumcodereview.appspot.com/22429005/

On 2013/08/06 13:33:34, pfeldman wrote:

+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&RemoteBrowser::PageCreatedOnUIThread, this, body, url));
+}
+
+void DevToolsAdbBridge::RemoteBrowser::PageCreatedOnUIThread(
+    const std::string& response, const std::string& url) {
+  scoped_ptr<base::Value> value(base::JSONReader::Read(response));
+  base::DictionaryValue* dict;
+  if (value && value->GetAsDictionary(&dict)) {
+    scoped_refptr<RemotePage> new_page =
+        new RemotePage(bridge_, device_, socket_, *dict);
+    base::DictionaryValue params;
+    params.SetString("url", url);
+    new_page->SendDebuggerCommand("Page.navigate", &params);
+  }
 }
 
 DevToolsAdbBridge::RemoteBrowser::~RemoteBrowser() {
 }
 
 DevToolsAdbBridge::RemoteDevice::RemoteDevice(
     scoped_refptr<DevToolsAdbBridge> bridge,
     scoped_refptr<AndroidDevice> device)
     : bridge_(bridge),
       device_(device) {
+  global_id_ = base::StringPrintf("device:%s", device_->serial().c_str());
 }
 
 DevToolsAdbBridge::RemoteDevice::~RemoteDevice() {
 }
 
 
 DevToolsAdbBridge::RefCountedAdbThread*
 DevToolsAdbBridge::RefCountedAdbThread::instance_ = NULL;
 
 // static
@@ skipping 148 matching lines @@
 
   if (listeners_.empty())
     return;
 
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&DevToolsAdbBridge::RequestRemoteDevices, this),
       base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
 }