Fix Telemetry.

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/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/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #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_target_impl.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/browser_context_keyed_service/browser_context_dependency_manager.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_external_agent_proxy.h"
 #include "content/public/browser/devtools_external_agent_proxy_delegate.h"
 #include "content/public/browser/devtools_manager.h"
 #include "crypto/rsa_private_key.h"
-#include "net/base/escape.h"
 #include "net/base/net_errors.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const char kDeviceModelCommand[] = "shell:getprop ro.product.model";
 const char kOpenedUnixSocketsCommand[] = "shell:cat /proc/net/unix";
 const char kListProcessesCommand[] = "shell:ps";
 const char kDumpsysCommand[] = "shell:dumpsys window policy";
 const char kDumpsysScreenSizePrefix[] = "mStable=";
 
 const char kUnknownModel[] = "Offline";
 
 const char kPageListRequest[] = "GET /json HTTP/1.1\r\n\r\n";
 const char kVersionRequest[] = "GET /json/version HTTP/1.1\r\n\r\n";
 const char kClosePageRequest[] = "GET /json/close/%s HTTP/1.1\r\n\r\n";
 const char kNewPageRequest[] = "GET /json/new HTTP/1.1\r\n\r\n";
-const char kNewPageRequestWithURL[] = "GET /json/new?%s HTTP/1.1\r\n\r\n";
 const char kActivatePageRequest[] =
     "GET /json/activate/%s HTTP/1.1\r\n\r\n";
 const int kAdbPollingIntervalMs = 1000;
 
 const char kUrlParam[] = "url";
 const char kPageReloadCommand[] = "Page.reload";
 const char kPageNavigateCommand[] = "Page.navigate";
 
-const char kChromeProductName[] = "Chrome";
-const int kMinVersionNewWithURL = 32;
-const int kNewPageNavigateDelayMs = 500;
-
 #if defined(DEBUG_DEVTOOLS)
+const char kChrome[] = "Chrome";
 const char kLocalChrome[] = "Local Chrome";
 #endif  // defined(DEBUG_DEVTOOLS)
 
 typedef DevToolsAdbBridge::Callback Callback;
 typedef std::vector<scoped_refptr<AndroidDevice> >
     AndroidDevices;
 typedef base::Callback<void(const AndroidDevices&)> AndroidDevicesCallback;
 
 // AdbPagesCommand ------------------------------------------------------------
 
@@ skipping 98 matching lines @@
   // For desktop remote debugging.
   if (devices_.back()->serial().empty()) {
     scoped_refptr<AndroidDevice> device =
         devices_.back();
     device->set_model(kLocalChrome);
     remote_devices_->push_back(
         new DevToolsAdbBridge::RemoteDevice(device));
     scoped_refptr<DevToolsAdbBridge::RemoteBrowser> remote_browser =
         new DevToolsAdbBridge::RemoteBrowser(
             adb_thread_, device, std::string());
-    remote_browser->set_product(kChromeProductName);
+    remote_browser->set_product(kChrome);
     remote_devices_->back()->AddBrowser(remote_browser);
     browsers_.push_back(remote_browser);
     device->HttpQuery(
         std::string(), kVersionRequest,
         base::Bind(&AdbPagesCommand::ReceivedVersion, this));
     return;
   }
 #endif  // defined(DEBUG_DEVTOOLS)
 
   scoped_refptr<AndroidDevice> device = devices_.back();
