DevTools: retain DTAH in all the targets to match their life time.

chrome/browser/android/devtools_manager_delegate_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/devtools_manager_delegate_android.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 141 matching lines @@
   }
 
   const int tab_id_;
   const std::string title_;
   const GURL url_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
   content::DevToolsExternalAgentProxy* proxy_;
   DISALLOW_COPY_AND_ASSIGN(TabProxyDelegate);
 };
 
+scoped_refptr<DevToolsAgentHost> DevToolsAgentHostForTab(TabAndroid* tab) {
+  scoped_refptr<DevToolsAgentHost> result = tab->GetDevToolsAgentHost();
+  if (result)
+    return result;
+
+  result = DevToolsAgentHost::Forward(base::IntToString(tab->GetAndroidId()),
+                                      base::MakeUnique<TabProxyDelegate>(tab));
+  tab->SetDevToolsAgentHost(result);
+  return result;
+}
+
 } //  namespace
 
 DevToolsManagerDelegateAndroid::DevToolsManagerDelegateAndroid()
     : network_protocol_handler_(new DevToolsNetworkProtocolHandler()) {
   content::DevToolsAgentHost::AddObserver(this);
 }
 
 DevToolsManagerDelegateAndroid::~DevToolsManagerDelegateAndroid() {
   content::DevToolsAgentHost::RemoveObserver(this);
 }
 
 base::DictionaryValue* DevToolsManagerDelegateAndroid::HandleCommand(
     DevToolsAgentHost* agent_host,
     base::DictionaryValue* command_dict) {
   return network_protocol_handler_->HandleCommand(agent_host, command_dict);
 }
 
 std::string DevToolsManagerDelegateAndroid::GetTargetType(
     content::RenderFrameHost* host) {
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(host);
   TabAndroid* tab = web_contents ? TabAndroid::FromWebContents(web_contents)
       : nullptr;
   return tab ? DevToolsAgentHost::kTypePage :
       DevToolsAgentHost::kTypeOther;
 }
 
-bool DevToolsManagerDelegateAndroid::DiscoverTargets(
-      const DevToolsAgentHost::DiscoveryCallback& callback) {
-#if defined(OS_ANDROID)
+DevToolsAgentHost::List
+DevToolsManagerDelegateAndroid::RemoteDebuggingTargets() {
   // Enumerate existing tabs, including the ones with no WebContents.
   DevToolsAgentHost::List result;
   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;
 
       if (tab->web_contents())
         tab_web_contents.insert(tab->web_contents());
-
-      scoped_refptr<DevToolsAgentHost> host =
-          DevToolsAgentHost::Forward(
-              base::IntToString(tab->GetAndroidId()),
-              base::WrapUnique(new TabProxyDelegate(tab)));
-      result.push_back(host);
+      result.push_back(DevToolsAgentHostForTab(tab));
     }
   }
 
   // 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(*it);
   }
 
-  callback.Run(std::move(result));
-  return true;
-#else
-  return false;
-#endif  // defined(OS_ANDROID)
+  return result;
 }
 
 scoped_refptr<DevToolsAgentHost>
 DevToolsManagerDelegateAndroid::CreateNewTarget(const GURL& url) {
   if (TabModelList::empty())
     return nullptr;
 
   TabModel* tab_model = TabModelList::get(0);
   if (!tab_model)
     return nullptr;
 
   WebContents* web_contents = tab_model->CreateNewTabForDevTools(url);
   if (!web_contents)
     return nullptr;
 
   TabAndroid* tab = TabAndroid::FromWebContents(web_contents);
-  if (!tab)
-    return nullptr;
-
-  return DevToolsAgentHost::Forward(
-      base::IntToString(tab->GetAndroidId()),
-      base::WrapUnique(new TabProxyDelegate(tab)));
+  return tab ? DevToolsAgentHostForTab(tab) : nullptr;
 }
 
 std::string DevToolsManagerDelegateAndroid::GetDiscoveryPageHTML() {
   return ResourceBundle::GetSharedInstance().GetRawDataResource(
       IDR_DEVTOOLS_DISCOVERY_PAGE_HTML).as_string();
 }
 
 void DevToolsManagerDelegateAndroid::DevToolsAgentHostAttached(
     content::DevToolsAgentHost* agent_host) {
   network_protocol_handler_->DevToolsAgentStateChanged(agent_host, true);
 }
 
 void DevToolsManagerDelegateAndroid::DevToolsAgentHostDetached(
     content::DevToolsAgentHost* agent_host) {
   network_protocol_handler_->DevToolsAgentStateChanged(agent_host, false);
 }