[DevTools] Simplify choice of UMA on remote inspect

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 <vector>
 
 #include "base/base64.h"
@@ skipping 48 matching lines @@
 const char kBrowserTargetSocket[] = "/devtools/browser";
 const int kAdbPollingIntervalMs = 1000;
 
 const char kUrlParam[] = "url";
 const char kPageReloadCommand[] = "Page.reload";
 const char kPageNavigateCommand[] = "Page.navigate";
 
 const int kMinVersionNewWithURL = 32;
 const int kNewPageNavigateDelayMs = 500;
 
+const char kWebViewSocketPrefix[] = "webview_devtools_remote";
+
 bool IsWebRTCDeviceProviderEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableDevToolsExperiments);
 }
 
 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;
@@ skipping 107 matching lines @@
     int result,
     const std::string& response) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (result < 0)
     return;
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::ListValue* list_value;
   if (value && value->GetAsList(&list_value)) {
     for (const auto& page_value : *list_value) {
       base::DictionaryValue* dict;
-      if (page_value->GetAsDictionary(&dict)) {
-        browser->pages_.push_back(
-            new RemotePage(browser->browser_id_, *dict, browser->IsWebView()));
-      }
+      if (page_value->GetAsDictionary(&dict))
+        browser->pages_.push_back(new RemotePage(browser->browser_id_, *dict));
     }
   }
 }
 
 // ProtocolCommand ------------------------------------------------------------
 
 namespace {
 
 class ProtocolCommand
     : public AndroidDeviceManager::AndroidWebSocket::Delegate {
@@ skipping 91 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& debug_url,
-      bool is_web_view);
+      const std::string& debug_url);
 
  private:
   AgentHostDelegate(
       DevToolsAndroidBridge* bridge,
       const std::string& id,
       const BrowserId& browser_id,
-      const std::string& debug_url,
-      bool is_web_view);
+      const std::string& debug_url);
   ~AgentHostDelegate() override;
   void Attach(content::DevToolsExternalAgentProxy* proxy) override;
   void Detach() 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 debug_url_;
   bool socket_opened_;
-  bool is_web_view_;
   std::vector<std::string> pending_messages_;
   scoped_refptr<AndroidDeviceManager::Device> device_;
   scoped_ptr<AndroidDeviceManager::AndroidWebSocket> web_socket_;
   content::DevToolsAgentHost* agent_host_;
   content::DevToolsExternalAgentProxy* proxy_;
   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,
-    bool is_web_view) {
+    const std::string& debug_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   AgentHostDelegates::iterator it = bridge->host_delegates_.find(id);
   if (it != bridge->host_delegates_.end())
     return it->second->agent_host_;
 
   AgentHostDelegate* delegate =
-      new AgentHostDelegate(bridge, id, browser_id, debug_url, is_web_view);
+      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,
-    bool is_web_view)
+    const std::string& debug_url)
     : id_(id),
       bridge_(bridge->AsWeakPtr()),
       browser_id_(browser_id),
       debug_url_(debug_url),
       socket_opened_(false),