@@ skipping 111 matching lines @@
   DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
   scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser = browsers_.back();
   browsers_.pop_back();
   if (result < 0) {
     ProcessSockets();
     return;
   }
 
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::ListValue* list_value;
-  if (value && value->GetAsList(&list_value)) {
-    browser->SetPageDescriptors(*list_value);
+  if (!value || !value->GetAsList(&list_value)) {
+    ProcessSockets();
+    return;
+  }
+
+  base::Value* item;
+
+  for (size_t i = 0; i < list_value->GetSize(); ++i) {
+    list_value->Get(i, &item);
+    base::DictionaryValue* dict;
+    if (!item || !item->GetAsDictionary(&dict))
+      continue;
+    browser->AddPage(new DevToolsAdbBridge::RemotePage(
+        adb_thread_, browser->device(), browser->socket(), *dict));
   }
   ProcessSockets();
 }
 
 void AdbPagesCommand::Respond() {
   callback_.Run(remote_devices_.release());
 }
 
 void AdbPagesCommand::ParseSocketsList(const std::string& response) {
   // On Android, '/proc/net/unix' looks like this:
@@ skipping 203 matching lines @@
     content::BrowserContext* context) const {
   return new DevToolsAdbBridge::Wrapper();
 }
 
 
 // AgentHostDelegate ----------------------------------------------------------
 
 class AgentHostDelegate : public content::DevToolsExternalAgentProxyDelegate,
                           public AdbWebSocket::Delegate {
  public:
-   static void Create(const std::string& id,
-                      scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser,
-                      const std::string& debug_url,
-                      const std::string& frontend_url,
-                      Profile* profile) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    AgentHostDelegates::iterator it =
-        g_host_delegates.Get().find(id);
-    if (it != g_host_delegates.Get().end()) {
-      it->second->OpenFrontend();
-    } else if (!frontend_url.empty()) {
-      new AgentHostDelegate(
-          id, browser->device(), browser->socket(), debug_url,
-          frontend_url, browser->adb_thread()->message_loop(), profile);
-    }
-  }
-
- private:
   AgentHostDelegate(
       const std::string& id,
       scoped_refptr<AndroidDevice> device,
       const std::string& socket_name,
       const std::string& debug_url,
       const std::string& frontend_url,
       base::MessageLoop* adb_message_loop,
       Profile* profile)
       : id_(id),
+        serial_(device->serial()),
         frontend_url_(frontend_url),
         adb_message_loop_(adb_message_loop),
         profile_(profile) {
     web_socket_ = new AdbWebSocket(
         device, socket_name, debug_url, adb_message_loop, this);
     g_host_delegates.Get()[id] = this;
   }
 
   void OpenFrontend() {
     if (!proxy_)
       return;
     DevToolsWindow::OpenExternalFrontend(
         profile_, frontend_url_, proxy_->GetAgentHost().get());
   }
 
+ private:
   virtual ~AgentHostDelegate() {
     g_host_delegates.Get().erase(id_);
   }
 
   virtual void Attach() OVERRIDE {}
 
   virtual void Detach() OVERRIDE {
     web_socket_->Disconnect();
   }
 
@@ skipping 14 matching lines @@
     if (proxy_ && closed_by_device)
       proxy_->ConnectionClosed();
     delete this;
   }
 
   virtual bool ProcessIncomingMessage(const std::string& message) OVERRIDE {
     return false;
   }
 
   const std::string id_;
+  const std::string serial_;
   const std::string frontend_url_;
   base::MessageLoop* adb_message_loop_;
   Profile* profile_;
 
   scoped_ptr<content::DevToolsExternalAgentProxy> proxy_;
   scoped_refptr<AdbWebSocket> web_socket_;
   DISALLOW_COPY_AND_ASSIGN(AgentHostDelegate);
 };
 
-//// RemotePageTarget ----------------------------------------------
 
