[DevTools] Migrate android to devtools_discovery.

BUG=476496

Review URL: https://codereview.chromium.org/1099243004

Cr-Commit-Position: refs/heads/master@{#327258}

android_webview/browser/aw_browser_main_parts.cc

@@ -13,7 +13,6 @@
 #include "base/android/memory_pressure_listener_android.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
-#include "components/devtools_discovery/devtools_discovery_manager.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
@@ -95,10 +94,7 @@ int AwBrowserMainParts::PreCreateThreads() {
 void AwBrowserMainParts::PreMainMessageLoopRun() {
   browser_context_->PreMainMessageLoopRun();
 
-  devtools_discovery::DevToolsDiscoveryManager* discovery_manager =
-      devtools_discovery::DevToolsDiscoveryManager::GetInstance();
-  discovery_manager->AddProvider(make_scoped_ptr(
-      new AwDevToolsDiscoveryProvider()));
+  AwDevToolsDiscoveryProvider::Install();
 
   // This is needed for WebView Classic backwards compatibility
   // See crbug.com/298495

android_webview/browser/aw_dev_tools_discovery_provider.cc

@@ -48,6 +48,8 @@ class TargetDescriptor : public devtools_discovery::BasicTargetDescriptor {
 
  private:
   std::string description_;
+
+  DISALLOW_COPY_AND_ASSIGN(TargetDescriptor);
 };
 
 TargetDescriptor::TargetDescriptor(scoped_refptr<DevToolsAgentHost> agent_host)
@@ -60,6 +62,14 @@ TargetDescriptor::TargetDescriptor(scoped_refptr<DevToolsAgentHost> agent_host)
 
 namespace android_webview {
 
+// static
+void AwDevToolsDiscoveryProvider::Install() {
+  devtools_discovery::DevToolsDiscoveryManager* discovery_manager =
+      devtools_discovery::DevToolsDiscoveryManager::GetInstance();
+  discovery_manager->AddProvider(
+      make_scoped_ptr(new AwDevToolsDiscoveryProvider()));
+}
+
 AwDevToolsDiscoveryProvider::AwDevToolsDiscoveryProvider() {
 }
 

android_webview/browser/aw_dev_tools_discovery_provider.h

@@ -12,13 +12,17 @@ namespace android_webview {
 class AwDevToolsDiscoveryProvider :
     public devtools_discovery::DevToolsDiscoveryManager::Provider {
  public:
-  AwDevToolsDiscoveryProvider();
+  // Installs provider to devtools_discovery.
+  static void Install();
+
   ~AwDevToolsDiscoveryProvider() override;
 
   // devtools_discovery::DevToolsDiscoveryManager::Provider implementation.
   devtools_discovery::DevToolsTargetDescriptor::List GetDescriptors() override;
 
  private:
+  AwDevToolsDiscoveryProvider();
+
   DISALLOW_COPY_AND_ASSIGN(AwDevToolsDiscoveryProvider);
 };
 

chrome/browser/BUILD.gn

@@ -242,6 +242,7 @@ source_set("browser") {
       "//components/autofill/content/browser",
       "//components/browsing_data",
       "//components/data_reduction_proxy/content/browser",
+      "//components/devtools_discovery",
       "//components/devtools_http_handler",
       "//components/dom_distiller/content",
       "//components/favicon/content",

chrome/browser/android/DEPS

 include_rules = [
   "-components/devtools_bridge",
+  "+components/devtools_discovery",
   "+components/devtools_http_handler",
   "+components/service_tab_launcher",
   "+components/web_contents_delegate_android",

chrome/browser/android/dev_tools_discovery_provider_android.cc

+// Copyright 2015 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/android/dev_tools_discovery_provider_android.h"
+
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/android/tab_android.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/ui/android/tab_model/tab_model.h"
+#include "chrome/browser/ui/android/tab_model/tab_model_list.h"
+#include "components/devtools_discovery/basic_target_descriptor.h"
+#include "components/devtools_discovery/devtools_discovery_manager.h"
+#include "content/public/browser/devtools_agent_host.h"
+#include "content/public/browser/devtools_target.h"
+#include "content/public/browser/favicon_status.h"
+#include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/web_contents.h"
+
+using content::DevToolsAgentHost;
+using content::WebContents;
+
+namespace {
+
+GURL GetFaviconURLForContents(WebContents* web_contents) {
+  content::NavigationController& controller = web_contents->GetController();
+  content::NavigationEntry* entry = controller.GetActiveEntry();
+  if (entry != NULL && entry->GetURL().is_valid())
+    return entry->GetFavicon().url;
+  return GURL();
+}
+
+class TabDescriptor : public devtools_discovery::DevToolsTargetDescriptor {
+ public:
+  static TabDescriptor* CreateForWebContents(int tab_id,
+                                             WebContents* web_contents) {
+    return new TabDescriptor(tab_id, web_contents);
+  }
+
+  static TabDescriptor* CreateForUnloadedTab(int tab_id,
+                                             const base::string16& title,
+                                             const GURL& url) {
+    return new TabDescriptor(tab_id, title, url);
+  }
+
+  ~TabDescriptor() override {
+  }
+
+  // devtools_discovery::DevToolsTargetDescriptor implementation.
+  std::string GetParentId() const override {
+    return std::string();
+  }
+
+  std::string GetTitle() const override {
+    return title_;
+  }
+
+  std::string GetDescription() const override {
+    return std::string();
+  }
+
+  GURL GetURL() const override {
+    return url_;
+  }
+
+  GURL GetFaviconURL() const override {
+    return favicon_url_;
+  }
+
+  base::TimeTicks GetLastActivityTime() const override {
+    return last_activity_time_;
+  }
+
+  std::string GetId() const override {
+    return base::IntToString(tab_id_);
+  }
+
+  std::string GetType() const override {
+    return devtools_discovery::BasicTargetDescriptor::kTypePage;
+  }
+
+  bool IsAttached() const override {
+    TabModel* model;
+    int index;
+    if (!FindTab(&model, &index))
+      return false;
+    WebContents* web_contents = model->GetWebContentsAt(index);
+    if (!web_contents)
+      return false;
+    return DevToolsAgentHost::IsDebuggerAttached(web_contents);
+  }
+
+  scoped_refptr<DevToolsAgentHost> GetAgentHost() const override {
+    TabModel* model;
+    int index;
+    if (!FindTab(&model, &index))
+      return NULL;
+    WebContents* web_contents = model->GetWebContentsAt(index);
+    if (!web_contents) {
+      // The tab has been pushed out of memory, pull it back.
+      TabAndroid* tab = model->GetTabAt(index);
+      if (!tab)
+        return NULL;
+
+      if (!tab->LoadIfNeeded())
+        return NULL;
+
+      web_contents = model->GetWebContentsAt(index);
+      if (!web_contents)
+        return NULL;
+    }
+    return DevToolsAgentHost::GetOrCreateFor(web_contents);
+  }
+
+  bool Activate() const override {
+    TabModel* model;
+    int index;
+    if (!FindTab(&model, &index))
+      return false;
+    model->SetActiveIndex(index);
+    return true;
+  }
+
+  bool Close() const override {
+    TabModel* model;
+    int index;
+    if (!FindTab(&model, &index))
+      return false;
+    model->CloseTabAt(index);
+    return true;
+  }
+
+ private:
+  TabDescriptor(int tab_id, WebContents* web_contents)
+      : tab_id_(tab_id),
+        title_(base::UTF16ToUTF8(web_contents->GetTitle())),
+        url_(web_contents->GetURL()),
+        favicon_url_(GetFaviconURLForContents(web_contents)),
+        last_activity_time_(web_contents->GetLastActiveTime()) {
+  }
+
+  TabDescriptor(int tab_id, const base::string16& title, const GURL& url)
+      : tab_id_(tab_id),
+        title_(base::UTF16ToUTF8(title)),
+        url_(url) {
+  }
+
+  bool FindTab(TabModel** model_result, int* index_result) const {
+    for (TabModelList::const_iterator iter = TabModelList::begin();
+        iter != TabModelList::end(); ++iter) {
+      TabModel* model = *iter;
+      for (int i = 0; i < model->GetTabCount(); ++i) {
+        TabAndroid* tab = model->GetTabAt(i);
+        if (tab && tab->GetAndroidId() == tab_id_) {
+          *model_result = model;
+          *index_result = i;
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  const int tab_id_;
+  const std::string title_;
+  const GURL url_;
+  const GURL favicon_url_;
+  const base::TimeTicks last_activity_time_;
+
+  DISALLOW_COPY_AND_ASSIGN(TabDescriptor);
+};
+
+scoped_ptr<devtools_discovery::DevToolsTargetDescriptor>
+CreateNewAndroidTab(const GURL& url) {
+  if (TabModelList::empty())
+    return scoped_ptr<devtools_discovery::DevToolsTargetDescriptor>();
+
+  TabModel* tab_model = TabModelList::get(0);
+  if (!tab_model)
+    return scoped_ptr<devtools_discovery::DevToolsTargetDescriptor>();
+
+  WebContents* web_contents = tab_model->CreateNewTabForDevTools(url);
+  if (!web_contents)
+    return scoped_ptr<devtools_discovery::DevToolsTargetDescriptor>();
+
+  TabAndroid* tab = TabAndroid::FromWebContents(web_contents);
+  if (!tab)
+    return scoped_ptr<devtools_discovery::DevToolsTargetDescriptor>();
+
+  return make_scoped_ptr(TabDescriptor::CreateForWebContents(
+      tab->GetAndroidId(), web_contents));
+}
+
+}  // namespace
+
+DevToolsDiscoveryProviderAndroid::DevToolsDiscoveryProviderAndroid() {
+}
+
+DevToolsDiscoveryProviderAndroid::~DevToolsDiscoveryProviderAndroid() {
+}
+
+devtools_discovery::DevToolsTargetDescriptor::List
+DevToolsDiscoveryProviderAndroid::GetDescriptors() {
+  devtools_discovery::DevToolsTargetDescriptor::List result;
+
+  // Enumerate existing tabs, including the ones with no WebContents.
+  std::set<WebContents*> tab_web_contents;
+  for (TabModelList::const_iterator iter = TabModelList::begin();
+      iter != TabModelList::end(); ++iter) {
+    TabModel* model = *iter;
+    for (int i = 0; i < model->GetTabCount(); ++i) {
+      TabAndroid* tab = model->GetTabAt(i);
+      if (!tab)
+        continue;
+
+      WebContents* web_contents = tab->web_contents();
+      if (web_contents) {
+        tab_web_contents.insert(web_contents);
+        result.push_back(TabDescriptor::CreateForWebContents(
+            tab->GetAndroidId(), web_contents));
+      } else {
+        result.push_back(TabDescriptor::CreateForUnloadedTab(
+            tab->GetAndroidId(), tab->GetTitle(), tab->GetURL()));
+      }
+    }
+  }
+
+  // Add descriptors for targets not associated with any tabs.
+  DevToolsAgentHost::List agents = DevToolsAgentHost::GetOrCreateAll();
+  for (DevToolsAgentHost::List::iterator it = agents.begin();
+       it != agents.end(); ++it) {
+    if (WebContents* web_contents = (*it)->GetWebContents()) {
+      if (tab_web_contents.find(web_contents) != tab_web_contents.end())
+        continue;
+    }
+    result.push_back(new devtools_discovery::BasicTargetDescriptor(*it));
+  }
+
+  return result;
+}
+
+// static
+void DevToolsDiscoveryProviderAndroid::Install() {
+  devtools_discovery::DevToolsDiscoveryManager* discovery_manager =
+      devtools_discovery::DevToolsDiscoveryManager::GetInstance();
+  discovery_manager->AddProvider(
+      make_scoped_ptr(new DevToolsDiscoveryProviderAndroid()));
+  discovery_manager->SetCreateCallback(base::Bind(&CreateNewAndroidTab));
+}

chrome/browser/android/dev_tools_discovery_provider_android.h

+// Copyright 2015 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.
+
+#ifndef CHROME_BROWSER_ANDROID_DEV_TOOLS_DISCOVERY_PROVIDER_ANDROID_H_
+#define CHROME_BROWSER_ANDROID_DEV_TOOLS_DISCOVERY_PROVIDER_ANDROID_H_
+
+#include "components/devtools_discovery/devtools_discovery_manager.h"
+
+class DevToolsDiscoveryProviderAndroid :
+    public devtools_discovery::DevToolsDiscoveryManager::Provider {
+ public:
+  // Installs provider to devtools_discovery.
+  static void Install();
+
+  ~DevToolsDiscoveryProviderAndroid() override;
+
+  // devtools_discovery::DevToolsDiscoveryManager::Provider implementation.
+  devtools_discovery::DevToolsTargetDescriptor::List GetDescriptors() override;
+
+ private:
+  DevToolsDiscoveryProviderAndroid();
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsDiscoveryProviderAndroid);
+};
+
+#endif  // CHROME_BROWSER_ANDROID_DEV_TOOLS_DISCOVERY_PROVIDER_ANDROID_H_

chrome/browser/android/dev_tools_manager_delegate_android.h

@@ -11,6 +11,8 @@
 #include "chrome/browser/devtools/devtools_network_protocol_handler.h"
 #include "content/public/browser/devtools_manager_delegate.h"
 
+// TODO(dgozman): remove this class once transition to devtools_discovery is
+// completed.
 class DevToolsManagerDelegateAndroid : public content::DevToolsManagerDelegate {
  public:
   DevToolsManagerDelegateAndroid();

chrome/browser/chrome_browser_main.cc

@@ -145,6 +145,7 @@
 #include "ui/strings/grit/app_locale_settings.h"
 
 #if defined(OS_ANDROID)
+#include "chrome/browser/android/dev_tools_discovery_provider_android.h"
 #include "chrome/browser/metrics/thread_watcher_android.h"
 #else
 #include "chrome/browser/feedback/feedback_profile_observer.h"
@@ -1093,6 +1094,11 @@ void ChromeBrowserMainParts::PreProfileInit() {
 
 void ChromeBrowserMainParts::PostProfileInit() {
   TRACE_EVENT0("startup", "ChromeBrowserMainParts::PostProfileInit");
+
+#if defined(OS_ANDROID)
+  DevToolsDiscoveryProviderAndroid::Install();
+#endif  // defined(OS_ANDROID)
+
   LaunchDevToolsHandlerIfNeeded(parsed_command_line());
   for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
     chrome_extra_parts_[i]->PostProfileInit();

chrome/chrome_browser.gypi

@@ -76,6 +76,8 @@
       'browser/android/content_view_util.h',
       'browser/android/cookies/cookies_fetcher.cc',
       'browser/android/cookies/cookies_fetcher.h',
+      'browser/android/dev_tools_discovery_provider_android.cc',
+      'browser/android/dev_tools_discovery_provider_android.h',
       'browser/android/dev_tools_manager_delegate_android.cc',
       'browser/android/dev_tools_manager_delegate_android.h',
       'browser/android/dev_tools_server.cc',
@@ -3103,6 +3105,7 @@
             '../components/components.gyp:autofill_content_browser',
             '../components/components.gyp:browsing_data',
             '../components/components.gyp:data_reduction_proxy_content_browser',
+            '../components/components.gyp:devtools_discovery',
             '../components/components.gyp:devtools_http_handler',
             '../components/components.gyp:dom_distiller_content',
             '../components/components.gyp:favicon_content',

components/devtools_discovery/devtools_discovery_manager.cc

@@ -40,6 +40,18 @@ DevToolsTargetDescriptor::List DevToolsDiscoveryManager::GetDescriptors() {
   return result;
 }
 
+void DevToolsDiscoveryManager::SetCreateCallback(
+    const CreateCallback& callback) {
+  create_callback_ = callback;
+}
+
+scoped_ptr<DevToolsTargetDescriptor>
+DevToolsDiscoveryManager::CreateNew(const GURL& url) {
+  if (create_callback_.is_null())
+    return scoped_ptr<DevToolsTargetDescriptor>();
+  return create_callback_.Run(url);
+}
+
 DevToolsTargetDescriptor::List
 DevToolsDiscoveryManager::GetDescriptorsFromProviders() {
   DevToolsTargetDescriptor::List result;

components/devtools_discovery/devtools_discovery_manager.h

@@ -21,13 +21,18 @@ class DevToolsDiscoveryManager {
     virtual DevToolsTargetDescriptor::List GetDescriptors() = 0;
   };
 
+  using CreateCallback = base::Callback<
+      scoped_ptr<DevToolsTargetDescriptor>(const GURL& url)>;
+
   // Returns single instance of this class. The instance is destroyed on the
   // browser main loop exit so this method MUST NOT be called after that point.
   static DevToolsDiscoveryManager* GetInstance();
 
   void AddProvider(scoped_ptr<Provider> provider);
+  void SetCreateCallback(const CreateCallback& callback);
 
   DevToolsTargetDescriptor::List GetDescriptors();
+  scoped_ptr<DevToolsTargetDescriptor> CreateNew(const GURL& url);
 
  private:
   friend struct DefaultSingletonTraits<DevToolsDiscoveryManager>;
@@ -37,6 +42,7 @@ class DevToolsDiscoveryManager {
   DevToolsTargetDescriptor::List GetDescriptorsFromProviders();
 
   std::vector<Provider*> providers_;
+  CreateCallback create_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsDiscoveryManager);
 };

content/shell/browser/shell_devtools_manager_delegate.cc

@@ -132,6 +132,16 @@ CreateSocketFactory() {
 #endif
 }
 
+scoped_ptr<devtools_discovery::DevToolsTargetDescriptor>
+CreateNewShellTarget(BrowserContext* browser_context, const GURL& url) {
+  Shell* shell = Shell::CreateNewWindow(browser_context,
+                                        url,
+                                        nullptr,
+                                        gfx::Size());
+  return make_scoped_ptr(new devtools_discovery::BasicTargetDescriptor(
+      DevToolsAgentHost::GetOrCreateFor(shell->web_contents())));
+}
+
 // ShellDevToolsDelegate ----------------------------------------------------
 
 class ShellDevToolsDelegate :
@@ -152,9 +162,15 @@ class ShellDevToolsDelegate :
 
 ShellDevToolsDelegate::ShellDevToolsDelegate(BrowserContext* browser_context)
     : browser_context_(browser_context) {
+  devtools_discovery::DevToolsDiscoveryManager::GetInstance()->
+      SetCreateCallback(base::Bind(&CreateNewShellTarget,
+                                   base::Unretained(browser_context)));
 }
 
 ShellDevToolsDelegate::~ShellDevToolsDelegate() {
+  devtools_discovery::DevToolsDiscoveryManager::GetInstance()->
+      SetCreateCallback(
+          devtools_discovery::DevToolsDiscoveryManager::CreateCallback());
 }
 
 std::string ShellDevToolsDelegate::GetDiscoveryPageHTML() {
@@ -215,13 +231,9 @@ std::string ShellDevToolsManagerDelegate::GetPageThumbnailData(
 
 scoped_ptr<DevToolsTarget>
 ShellDevToolsManagerDelegate::CreateNewTarget(const GURL& url) {
-  Shell* shell = Shell::CreateNewWindow(browser_context_,
-                                        url,
-                                        NULL,
-                                        gfx::Size());
-  return scoped_ptr<DevToolsTarget>(
-      new devtools_discovery::BasicTargetDescriptor(
-          DevToolsAgentHost::GetOrCreateFor(shell->web_contents())));
+  devtools_discovery::DevToolsDiscoveryManager* discovery_manager =
+      devtools_discovery::DevToolsDiscoveryManager::GetInstance();
+  return discovery_manager->CreateNew(url);
 }
 
 void ShellDevToolsManagerDelegate::EnumerateTargets(TargetCallback callback) {