DevTools: Make Android tabs unloaded from memory accessible via remote debugging protocol (re-land of step 3)

The previous attempt (https://chromiumcodereview.appspot.com/25627004) broke telemetry tests because ChromiumTestShell has no tab models so json/list always returned an empty list.

This patch adds the targets not associated with any tabs to the list.


BUG=272174

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@230755 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 282 insertions, 80 deletions

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/TabBase.java b/chrome/android/java/src/org/chromium/chrome/browser/TabBase.java
index 688c70b..500cc81 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/TabBase.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/TabBase.java
@@ -528,7 +528,7 @@ public abstract class TabBase implements NavigationClient {
 
         assert mNativeTabAndroid != 0;
         nativeInitWebContents(
-                mNativeTabAndroid, mId, mIncognito, mContentViewCore, mWebContentsDelegate);
+                mNativeTabAndroid, mIncognito, mContentViewCore, mWebContentsDelegate);
 
         // In the case where restoring a Tab or showing a prerendered one we already have a
         // valid infobar container, no need to recreate one.
@@ -559,6 +559,31 @@ public abstract class TabBase implements NavigationClient {
         }
     }
 
+    /**
+     * @return The url associated with the tab.
+     */
+    @CalledByNative
+    public String getUrl() {
+        return getPageInfo() != null ? getPageInfo().getUrl() : "";
+    }
+
+    /**
+     * @return The tab title.
+     */
+    @CalledByNative
+    public String getTitle() {
+        return getPageInfo() != null ? getPageInfo().getTitle() : "";
+    }
+
+    /**
+     * Restores the tab if it is frozen or crashed.
+     * @return true iff tab restore was triggered.
+     */
+    @CalledByNative
+    public boolean restoreIfNeeded() {
+        return false;
+    }
+
     private void destroyNativePageInternal() {
         if (mNativePage == null) return;
 
@@ -721,7 +746,7 @@ public abstract class TabBase implements NavigationClient {
         sIdCounter.addAndGet(diff);
     }
 
-    private native void nativeInitWebContents(int nativeTabAndroid, int id, boolean incognito,
+    private native void nativeInitWebContents(int nativeTabAndroid, boolean incognito,
             ContentViewCore contentViewCore, ChromeWebContentsDelegateAndroid delegate);
     private native void nativeDestroyWebContents(int nativeTabAndroid, boolean deleteNative);
     private native Profile nativeGetProfileAndroid(int nativeTabAndroid);
diff --git a/chrome/browser/android/dev_tools_server.cc b/chrome/browser/android/dev_tools_server.cc
index 49a3b79..80d09fa 100644
--- a/chrome/browser/android/dev_tools_server.cc
+++ b/chrome/browser/android/dev_tools_server.cc
@@ -14,8 +14,10 @@
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/android/tab_android.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/devtools/devtools_adb_bridge.h"
 #include "chrome/browser/history/top_sites.h"
@@ -54,69 +56,200 @@ const char kDefaultSocketNamePrefix[] = "chrome";
 const char kTetheringSocketName[] = "chrome_devtools_tethering_%d_%d";
 
 const char kTargetTypePage[] = "page";
+const char kTargetTypeOther[] = "other";
 
-class Target : public content::DevToolsTarget {
- public:
-  explicit Target(WebContents* web_contents);
+static GURL GetFaviconURL(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();
+}
 
-  virtual std::string GetId() const OVERRIDE { return id_; }
-  virtual std::string GetType() const OVERRIDE { return kTargetTypePage; }
+class TargetBase : public content::DevToolsTarget {
+ public:
+  // content::DevToolsTarget implementation:
   virtual std::string GetTitle() const OVERRIDE { return title_; }
+
   virtual std::string GetDescription() const OVERRIDE { return std::string(); }
+
   virtual GURL GetUrl() const OVERRIDE { return url_; }
+
   virtual GURL GetFaviconUrl() const OVERRIDE { return favicon_url_; }
+
   virtual base::TimeTicks GetLastActivityTime() const OVERRIDE {
     return last_activity_time_;
   }
+
+ protected:
+  explicit TargetBase(WebContents* web_contents)
+      : title_(UTF16ToUTF8(web_contents->GetTitle())),
+        url_(web_contents->GetURL()),
+        favicon_url_(GetFaviconURL(web_contents)),
+        last_activity_time_(web_contents->GetLastSelectedTime()) {
+  }
+
+  TargetBase(const string16& title, const GURL& url)
+      : title_(UTF16ToUTF8(title)),
+        url_(url)
+  {}
+
+ private:
+  const std::string title_;
+  const GURL url_;
+  const GURL favicon_url_;
+  const base::TimeTicks last_activity_time_;
+};
+
+class TabTarget : public TargetBase {
+ public:
+  static TabTarget* CreateForWebContents(int tab_id,
+                                         WebContents* web_contents) {
+    return new TabTarget(tab_id, web_contents);
+  }
+
+  static TabTarget* CreateForUnloadedTab(int tab_id,
+                                         const string16& title,
+                                         const GURL& url) {
+    return new TabTarget(tab_id, title, url);
+  }
+
+  // content::DevToolsTarget implementation:
+  virtual std::string GetId() const OVERRIDE {
+    return base::IntToString(tab_id_);
+  }
+
+  virtual std::string GetType() const OVERRIDE { return kTargetTypePage; }
+
   virtual bool IsAttached() const OVERRIDE {
-    return agent_host_->IsAttached();
+    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);
   }
+
   virtual scoped_refptr<DevToolsAgentHost> GetAgentHost() const OVERRIDE {
-    return agent_host_;
+    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);
+      tab->RestoreIfNeeded();
+      web_contents = model->GetWebContentsAt(index);
+      if (!web_contents)
+        return NULL;
+    }
+    RenderViewHost* rvh = web_contents->GetRenderViewHost();
+    return rvh ? DevToolsAgentHost::GetOrCreateFor(rvh) : NULL;
+  }
+
+  virtual bool Activate() const OVERRIDE {
+    TabModel* model;
+    int index;
+    if (!FindTab(&model, &index))
+      return false;
+    model->SetActiveIndex(index);
+    return true;
+  }
+
+  virtual bool Close() const OVERRIDE {
+    TabModel* model;
+    int index;
+    if (!FindTab(&model, &index))
+      return false;
+    model->CloseTabAt(index);
+    return true;
   }
-  virtual bool Activate() const OVERRIDE;
-  virtual bool Close() const OVERRIDE;
 
  private:
-  scoped_refptr<DevToolsAgentHost> agent_host_;
-  std::string id_;
-  std::string title_;
-  GURL url_;
-  GURL favicon_url_;
-  base::TimeTicks last_activity_time_;
-};
+  TabTarget(int tab_id, WebContents* web_contents)
+      : TargetBase(web_contents),
+        tab_id_(tab_id) {
+  }
 