-class RemotePageTarget : public DevToolsTargetImpl {
- public:
-  RemotePageTarget(scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser,
-                   const base::DictionaryValue& value);
-  virtual ~RemotePageTarget();
+// DevToolsAdbBridge::RemotePage ----------------------------------------------
 
-  // content::DevToolsTarget overrides:
-  virtual bool IsAttached() const OVERRIDE;
-  virtual bool Activate() const OVERRIDE;
-  virtual bool Close() const OVERRIDE;
-
-  // DevToolsTargetImpl overrides:
-  virtual void Inspect(Profile* profile) const OVERRIDE;
-  virtual void Reload() const OVERRIDE;
-
-  void Navigate(const std::string& url) const;
-
- private:
-  scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser_;
-  std::string debug_url_;
-  std::string frontend_url_;
-  std::string agent_id_;
-  DISALLOW_COPY_AND_ASSIGN(RemotePageTarget);
-};
-
-RemotePageTarget::RemotePageTarget(
-    scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser,
+DevToolsAdbBridge::RemotePage::RemotePage(
+    scoped_refptr<RefCountedAdbThread> adb_thread,
+    scoped_refptr<AndroidDevice> device,
+    const std::string& socket,
     const base::DictionaryValue& value)
-    : browser_(browser) {
-  type_ = "adb_page";
+    : adb_thread_(adb_thread),
+      device_(device),
+      socket_(socket) {
   value.GetString("id", &id_);
-  std::string url;
-  value.GetString("url", &url);
-  url_ = GURL(url);
+  value.GetString("url", &url_);
   value.GetString("title", &title_);
-  title_ = UTF16ToUTF8(net::UnescapeForHTML(UTF8ToUTF16(title_)));
   value.GetString("description", &description_);
-  std::string favicon_url;
-  value.GetString("faviconUrl", &favicon_url);
-  favicon_url_ = GURL(favicon_url);
+  value.GetString("faviconUrl", &favicon_url_);
   value.GetString("webSocketDebuggerUrl", &debug_url_);
   value.GetString("devtoolsFrontendUrl", &frontend_url_);
 
   if (id_.empty() && !debug_url_.empty())  {
     // Target id is not available until Chrome 26. Use page id at the end of
     // debug_url_ instead. For attached targets the id will remain empty.
     std::vector<std::string> parts;
     Tokenize(debug_url_, "/", &parts);
     id_ = parts[parts.size()-1];
   }
 
   if (debug_url_.find("ws://") == 0)
     debug_url_ = debug_url_.substr(5);
   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);
 
   agent_id_ = base::StringPrintf("%s:%s:%s",
-      browser_->device()->serial().c_str(),
-      browser_->socket().c_str(),
-      id_.c_str());
+      device_->serial().c_str(), socket_.c_str(), id_.c_str());
 }
 
-RemotePageTarget::~RemotePageTarget() {
+bool DevToolsAdbBridge::RemotePage::HasDevToolsWindow() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return g_host_delegates.Get().find(agent_id_) != g_host_delegates.Get().end();
 }
 
-bool RemotePageTarget::IsAttached() const {
-  return debug_url_.empty();
+void DevToolsAdbBridge::RemotePage::Inspect(Profile* profile) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  RequestActivate(
+      base::Bind(&RemotePage::InspectOnHandlerThread, this, profile));
 }
 
-void RemotePageTarget::Inspect(Profile* profile) const {
-  std::string request = base::StringPrintf(kActivatePageRequest, id_.c_str());
-  base::Closure inspect_callback = base::Bind(&AgentHostDelegate::Create,
-      id_, browser_, debug_url_, frontend_url_, profile);
-  browser_->SendJsonRequest(request, inspect_callback);
+static void Noop(int, const std::string&) {}
+
+void DevToolsAdbBridge::RemotePage::Activate() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  RequestActivate(base::Bind(&Noop));
 }
 
-bool RemotePageTarget::Activate() const {
-  std::string request = base::StringPrintf(kActivatePageRequest, id_.c_str());
-  browser_->SendJsonRequest(request, base::Closure());
-  return true;
+void DevToolsAdbBridge::RemotePage::Close() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (attached())
+    return;
+  std::string request = base::StringPrintf(kClosePageRequest, id_.c_str());
+  adb_thread_->message_loop()->PostTask(FROM_HERE,
+      base::Bind(&AndroidDevice::HttpQuery,
+          device_, socket_, request, base::Bind(&Noop)));
 }
 
