chrome/browser/devtools/devtools_target_impl.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/devtools/devtools_target_impl.h"
   6
   7 #include "base/strings/stringprintf.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "chrome/browser/devtools/devtools_window.h"
  10 #include "chrome/browser/extensions/extension_tab_util.h"
  11 #include "chrome/browser/profiles/profile.h"
  12 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
  13 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
  14 #include "chrome/common/extensions/extension_constants.h"
  15 #include "content/public/browser/browser_thread.h"
  16 #include "content/public/browser/favicon_status.h"
  17 #include "content/public/browser/navigation_entry.h"
  18 #include "content/public/browser/render_frame_host.h"
  19 #include "content/public/browser/render_view_host.h"
  20 #include "content/public/browser/web_contents.h"
  21 #include "extensions/browser/extension_host.h"
  22 #include "extensions/browser/extension_registry.h"
  23 #include "extensions/browser/guest_view/guest_view_base.h"
  24 #include "extensions/browser/process_manager.h"
  25 #include "extensions/common/constants.h"
  26
  27 using content::BrowserThread;
  28 using content::DevToolsAgentHost;
  29 using content::RenderViewHost;
  30 using content::WebContents;
  31 using content::WorkerService;
  32
  33 const char DevToolsTargetImpl::kTargetTypeApp[] = "app";
  34 const char DevToolsTargetImpl::kTargetTypeBackgroundPage[] = "background_page";
  35 const char DevToolsTargetImpl::kTargetTypePage[] = "page";
  36 const char DevToolsTargetImpl::kTargetTypeWorker[] = "worker";
  37 const char DevToolsTargetImpl::kTargetTypeWebView[] = "webview";
  38 const char DevToolsTargetImpl::kTargetTypeIFrame[] = "iframe";
  39 const char DevToolsTargetImpl::kTargetTypeOther[] = "other";
  40 const char DevToolsTargetImpl::kTargetTypeServiceWorker[] = "service_worker";
  41
  42 namespace {
  43
  44 // WebContentsTarget --------------------------------------------------------
  45
  46 class WebContentsTarget : public DevToolsTargetImpl {
  47  public:
  48   WebContentsTarget(WebContents* web_contents, bool is_tab);
  49
  50   // DevToolsTargetImpl overrides:
  51   WebContents* GetWebContents() const override;
  52   int GetTabId() const override;
  53   std::string GetExtensionId() const override;
  54   void Inspect(Profile* profile) const override;
  55
  56  private:
  57   int tab_id_;
  58   std::string extension_id_;
  59 };
  60
  61 WebContentsTarget::WebContentsTarget(WebContents* web_contents, bool is_tab)
  62     : DevToolsTargetImpl(DevToolsAgentHost::GetOrCreateFor(web_contents)),
  63       tab_id_(-1) {
  64   set_type(kTargetTypeOther);
  65
  66   content::NavigationController& controller = web_contents->GetController();
  67   content::NavigationEntry* entry = controller.GetActiveEntry();
  68   if (entry != NULL && entry->GetURL().is_valid())
  69     set_favicon_url(entry->GetFavicon().url);
  70   set_last_activity_time(web_contents->GetLastActiveTime());
  71
  72   extensions::GuestViewBase* guest =
  73       extensions::GuestViewBase::FromWebContents(web_contents);
  74   WebContents* guest_contents = guest ? guest->embedder_web_contents() : NULL;
  75   if (guest_contents) {
  76     set_type(kTargetTypeWebView);
  77     set_parent_id(DevToolsAgentHost::GetOrCreateFor(guest_contents)->GetId());
  78     return;
  79   }
  80
  81   if (is_tab) {
  82     set_type(kTargetTypePage);
  83     tab_id_ = extensions::ExtensionTabUtil::GetTabId(web_contents);
  84     return;
  85   }
  86
  87   const extensions::Extension* extension = extensions::ExtensionRegistry::Get(
  88       web_contents->GetBrowserContext())->enabled_extensions().GetByID(
  89           GetURL().host());
  90   if (!extension)
  91     return;
  92
  93   Profile* profile =
  94       Profile::FromBrowserContext(web_contents->GetBrowserContext());
  95   if (!profile)
  96     return;
  97   set_title(extension->name());
  98   extensions::ExtensionHost* extension_host =
  99       extensions::ProcessManager::Get(profile)
 100           ->GetBackgroundHostForExtension(extension->id());
 101   if (extension_host &&
 102       extension_host->host_contents() == web_contents) {
 103     set_type(kTargetTypeBackgroundPage);
 104     extension_id_ = extension->id();
 105   } else if (extension->is_hosted_app()
 106              || extension->is_legacy_packaged_app()
 107              || extension->is_platform_app()) {
 108     set_type(kTargetTypeApp);
 109   }
 110   set_favicon_url(extensions::ExtensionIconSource::GetIconURL(
 111       extension, extension_misc::EXTENSION_ICON_SMALLISH,
 112       ExtensionIconSet::MATCH_BIGGER, false, NULL));
 113 }
 114
 115 WebContents* WebContentsTarget::GetWebContents() const {
 116   return GetAgentHost()->GetWebContents();
 117 }
 118
 119 int WebContentsTarget::GetTabId() const {
 120   return tab_id_;
 121 }
 122
 123 std::string WebContentsTarget::GetExtensionId() const {
 124   return extension_id_;
 125 }
 126
 127 void WebContentsTarget::Inspect(Profile* profile) const {
 128   WebContents* web_contents = GetWebContents();
 129   if (!web_contents)
 130     return;
 131   DevToolsWindow::OpenDevToolsWindow(web_contents);
 132 }
 133
 134 // FrameTarget ----------------------------------------------------------------
 135
 136 class FrameTarget : public DevToolsTargetImpl {
 137  public:
 138   explicit FrameTarget(scoped_refptr<DevToolsAgentHost> agent_host);
 139
 140   // DevToolsTargetImpl overrides:
 141   void Inspect(Profile* profile) const override;
 142 };
 143
 144 FrameTarget::FrameTarget(scoped_refptr<DevToolsAgentHost> agent_host)
 145     : DevToolsTargetImpl(agent_host) {
 146   set_type(kTargetTypePage);
 147   WebContents* wc = agent_host->GetWebContents();
 148   DCHECK(DevToolsAgentHost::GetOrCreateFor(wc).get() != agent_host.get());
 149   set_parent_id(DevToolsAgentHost::GetOrCreateFor(wc)->GetId());
 150 }
 151
 152 void FrameTarget::Inspect(Profile* profile) const {
 153   DevToolsWindow::OpenDevToolsWindow(profile, GetAgentHost());
 154 }
 155
 156 // WorkerTarget ----------------------------------------------------------------
 157
 158 class WorkerTarget : public DevToolsTargetImpl {
 159  public:
 160   explicit WorkerTarget(scoped_refptr<DevToolsAgentHost> agent_host);
 161
 162   // DevToolsTargetImpl overrides:
 163   void Inspect(Profile* profile) const override;
 164 };
 165
 166 WorkerTarget::WorkerTarget(scoped_refptr<DevToolsAgentHost> agent_host)
 167     : DevToolsTargetImpl(agent_host) {
 168   switch (agent_host->GetType()) {
 169     case DevToolsAgentHost::TYPE_SHARED_WORKER:
 170       set_type(kTargetTypeWorker);
 171       break;
 172     case DevToolsAgentHost::TYPE_SERVICE_WORKER:
 173       set_type(kTargetTypeServiceWorker);
 174       break;
 175     default:
 176       NOTREACHED();
 177   }
 178 }
 179
 180 void WorkerTarget::Inspect(Profile* profile) const {
 181   DevToolsWindow::OpenDevToolsWindowForWorker(profile, GetAgentHost());
 182 }
 183
 184 }  // namespace
 185
 186 // DevToolsTargetImpl ----------------------------------------------------------
 187
 188 DevToolsTargetImpl::~DevToolsTargetImpl() {
 189 }
 190
 191 DevToolsTargetImpl::DevToolsTargetImpl(
 192     scoped_refptr<DevToolsAgentHost> agent_host)
 193     : agent_host_(agent_host),
 194       title_(agent_host->GetTitle()),
 195       url_(agent_host->GetURL()) {
 196 }
 197
 198 std::string DevToolsTargetImpl::GetParentId() const {
 199   return parent_id_;
 200 }
 201
 202 std::string DevToolsTargetImpl::GetId() const {
 203   return agent_host_->GetId();
 204 }
 205
 206 std::string DevToolsTargetImpl::GetType() const {
 207   return type_;
 208 }
 209
 210 std::string DevToolsTargetImpl::GetTitle() const {
 211   return title_;
 212 }
 213
 214 std::string DevToolsTargetImpl::GetDescription() const {
 215   return description_;
 216 }
 217
 218 GURL DevToolsTargetImpl::GetURL() const {
 219   return url_;
 220 }
 221
 222 GURL DevToolsTargetImpl::GetFaviconURL() const {
 223   return favicon_url_;
 224 }
 225
 226 base::TimeTicks DevToolsTargetImpl::GetLastActivityTime() const {
 227   return last_activity_time_;
 228 }
 229
 230 scoped_refptr<content::DevToolsAgentHost>
 231 DevToolsTargetImpl::GetAgentHost() const {
 232   return agent_host_;
 233 }
 234
 235 bool DevToolsTargetImpl::IsAttached() const {
 236   return agent_host_->IsAttached();
 237 }
 238
 239 bool DevToolsTargetImpl::Activate() const {
 240   return agent_host_->Activate();
 241 }
 242
 243 bool DevToolsTargetImpl::Close() const {
 244   return agent_host_->Close();
 245 }
 246
 247 int DevToolsTargetImpl::GetTabId() const {
 248   return -1;
 249 }
 250
 251 WebContents* DevToolsTargetImpl::GetWebContents() const {
 252   return NULL;
 253 }
 254
 255 std::string DevToolsTargetImpl::GetExtensionId() const {
 256   return std::string();
 257 }
 258
 259 void DevToolsTargetImpl::Inspect(Profile* /*profile*/) const {
 260 }
 261
 262 void DevToolsTargetImpl::Reload() const {
 263 }
 264
 265 // static
 266 scoped_ptr<DevToolsTargetImpl> DevToolsTargetImpl::CreateForWebContents(
 267     content::WebContents* web_contents,
 268     bool is_tab) {
 269   return scoped_ptr<DevToolsTargetImpl>(
 270       new WebContentsTarget(web_contents, is_tab));
 271 }
 272
 273 // static
 274 void DevToolsTargetImpl::EnumerateAllTargets(Callback callback) {
 275   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 276
 277   std::set<WebContents*> tab_web_contents;
 278   for (TabContentsIterator it; !it.done(); it.Next())
 279     tab_web_contents.insert(*it);
 280
 281   DevToolsTargetImpl::List result;
 282   DevToolsAgentHost::List agents = DevToolsAgentHost::GetOrCreateAll();
 283   for (DevToolsAgentHost::List::iterator it = agents.begin();
 284        it != agents.end(); ++it) {
 285     DevToolsAgentHost* agent_host = (*it).get();
 286     switch (agent_host->GetType()) {
 287       case DevToolsAgentHost::TYPE_WEB_CONTENTS:
 288         if (WebContents* web_contents = agent_host->GetWebContents()) {
 289           const bool is_tab =
 290               tab_web_contents.find(web_contents) != tab_web_contents.end();
 291           result.push_back(new WebContentsTarget(web_contents, is_tab));
 292         }
 293         break;
 294       case DevToolsAgentHost::TYPE_FRAME:
 295         result.push_back(new FrameTarget(agent_host));
 296         break;
 297       case DevToolsAgentHost::TYPE_SHARED_WORKER:
 298         result.push_back(new WorkerTarget(agent_host));
 299         break;
 300       case DevToolsAgentHost::TYPE_SERVICE_WORKER:
 301         result.push_back(new WorkerTarget(agent_host));
 302         break;
 303       default:
 304         break;
 305     }
 306   }
 307
 308   callback.Run(result);
 309 }