-Target::Target(WebContents* web_contents) {
-  agent_host_ =
-      DevToolsAgentHost::GetOrCreateFor(web_contents->GetRenderViewHost());
-  id_ = agent_host_->GetId();
-  title_ = UTF16ToUTF8(web_contents->GetTitle());
-  url_ = web_contents->GetURL();
-  content::NavigationController& controller = web_contents->GetController();
-  content::NavigationEntry* entry = controller.GetActiveEntry();
-  if (entry != NULL && entry->GetURL().is_valid())
-    favicon_url_ = entry->GetFavicon().url;
-  last_activity_time_ = web_contents->GetLastSelectedTime();
-}
+  TabTarget(int tab_id, const string16& title, const GURL& url)
+      : TargetBase(title, url),
+        tab_id_(tab_id) {
+  }
 
-bool Target::Activate() const {
-  RenderViewHost* rvh = agent_host_->GetRenderViewHost();
-  if (!rvh)
-    return false;
-  WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
-  if (!web_contents)
+  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->GetAndroidId() == tab_id_) {
+          *model_result = model;
+          *index_result = i;
+          return true;
+        }
+      }
+    }
     return false;
-  web_contents->GetDelegate()->ActivateContents(web_contents);
-  return true;
-}
+  }
 
-bool Target::Close() const {
-  RenderViewHost* rvh = agent_host_->GetRenderViewHost();
-  if (!rvh)
-    return false;
-  rvh->ClosePage();
-  return true;
-}
+  const int tab_id_;
+};
+
+class NonTabTarget : public TargetBase {
+ public:
+  explicit NonTabTarget(WebContents* web_contents)
+      : TargetBase(web_contents),
+        agent_host_(DevToolsAgentHost::GetOrCreateFor(
+            web_contents->GetRenderViewHost())) {
+  }
+
+  // content::DevToolsTarget implementation:
+  virtual std::string GetId() const OVERRIDE {
+    return agent_host_->GetId();
+  }
+
+  virtual std::string GetType() const OVERRIDE {
+    if (TabModelList::begin() == TabModelList::end()) {
+      // If there are no tab models we must be running in ChromiumTestShell.
+      // Return the 'page' target type for backwards compatibility.
+      return kTargetTypePage;
+    }
+    return kTargetTypeOther;
+  }
+
+  virtual bool IsAttached() const OVERRIDE {
+    return agent_host_->IsAttached();
+  }
+
+  virtual scoped_refptr<DevToolsAgentHost> GetAgentHost() const OVERRIDE {
+    return agent_host_;
+  }
+
+  virtual bool Activate() const OVERRIDE {
+    RenderViewHost* rvh = agent_host_->GetRenderViewHost();
+    if (!rvh)
+      return false;
+    WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
+    if (!web_contents)
+      return false;
+    web_contents->GetDelegate()->ActivateContents(web_contents);
+    return true;
+  }
+
+  virtual bool Close() const OVERRIDE {
+    RenderViewHost* rvh = agent_host_->GetRenderViewHost();
+    if (!rvh)
+      return false;
+    rvh->ClosePage();
+    return true;
+  }
+
+ private:
+  scoped_refptr<DevToolsAgentHost> agent_host_;
+};
 
 // Delegate implementation for the devtools http handler on android. A new
 // instance of this gets created each time devtools is enabled.