-bool RemotePageTarget::Close() const {
-  if (IsAttached())
-    return false;
-  std::string request = base::StringPrintf(kClosePageRequest, id_.c_str());
-  browser_->SendJsonRequest(request, base::Closure());
-  return true;
+void DevToolsAdbBridge::RemotePage::Reload() {
+  SendProtocolCommand(kPageReloadCommand, NULL);
 }
 
-void RemotePageTarget::Reload() const {
-  browser_->SendProtocolCommand(debug_url_, kPageReloadCommand, NULL);
+void DevToolsAdbBridge::RemotePage::SendProtocolCommand(
+    const std::string& method,
+    base::DictionaryValue* params) {
+  if (attached())
+    return;
+  DevToolsProtocol::Command command(1, method, params);
+  new AdbProtocolCommand(
+      adb_thread_, device_, socket_, debug_url_, command.Serialize());
 }
 
-void RemotePageTarget::Navigate(const std::string& url) const {
-  base::DictionaryValue params;
-  params.SetString(kUrlParam, url);
-  browser_->SendProtocolCommand(debug_url_, kPageNavigateCommand, &params);
+DevToolsAdbBridge::RemotePage::~RemotePage() {
 }
 
+void DevToolsAdbBridge::RemotePage::RequestActivate(
+    const AndroidDevice::CommandCallback& callback) {
+  std::string request = base::StringPrintf(kActivatePageRequest, id_.c_str());
+  adb_thread_->message_loop()->PostTask(FROM_HERE,
+      base::Bind(&AndroidDevice::HttpQuery,
+          device_, socket_, request, callback));
+}
+
+void DevToolsAdbBridge::RemotePage::InspectOnHandlerThread(
+    Profile* profile, int result, const std::string& response) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&RemotePage::InspectOnUIThread, this, profile));
+}
+
+void DevToolsAdbBridge::RemotePage::InspectOnUIThread(Profile* profile) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  AgentHostDelegates::iterator it =
+      g_host_delegates.Get().find(agent_id_);
+  if (it != g_host_delegates.Get().end()) {
+    it->second->OpenFrontend();
+  } else if (!attached()) {
+    new AgentHostDelegate(
+        agent_id_, device_, socket_, debug_url_,
+        frontend_url_, adb_thread_->message_loop(), profile);
+  }
+}
+
+
 // DevToolsAdbBridge::RemoteBrowser -------------------------------------------
 
 DevToolsAdbBridge::RemoteBrowser::RemoteBrowser(
     scoped_refptr<RefCountedAdbThread> adb_thread,
     scoped_refptr<AndroidDevice> device,
     const std::string& socket)
     : adb_thread_(adb_thread),
       device_(device),
       socket_(socket) {
 }
 