-      is_web_view_(is_web_view),
       agent_host_(NULL),
       proxy_(NULL) {
   bridge_->host_delegates_[id] = this;
 }
 
 DevToolsAndroidBridge::AgentHostDelegate::~AgentHostDelegate() {
   if (bridge_)
     bridge_->host_delegates_.erase(id_);
 }
 
 void DevToolsAndroidBridge::AgentHostDelegate::Attach(
     content::DevToolsExternalAgentProxy* proxy) {
   proxy_ = proxy;
-  content::RecordAction(is_web_view_ ?
+  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(
@@ skipping 32 matching lines @@
   if (proxy_)
     proxy_->ConnectionClosed();
 }
 
 //// RemotePageTarget ----------------------------------------------
 
 class DevToolsAndroidBridge::RemotePageTarget : public DevToolsTargetImpl {
  public:
   RemotePageTarget(DevToolsAndroidBridge* bridge,
                    const BrowserId& browser_id,
-                   const base::DictionaryValue& value,
-                   bool is_web_view_);
+                   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;
 
@@ skipping 40 matching lines @@
   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,
-    bool is_web_view)
+    const base::DictionaryValue& value)
     : DevToolsTargetImpl(AgentHostDelegate::GetOrCreateAgentHost(
                              bridge,
                              BuildUniqueTargetId(browser_id, value),
                              browser_id,
-                             GetDebugURL(value),
-                             is_web_view)),
+                             GetDebugURL(value))),
       bridge_(bridge->AsWeakPtr()),
       browser_id_(browser_id),
       debug_url_(GetDebugURL(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(
@@ skipping 59 matching lines @@
     return;
 
   scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue);
   params->SetString(kUrlParam, url);
   bridge_->SendProtocolCommand(browser_id_, debug_url_, kPageNavigateCommand,
                                params.Pass(), callback);
 }
 
 // DevToolsAndroidBridge::RemotePage ------------------------------------------
 
-DevToolsAndroidBridge::RemotePage::RemotePage(
-    const BrowserId& browser_id,
-    const base::DictionaryValue& dict,
-    bool is_web_view)
+DevToolsAndroidBridge::RemotePage::RemotePage(const BrowserId& browser_id,
+                                              const base::DictionaryValue& dict)
     : browser_id_(browser_id),
       frontend_url_(GetFrontendURL(dict)),
-      is_web_view_(is_web_view),
       dict_(dict.DeepCopy()) {
 }
 
 DevToolsAndroidBridge::RemotePage::~RemotePage() {
 }
 
 // DevToolsAndroidBridge::RemoteBrowser ---------------------------------------
 
 DevToolsAndroidBridge::RemoteBrowser::RemoteBrowser(
     const std::string& serial,
     const AndroidDeviceManager::BrowserInfo& browser_info)
     : browser_id_(std::make_pair(serial, browser_info.socket_name)),
       display_name_(browser_info.display_name),
       user_(browser_info.user),
       type_(browser_info.type) {
 }
 
 bool DevToolsAndroidBridge::RemoteBrowser::IsChrome() {
   return type_ == AndroidDeviceManager::BrowserInfo::kTypeChrome;

[dgozman, 2015/03/25 16:11:50]

Let's remove |type| everywhere, move GetBrowserType() function right here, and
call it when needed.

[vkuzkokov, 2015/03/26 09:46:31]

Moving GetBrowserType here would require splitting kBrowserDescriptors between
here and android_device_info_query.cc which seems unnecessary as the part we're
moving here we were going to move further to javascript anyway.

 }
 
-bool DevToolsAndroidBridge::RemoteBrowser::IsWebView() {
-  return type_ == AndroidDeviceManager::BrowserInfo::kTypeWebView;
-}
-
 std::string DevToolsAndroidBridge::RemoteBrowser::GetId() {
   return serial() + ":" + socket();
 }
 
 DevToolsAndroidBridge::RemoteBrowser::ParsedVersion
 DevToolsAndroidBridge::RemoteBrowser::GetParsedVersion() {
   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;
 }
 
 DevToolsTargetImpl*
 DevToolsAndroidBridge::CreatePageTarget(scoped_refptr<RemotePage> page) {
-  return new RemotePageTarget(this, page->browser_id_, *page->dict_,
-                              page->is_web_view_);
+  return new RemotePageTarget(this, page->browser_id_, *page->dict_);
 }
 
 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 23 matching lines @@
       callback);
 }
 
 scoped_refptr<content::DevToolsAgentHost>
 DevToolsAndroidBridge::GetBrowserAgentHost(
     scoped_refptr<RemoteBrowser> browser) {
   return AgentHostDelegate::GetOrCreateAgentHost(
       this,
       "adb:" + browser->serial() + ":" + browser->socket(),
       browser->browser_id_,
-      kBrowserTargetSocket,
-      browser->IsWebView());
+      kBrowserTargetSocket);
 }
 
 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 12 matching lines @@
     const RemotePageCallback& callback,
     int result,
     const std::string& response) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (result < 0) {
     callback.Run(NULL);
     return;
   }
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::DictionaryValue* dict;
-  if (value && value->GetAsDictionary(&dict)) {
-    scoped_refptr<RemotePage> new_page(
-        new RemotePage(browser->browser_id_, *dict, browser->IsWebView()));
-    callback.Run(new_page);
-  }
+  if (value && value->GetAsDictionary(&dict))
+    callback.Run(new RemotePage(browser->browser_id_, *dict));
 }
 
 void DevToolsAndroidBridge::OpenRemotePage(
     scoped_refptr<RemoteBrowser> browser,
     const std::string& input_url,
     const DevToolsAndroidBridge::RemotePageCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   GURL gurl(input_url);
   if (!gurl.is_valid()) {
     gurl = GURL("http://" + input_url);
@@ skipping 42 matching lines @@
     scoped_refptr<RemoteBrowser> browser,
     const RemotePageCallback& callback,
     int result,
     const std::string& response,
     const std::string& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::DictionaryValue* dict;
 
   if (value && value->GetAsDictionary(&dict)) {
-    RemotePageTarget new_page(this, browser->browser_id_, *dict,
-                              browser->IsWebView());
+    RemotePageTarget new_page(this, browser->browser_id_, *dict);
     new_page.Navigate(url,
         base::Bind(&DevToolsAndroidBridge::RespondToOpenOnUIThread,
                    AsWeakPtr(), browser, callback, result, response));
   }
 }
 
 DevToolsAndroidBridge::RemoteBrowser::~RemoteBrowser() {
 }
 
 // DevToolsAndroidBridge::RemoteDevice ----------------------------------------
@@ skipping 234 matching lines @@
     device_providers.push_back(
         new WebRTCDeviceProvider(profile_, signin_manager_, token_service_));
   }
 
   device_manager_->SetDeviceProviders(device_providers);
   if (NeedsDeviceListPolling()) {
     StopDeviceListPolling();
     StartDeviceListPolling();
   }
 }