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

chrome/browser/devtools/devtools_adb_bridge.cc

Index: chrome/browser/devtools/devtools_adb_bridge.cc
diff --git a/chrome/browser/devtools/devtools_adb_bridge.cc b/chrome/browser/devtools/devtools_adb_bridge.cc
index 3b9dd6a4d746fa3fc9ab50142459e966d33a42fe..5df404bd58525f6912a74acfdb41e82276cc6e07 100644
--- a/chrome/browser/devtools/devtools_adb_bridge.cc
+++ b/chrome/browser/devtools/devtools_adb_bridge.cc
@@ -24,6 +24,7 @@
 #include "chrome/browser/devtools/adb/android_rsa.h"
 #include "chrome/browser/devtools/adb_client_socket.h"
 #include "chrome/browser/devtools/adb_web_socket.h"
+#include "chrome/browser/devtools/devtools_protocol.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/devtools/tethering_adb_filter.h"
 #include "chrome/browser/profiles/profile.h"
@@ -38,6 +39,7 @@
 #include "net/base/net_errors.h"
 
 using content::BrowserThread;
+using chrome::DevToolsProtocol;
 
 namespace {
 
@@ -51,6 +53,8 @@ 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;
@@ -382,6 +386,57 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
   scoped_ptr<DevToolsAdbBridge::RemoteDevices> remote_devices_;
 };
 
+// AdbProtocolCommand ---------------------------------------------------------
+
+class AdbProtocolCommand : public AdbWebSocket::Delegate {
+ public:
+  AdbProtocolCommand(
+      scoped_refptr<DevToolsAdbBridge> bridge_,
+      scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
+      const std::string& socket_name,
+      const std::string& debug_url,
+      const std::string& command);
+
+ private:
+  virtual void OnSocketOpened() OVERRIDE;
+  virtual void OnFrameRead(const std::string& message) OVERRIDE;
+  virtual void OnSocketClosed(bool closed_by_device) OVERRIDE;
+  virtual bool ProcessIncomingMessage(const std::string& message) OVERRIDE;
+
+  scoped_refptr<DevToolsAdbBridge> bridge_;
+  const std::string command_;
+  scoped_refptr<AdbWebSocket> web_socket_;
+
+  DISALLOW_COPY_AND_ASSIGN(AdbProtocolCommand);
+};
+
+AdbProtocolCommand::AdbProtocolCommand(
+    scoped_refptr<DevToolsAdbBridge> bridge,
+    scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
+    const std::string& socket_name,
+    const std::string& debug_url,
+    const std::string& command)
+    : bridge_(bridge),
+      command_(command) {
+  web_socket_ = new AdbWebSocket(
+      device, socket_name, debug_url, bridge_->GetAdbMessageLoop(), this);
+}
+
+void AdbProtocolCommand::OnSocketOpened() {
+  web_socket_->SendFrame(command_);
+  web_socket_->Disconnect();
+}
+
+void AdbProtocolCommand::OnFrameRead(const std::string& message) {}
+
+void AdbProtocolCommand::OnSocketClosed(bool closed_by_device) {
+  delete this;
+}
+
+bool AdbProtocolCommand::ProcessIncomingMessage(const std::string& message) {
+  return false;
+}
+
 }  // namespace
 
 const char kDevToolsChannelNameFormat[] = "%s_devtools_remote";
@@ -443,7 +498,7 @@ void DevToolsAdbBridge::AndroidDevice::HttpQuery(
                                  request, callback));
 }
 
-void DevToolsAdbBridge::AndroidDevice::HttpQuery(
+void DevToolsAdbBridge::AndroidDevice::HttpConnect(
     const std::string& la_name,
     const std::string& request,
     const SocketCallback& callback) {
@@ -583,7 +638,7 @@ DevToolsAdbBridge::RemotePage::RemotePage(
     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) {
@@ -598,6 +653,32 @@ void DevToolsAdbBridge::RemotePage::Inspect(Profile* profile) {
         frontend_url_, bridge_->GetAdbMessageLoop(), profile);
 }
 
+static void Noop(int, const std::string&) {}
+
+void DevToolsAdbBridge::RemotePage::Close() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (attached())
+    return;
+  std::string request = base::StringPrintf(kClosePageRequest, id_.c_str());
+  bridge_->GetAdbMessageLoop()->PostTask(FROM_HERE,
+      base::Bind(&AndroidDevice::HttpQuery,
+          device_, socket_, request, base::Bind(&Noop)));
+}
+
+void DevToolsAdbBridge::RemotePage::Reload() {
+  SendProtocolCommand("Page.reload", NULL);

[pfeldman, 2013/08/07 09:48:12]

kPageReloadCommand

[Vladislav Kaznacheev, 2013/08/07 12:11:05]

Done. Also kPageNavigateCommand

+}
+
+void DevToolsAdbBridge::RemotePage::SendProtocolCommand(
+    const std::string& method,
+    base::DictionaryValue* params) {
+  if (attached())
+    return;
+  DevToolsProtocol::Command command(1, method, params);
+  new AdbProtocolCommand(
+      bridge_, device_, socket_, debug_url_, command.Serialize());
+}
+
 DevToolsAdbBridge::RemotePage::~RemotePage() {
 }
 
@@ -610,6 +691,37 @@ DevToolsAdbBridge::RemoteBrowser::RemoteBrowser(
       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) {
+  bridge_->GetAdbMessageLoop()->PostTask(FROM_HERE,
+      base::Bind(&AndroidDevice::HttpQuery,
+          device_, socket_, kNewPageRequest,
+          base::Bind(&RemoteBrowser::PageCreatedOnHandlerThread, this, url)));
+}
+
+void DevToolsAdbBridge::RemoteBrowser::PageCreatedOnHandlerThread(
+    const std::string& url, int result, const std::string& response) {
+  if (result < 0)
+    return;
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&RemoteBrowser::PageCreatedOnUIThread, this, response, 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);

[pfeldman, 2013/08/07 09:48:12]

kUrl

[Vladislav Kaznacheev, 2013/08/07 12:11:05]

Done.

+    new_page->SendProtocolCommand("Page.navigate", &params);
+  }
 }
 
 DevToolsAdbBridge::RemoteBrowser::~RemoteBrowser() {
@@ -620,6 +732,7 @@ DevToolsAdbBridge::RemoteDevice::RemoteDevice(
     scoped_refptr<AndroidDevice> device)
     : bridge_(bridge),
       device_(device) {
+  global_id_ = base::StringPrintf("device:%s", device_->serial().c_str());
 }
 
 DevToolsAdbBridge::RemoteDevice::~RemoteDevice() {