@@ -168,19 +301,55 @@ class DevToolsServerDelegate : public content::DevToolsHttpHandlerDelegate {
         tab_model->CreateTabForTesting(GURL(content::kAboutBlankURL));
     if (!web_contents)
       return scoped_ptr<content::DevToolsTarget>();
-    return scoped_ptr<content::DevToolsTarget>(new Target(web_contents));
+
+    for (int i = 0; i < tab_model->GetTabCount(); ++i) {
+      if (web_contents != tab_model->GetWebContentsAt(i))
+        continue;
+      TabAndroid* tab = tab_model->GetTabAt(i);
+      return scoped_ptr<content::DevToolsTarget>(
+          TabTarget::CreateForWebContents(tab->GetAndroidId(), web_contents));
+    }
+
+    // Newly created tab not found, return no target.
+    return scoped_ptr<content::DevToolsTarget>();
   }
 
   virtual void EnumerateTargets(TargetCallback callback) OVERRIDE {
     TargetList targets;
+
+    // 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);
+        WebContents* web_contents = model->GetWebContentsAt(i);
+        if (web_contents) {
+          tab_web_contents.insert(web_contents);
+          targets.push_back(TabTarget::CreateForWebContents(tab->GetAndroidId(),
+                                                            web_contents));
+        } else {
+          targets.push_back(TabTarget::CreateForUnloadedTab(tab->GetAndroidId(),
+                                                            tab->GetTitle(),
+                                                            tab->GetURL()));
+        }
+      }
+    }
+
+    // Add targets for WebContents not associated with any tabs.
     std::vector<RenderViewHost*> rvh_list =
         DevToolsAgentHost::GetValidRenderViewHosts();
     for (std::vector<RenderViewHost*>::iterator it = rvh_list.begin();
          it != rvh_list.end(); ++it) {
       WebContents* web_contents = WebContents::FromRenderViewHost(*it);
-      if (web_contents)
-        targets.push_back(new Target(web_contents));
+      if (!web_contents)
+        continue;
+      if (tab_web_contents.find(web_contents) != tab_web_contents.end())
+        continue;
+      targets.push_back(new NonTabTarget(web_contents));
     }
+
     callback.Run(targets);
   }
 
diff --git a/chrome/browser/android/tab_android.cc b/chrome/browser/android/tab_android.cc
index becad84..c63c105 100644
--- a/chrome/browser/android/tab_android.cc
+++ b/chrome/browser/android/tab_android.cc
@@ -156,6 +156,32 @@ int TabAndroid::GetAndroidId() const {
   return Java_TabBase_getId(env, obj.obj());
 }
 
