[DevTools] Migrate chrome to devtools_discovery.

chrome/browser/devtools/devtools_target_impl.cc

 // Copyright 2013 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/devtools_target_impl.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_frame_host.h"
-#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/guest_view/guest_view_base.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/common/constants.h"
 
 using content::BrowserThread;
 using content::DevToolsAgentHost;
-using content::RenderViewHost;
 using content::WebContents;
-using content::WorkerService;
 
 const char DevToolsTargetImpl::kTargetTypeApp[] = "app";
 const char DevToolsTargetImpl::kTargetTypeBackgroundPage[] = "background_page";
 const char DevToolsTargetImpl::kTargetTypePage[] = "page";
 const char DevToolsTargetImpl::kTargetTypeWorker[] = "worker";
 const char DevToolsTargetImpl::kTargetTypeWebView[] = "webview";
 const char DevToolsTargetImpl::kTargetTypeIFrame[] = "iframe";
 const char DevToolsTargetImpl::kTargetTypeOther[] = "other";
 const char DevToolsTargetImpl::kTargetTypeServiceWorker[] = "service_worker";
 
 namespace {
 
 // WebContentsTarget --------------------------------------------------------
 
 class WebContentsTarget : public DevToolsTargetImpl {
  public:
   WebContentsTarget(WebContents* web_contents, bool is_tab);
 
-  // DevToolsTargetImpl overrides:
-  WebContents* GetWebContents() const override;
+  // DevToolsTargetImpl overrides.
   int GetTabId() const override;
   std::string GetExtensionId() const override;
   void Inspect(Profile* profile) const override;
 
  private:
   int tab_id_;
   std::string extension_id_;
 };
 
 WebContentsTarget::WebContentsTarget(WebContents* web_contents, bool is_tab)
     : DevToolsTargetImpl(DevToolsAgentHost::GetOrCreateFor(web_contents)),
       tab_id_(-1) {
   set_type(kTargetTypeOther);
 
-  content::NavigationController& controller = web_contents->GetController();
-  content::NavigationEntry* entry = controller.GetActiveEntry();
-  if (entry != NULL && entry->GetURL().is_valid())
-    set_favicon_url(entry->GetFavicon().url);
-  set_last_activity_time(web_contents->GetLastActiveTime());
-
   extensions::GuestViewBase* guest =
       extensions::GuestViewBase::FromWebContents(web_contents);
   WebContents* guest_contents = guest ? guest->embedder_web_contents() : NULL;
   if (guest_contents) {
     set_type(kTargetTypeWebView);
     set_parent_id(DevToolsAgentHost::GetOrCreateFor(guest_contents)->GetId());
     return;
   }
 
   if (is_tab) {
@@ skipping 23 matching lines @@
   } else if (extension->is_hosted_app()
              || extension->is_legacy_packaged_app()
              || extension->is_platform_app()) {
     set_type(kTargetTypeApp);
   }
   set_favicon_url(extensions::ExtensionIconSource::GetIconURL(
       extension, extension_misc::EXTENSION_ICON_SMALLISH,
       ExtensionIconSet::MATCH_BIGGER, false, NULL));
 }
 
-WebContents* WebContentsTarget::GetWebContents() const {
-  return GetAgentHost()->GetWebContents();
-}
-
 int WebContentsTarget::GetTabId() const {
   return tab_id_;
 }
 
 std::string WebContentsTarget::GetExtensionId() const {
   return extension_id_;
 }
 
 void WebContentsTarget::Inspect(Profile* profile) const {
   WebContents* web_contents = GetWebContents();
@@ skipping 54 matching lines @@
 
 }  // namespace
 
 // DevToolsTargetImpl ----------------------------------------------------------
 
 DevToolsTargetImpl::~DevToolsTargetImpl() {
 }
 
 DevToolsTargetImpl::DevToolsTargetImpl(
     scoped_refptr<DevToolsAgentHost> agent_host)
-    : agent_host_(agent_host),
-      title_(agent_host->GetTitle()),
-      url_(agent_host->GetURL()) {
-}
-
-std::string DevToolsTargetImpl::GetParentId() const {
-  return parent_id_;
-}
-
-std::string DevToolsTargetImpl::GetId() const {
-  return agent_host_->GetId();
-}
-
-std::string DevToolsTargetImpl::GetType() const {
-  return type_;
-}
-
-std::string DevToolsTargetImpl::GetTitle() const {
-  return title_;
-}
-
-std::string DevToolsTargetImpl::GetDescription() const {
-  return description_;
-}
-
-GURL DevToolsTargetImpl::GetURL() const {
-  return url_;
-}
-
-GURL DevToolsTargetImpl::GetFaviconURL() const {
-  return favicon_url_;
-}
-
-base::TimeTicks DevToolsTargetImpl::GetLastActivityTime() const {
-  return last_activity_time_;
-}
-
-scoped_refptr<content::DevToolsAgentHost>
-DevToolsTargetImpl::GetAgentHost() const {
-  return agent_host_;
-}
-
-bool DevToolsTargetImpl::IsAttached() const {
-  return agent_host_->IsAttached();
-}
-
-bool DevToolsTargetImpl::Activate() const {
-  return agent_host_->Activate();
-}
-
-bool DevToolsTargetImpl::Close() const {
-  return agent_host_->Close();
+    : devtools_discovery::BasicTargetDescriptor(agent_host) {
 }
 
 int DevToolsTargetImpl::GetTabId() const {
   return -1;
 }
 
 WebContents* DevToolsTargetImpl::GetWebContents() const {
-  return NULL;
+  return GetAgentHost()->GetWebContents();
 }
 
 std::string DevToolsTargetImpl::GetExtensionId() const {
   return std::string();
 }
 
 void DevToolsTargetImpl::Inspect(Profile* /*profile*/) const {
 }
 
 void DevToolsTargetImpl::Reload() const {
 }
 
 // static
-scoped_ptr<DevToolsTargetImpl> DevToolsTargetImpl::CreateForWebContents(
-    content::WebContents* web_contents,
-    bool is_tab) {
+scoped_ptr<DevToolsTargetImpl> DevToolsTargetImpl::CreateForTab(
+    content::WebContents* web_contents) {
   return scoped_ptr<DevToolsTargetImpl>(
-      new WebContentsTarget(web_contents, is_tab));
+      new WebContentsTarget(web_contents, true));
 }
 
 // static
-void DevToolsTargetImpl::EnumerateAllTargets(Callback callback) {
+std::vector<DevToolsTargetImpl*> DevToolsTargetImpl::EnumerateAll() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::set<WebContents*> tab_web_contents;
   for (TabContentsIterator it; !it.done(); it.Next())
     tab_web_contents.insert(*it);
 
-  DevToolsTargetImpl::List result;
+  std::vector<DevToolsTargetImpl*> result;
   DevToolsAgentHost::List agents = DevToolsAgentHost::GetOrCreateAll();
   for (DevToolsAgentHost::List::iterator it = agents.begin();
        it != agents.end(); ++it) {
     DevToolsAgentHost* agent_host = (*it).get();
     switch (agent_host->GetType()) {
       case DevToolsAgentHost::TYPE_WEB_CONTENTS:
         if (WebContents* web_contents = agent_host->GetWebContents()) {
           const bool is_tab =
               tab_web_contents.find(web_contents) != tab_web_contents.end();
           result.push_back(new WebContentsTarget(web_contents, is_tab));
         }
         break;
       case DevToolsAgentHost::TYPE_FRAME:
         result.push_back(new FrameTarget(agent_host));
         break;
       case DevToolsAgentHost::TYPE_SHARED_WORKER:
         result.push_back(new WorkerTarget(agent_host));
         break;
       case DevToolsAgentHost::TYPE_SERVICE_WORKER:
         result.push_back(new WorkerTarget(agent_host));
         break;
       default:
         break;
     }
   }
-
-  callback.Run(result);
+  return result;
 }