[DevTools] Calculate target type and title once in constructor

chrome/browser/devtools/chrome_devtools_manager_delegate.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/chrome_devtools_manager_delegate.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/devtools/device/android_device_manager.h"
@@ skipping 16 matching lines @@
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/process_manager.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::DevToolsAgentHost;
 
 char ChromeDevToolsManagerDelegate::kTypeApp[] = "app";
 char ChromeDevToolsManagerDelegate::kTypeBackgroundPage[] = "background_page";
 char ChromeDevToolsManagerDelegate::kTypeWebView[] = "webview";
 
+namespace {
+
 char kLocationsParam[] = "locations";
 char kHostParam[] = "host";
 char kPortParam[] = "port";
 
+bool GetExtensionInfo(content::RenderFrameHost* host,
+                      std::string* name,
+                      std::string* type) {
+  content::WebContents* wc = content::WebContents::FromRenderFrameHost(host);
+  if (!wc)
+    return false;
+  Profile* profile = Profile::FromBrowserContext(wc->GetBrowserContext());
+  if (!profile)
+    return false;
+  const extensions::Extension* extension =
+      extensions::ProcessManager::Get(profile)->GetExtensionForRenderFrameHost(
+          host);
+  if (!extension)
+    return false;
+  extensions::ExtensionHost* extension_host =
+      extensions::ProcessManager::Get(profile)->GetBackgroundHostForExtension(
+          extension->id());
+  if (extension_host && extension_host->host_contents() == wc) {
+    *name = extension->name();
+    *type = ChromeDevToolsManagerDelegate::kTypeBackgroundPage;
+    return true;
+  } else if (extension->is_hosted_app() ||
+             extension->is_legacy_packaged_app() ||
+             extension->is_platform_app()) {
+    *name = extension->name();
+    *type = ChromeDevToolsManagerDelegate::kTypeApp;
+    return true;
+  }
+  return false;
+}
+
+}  // namespace
+
 class ChromeDevToolsManagerDelegate::HostData {
  public:
   HostData() {}
   ~HostData() {}
 
   RemoteLocations& remote_locations() { return remote_locations_; }
 
   void set_remote_locations(RemoteLocations& locations) {
     remote_locations_.swap(locations);
   }
@@ skipping 45 matching lines @@
     return kTypeWebView;
 
   if (host->GetParent())
     return DevToolsAgentHost::kTypeFrame;
 
   for (TabContentsIterator it; !it.done(); it.Next()) {
     if (*it == web_contents)
       return DevToolsAgentHost::kTypePage;
   }
 
-  const extensions::Extension* extension = extensions::ExtensionRegistry::Get(
-      web_contents->GetBrowserContext())->enabled_extensions().GetByID(
-          host->GetLastCommittedURL().host());
-  if (!extension)
+  std::string extension_name;
+  std::string extension_type;
+  if (!GetExtensionInfo(host, &extension_name, &extension_type))
     return DevToolsAgentHost::kTypeOther;
-
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents->GetBrowserContext());
-  if (!profile)
-    return DevToolsAgentHost::kTypeOther;
-
-  extensions::ExtensionHost* extension_host =
-      extensions::ProcessManager::Get(profile)
-          ->GetBackgroundHostForExtension(extension->id());
-  if (extension_host &&
-      extension_host->host_contents() == web_contents) {
-    return kTypeBackgroundPage;
-  } else if (extension->is_hosted_app()
-             || extension->is_legacy_packaged_app()
-             || extension->is_platform_app()) {
-    return kTypeApp;
-  }
-  return DevToolsAgentHost::kTypeOther;
+  return extension_type;
 }
 
 std::string ChromeDevToolsManagerDelegate::GetTargetTitle(
     content::RenderFrameHost* host) {
-  content::WebContents* web_contents =
-      content::WebContents::FromRenderFrameHost(host);
-  if (host->GetParent())
-    return host->GetLastCommittedURL().spec();
-  for (TabContentsIterator it; !it.done(); it.Next()) {
-    if (*it == web_contents)
-      return base::UTF16ToUTF8(web_contents->GetTitle());
-  }
-  const extensions::Extension* extension = extensions::ExtensionRegistry::Get(
-    web_contents->GetBrowserContext())->enabled_extensions().GetByID(
-          host->GetLastCommittedURL().host());
-  if (extension)
-    return extension->name();
-  return "";
+  std::string extension_name;
+  std::string extension_type;
+  if (!GetExtensionInfo(host, &extension_name, &extension_type))
+    return std::string();
+  return extension_name;
 }
 
 scoped_refptr<DevToolsAgentHost>
 ChromeDevToolsManagerDelegate::CreateNewTarget(const GURL& url) {
   chrome::NavigateParams params(ProfileManager::GetLastUsedProfile(),
       url, ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
   params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
   if (!params.target_contents)
     return nullptr;
@@ skipping 116 matching lines @@
     tcp_locations.insert(net::HostPortPair(host, port));
   }
 
   host_data_[agent_host]->set_remote_locations(tcp_locations);
   UpdateDeviceDiscovery();
 
   std::unique_ptr<base::DictionaryValue> result(
       base::MakeUnique<base::DictionaryValue>());
   return DevToolsProtocol::CreateSuccessResponse(command_id, std::move(result));
 }