+string16 TabAndroid::GetTitle() const {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> obj = weak_java_tab_.get(env);
+  if (obj.is_null())
+    return string16();
+  return base::android::ConvertJavaStringToUTF16(
+      Java_TabBase_getTitle(env, obj.obj()));
+}
+
+GURL TabAndroid::GetURL() const {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> obj = weak_java_tab_.get(env);
+  if (obj.is_null())
+    return GURL::EmptyGURL();
+  return GURL(base::android::ConvertJavaStringToUTF8(
+      Java_TabBase_getUrl(env, obj.obj())));
+}
+
+bool TabAndroid::RestoreIfNeeded() {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> obj = weak_java_tab_.get(env);
+  if (obj.is_null())
+    return false;
+  return Java_TabBase_restoreIfNeeded(env, obj.obj());
+}
+
 content::ContentViewCore* TabAndroid::GetContentViewCore() const {
   if (!web_contents())
     return NULL;
@@ -231,16 +257,6 @@ void TabAndroid::Observe(int type,
 
 void TabAndroid::InitWebContents(JNIEnv* env,
                                  jobject obj,
-                                 jint tab_id,
-                                 jboolean incognito,
-                                 jobject jcontent_view_core,
-                                 jobject jweb_contents_delegate) {
-  InitWebContents(
-      env, obj, incognito, jcontent_view_core, jweb_contents_delegate);
-}
-
-void TabAndroid::InitWebContents(JNIEnv* env,
-                                 jobject obj,
                                  jboolean incognito,
                                  jobject jcontent_view_core,
                                  jobject jweb_contents_delegate) {
diff --git a/chrome/browser/android/tab_android.h b/chrome/browser/android/tab_android.h
index 71c5745..2ef531f 100644
--- a/chrome/browser/android/tab_android.h
+++ b/chrome/browser/android/tab_android.h
@@ -57,8 +57,15 @@ class TabAndroid : public CoreTabHelperDelegate,
   // Return specific id information regarding this TabAndroid.
   const SessionID& session_id() const { return session_tab_id_; }
   int GetAndroidId() const;
-  // TODO(kaznacheev) Remove when there are no more downstream usages.
-  int android_id() const { return GetAndroidId(); }
+
+  // Return the tab title.
+  string16 GetTitle() const;
+
+  // Return the tab url.
+  GURL GetURL() const;
+
+  // Restore the tab if it was unloaded from memory.
+  bool RestoreIfNeeded();
 
   // Helper methods to make it easier to access objects from the associated
   // WebContents.  Can return NULL.
@@ -117,13 +124,6 @@ class TabAndroid : public CoreTabHelperDelegate,
 
   // Methods called from Java via JNI -----------------------------------------
 
-  // TODO(kaznacheev) Remove when there are no more downstream usages.
-  virtual void InitWebContents(JNIEnv* env,
-                               jobject obj,
-                               jint tab_id,
-                               jboolean incognito,
-                               jobject jcontent_view_core,
-                               jobject jweb_contents_delegate);
   virtual void InitWebContents(JNIEnv* env,
                                jobject obj,
                                jboolean incognito,
diff --git a/chrome/browser/ui/android/tab_model/tab_model.cc b/chrome/browser/ui/android/tab_model/tab_model.cc
index 4e6bc0e..9eb5f7a 100644
--- a/chrome/browser/ui/android/tab_model/tab_model.cc
+++ b/chrome/browser/ui/android/tab_model/tab_model.cc
@@ -123,10 +123,3 @@ void TabModel::Observe(
       NOTREACHED();
   }
 }
-
-// TODO(kaznacheev) Make these two  methods pure as soon as they are
-// implemented in TabModelImpl.
-void TabModel::SetActiveIndex(int index) { }
-
-void TabModel::CloseTabAt(int index) { }
-
diff --git a/chrome/browser/ui/android/tab_model/tab_model.h b/chrome/browser/ui/android/tab_model/tab_model.h
index ea53cc1..129164a 100644
--- a/chrome/browser/ui/android/tab_model/tab_model.h
+++ b/chrome/browser/ui/android/tab_model/tab_model.h
@@ -47,10 +47,8 @@ class TabModel : public content::NotificationObserver,
   virtual content::WebContents* GetWebContentsAt(int index) const = 0;
   virtual TabAndroid* GetTabAt(int index) const = 0;
 
-  // TODO(kaznacheev) Make these two  methods pure as soon as they are
-  // implemented in TabModelImpl.
-  virtual void SetActiveIndex(int index);
-  virtual void CloseTabAt(int index);
+  virtual void SetActiveIndex(int index) = 0;
+  virtual void CloseTabAt(int index) = 0;
 
   // Used for restoring tabs from synced foreign sessions.
   virtual void CreateTab(content::WebContents* web_contents) = 0;
diff --git a/chrome/browser/ui/android/tab_model/tab_model_unittest.cc b/chrome/browser/ui/android/tab_model/tab_model_unittest.cc
index 3feaf0f..bcddf79 100644
--- a/chrome/browser/ui/android/tab_model/tab_model_unittest.cc
+++ b/chrome/browser/ui/android/tab_model/tab_model_unittest.cc
@@ -43,7 +43,8 @@ class TestTabModel : public TabModel {
   virtual TabAndroid* GetTabAt(int index) const OVERRIDE {
     return NULL;
   }
-
+  virtual void SetActiveIndex(int index) OVERRIDE {}
+  virtual void CloseTabAt(int index) OVERRIDE {}
 };
 
 TEST_F(TabModelTest, TestProfileHandling) {