-bool DevToolsAdbBridge::RemoteBrowser::IsChrome() const {
-  return product_.find(kChromeProductName) == 0;
-}
-
-DevToolsAdbBridge::RemoteBrowser::ParsedVersion
-DevToolsAdbBridge::RemoteBrowser::GetParsedVersion() const {
-  ParsedVersion result;
-  std::vector<std::string> parts;
-  Tokenize(version_, ".", &parts);
-  for (size_t i = 0; i != parts.size(); ++i) {
-    int value = 0;
-    base::StringToInt(parts[i], &value);
-    result.push_back(value);
-  }
-  return result;
-}
-
-std::vector<DevToolsTargetImpl*>
-DevToolsAdbBridge::RemoteBrowser::CreatePageTargets() {
-  std::vector<DevToolsTargetImpl*> result;
-  for (size_t i = 0; i < page_descriptors_->GetSize(); ++i) {
-    base::Value* item;
-    page_descriptors_->Get(i, &item);
-    if (!item)
-      continue;
-    base::DictionaryValue* dict;
-    if (!item->GetAsDictionary(&dict))
-      continue;
-    result.push_back(new RemotePageTarget(this, *dict));
-  }
-  return result;
-}
-
-void DevToolsAdbBridge::RemoteBrowser::SetPageDescriptors(
-    const base::ListValue& list) {
-  page_descriptors_.reset(list.DeepCopy());
-}
-
-static void RespondOnUIThread(base::Closure callback, int, const std::string&) {
-  if (!callback.is_null())
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
-}
-
-void DevToolsAdbBridge::RemoteBrowser::SendJsonRequest(
-    const std::string& request, base::Closure callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+void DevToolsAdbBridge::RemoteBrowser::Open(const std::string& url) {
   adb_thread_->message_loop()->PostTask(FROM_HERE,
-      base::Bind(&AndroidDevice::HttpQuery, device_, socket_, request,
-          base::Bind(&RespondOnUIThread, callback)));
-}
-
-void DevToolsAdbBridge::RemoteBrowser::SendProtocolCommand(
-    const std::string& debug_url,
-    const std::string& method,
-    base::DictionaryValue* params) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (debug_url.empty())
-    return;
-  DevToolsProtocol::Command command(1, method, params);
-  new AdbProtocolCommand(
-      adb_thread_, device_, socket_, debug_url, command.Serialize());
-}
-
-static void NoOp(int, const std::string&) {}
-
-void DevToolsAdbBridge::RemoteBrowser::Open(const std::string& url) {
-  ParsedVersion parsed_version = GetParsedVersion();
-  if (IsChrome() &&
-      !parsed_version.empty() &&
-      parsed_version[0] >= kMinVersionNewWithURL) {
-    std::string query = net::EscapeQueryParamValue(url, false /* use_plus */);
-    std::string request =
-        base::StringPrintf(kNewPageRequestWithURL, query.c_str());
-    adb_thread_->message_loop()->PostTask(FROM_HERE,
-        base::Bind(&AndroidDevice::HttpQuery,
-            device_, socket_, request, base::Bind(&NoOp)));
-  } else {
-    adb_thread_->message_loop()->PostTask(FROM_HERE,
-        base::Bind(&AndroidDevice::HttpQuery,
-            device_, socket_, kNewPageRequest,
-            base::Bind(&RemoteBrowser::PageCreatedOnHandlerThread, this, url)));
-  }
+      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;
-  // Navigating too soon after the page creation breaks navigation history
-  // (crbug.com/311014). This can be avoided by adding a moderate delay.
-  BrowserThread::PostDelayedTask(
+  BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&RemoteBrowser::PageCreatedOnUIThread, this, response, url),
-      base::TimeDelta::FromMilliseconds(kNewPageNavigateDelayMs));
+      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)) {
-    RemotePageTarget new_page(this, *dict);
-    new_page.Navigate(url);
+    scoped_refptr<RemotePage> new_page =
+        new RemotePage(adb_thread_, device_, socket_, *dict);
+    base::DictionaryValue params;
+    params.SetString(kUrlParam, url);
+    new_page->SendProtocolCommand(kPageNavigateCommand, &params);
   }
 }
 
 DevToolsAdbBridge::RemoteBrowser::~RemoteBrowser() {
 }
 
 
 // DevToolsAdbBridge::RemoteDevice --------------------------------------------
 
 DevToolsAdbBridge::RemoteDevice::RemoteDevice(
@@ skipping 37 matching lines @@
 }
 
 void DevToolsAdbBridge::RemoveListener(Listener* listener) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   Listeners::iterator it =
       std::find(listeners_.begin(), listeners_.end(), listener);
   DCHECK(it != listeners_.end());
   listeners_.erase(it);
 }
 
-bool DevToolsAdbBridge::HasDevToolsWindow(const std::string& agent_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return g_host_delegates.Get().find(agent_id) != g_host_delegates.Get().end();
-}
-
 DevToolsAdbBridge::~DevToolsAdbBridge() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(listeners_.empty());
 }
 
 void DevToolsAdbBridge::RequestRemoteDevices() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!has_message_loop_)
     return;
 
@@ skipping 13 matching lines @@
 
   if (listeners_.empty())
     return;
 
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&DevToolsAdbBridge::RequestRemoteDevices, this),
       base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
 }