src/extensions/browser/extension_host.cc

   1 // Copyright 2014 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 "extensions/browser/extension_host.h"
   6
   7 #include <list>
   8
   9 #include "base/bind.h"
  10 #include "base/logging.h"
  11 #include "base/memory/singleton.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/metrics/histogram.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "chrome/browser/chrome_notification_types.h"
  18 #include "content/public/browser/browser_context.h"
  19 #include "content/public/browser/content_browser_client.h"
  20 #include "content/public/browser/native_web_keyboard_event.h"
  21 #include "content/public/browser/notification_service.h"
  22 #include "content/public/browser/notification_source.h"
  23 #include "content/public/browser/notification_types.h"
  24 #include "content/public/browser/render_process_host.h"
  25 #include "content/public/browser/render_view_host.h"
  26 #include "content/public/browser/render_widget_host_view.h"
  27 #include "content/public/browser/site_instance.h"
  28 #include "content/public/browser/web_contents.h"
  29 #include "extensions/browser/event_router.h"
  30 #include "extensions/browser/extension_error.h"
  31 #include "extensions/browser/extension_host_delegate.h"
  32 #include "extensions/browser/extension_system.h"
  33 #include "extensions/browser/extensions_browser_client.h"
  34 #include "extensions/browser/process_manager.h"
  35 #include "extensions/browser/runtime_data.h"
  36 #include "extensions/browser/view_type_utils.h"
  37 #include "extensions/common/extension.h"
  38 #include "extensions/common/extension_messages.h"
  39 #include "extensions/common/extension_urls.h"
  40 #include "extensions/common/feature_switch.h"
  41 #include "extensions/common/manifest_handlers/background_info.h"
  42 #include "ui/base/l10n/l10n_util.h"
  43 #include "ui/base/window_open_disposition.h"
  44
  45 using content::BrowserContext;
  46 using content::OpenURLParams;
  47 using content::RenderProcessHost;
  48 using content::RenderViewHost;
  49 using content::SiteInstance;
  50 using content::WebContents;
  51
  52 namespace extensions {
  53
  54 // Helper class that rate-limits the creation of renderer processes for
  55 // ExtensionHosts, to avoid blocking the UI.
  56 class ExtensionHost::ProcessCreationQueue {
  57  public:
  58   static ProcessCreationQueue* GetInstance() {
  59     return Singleton<ProcessCreationQueue>::get();
  60   }
  61
  62   // Add a host to the queue for RenderView creation.
  63   void CreateSoon(ExtensionHost* host) {
  64     queue_.push_back(host);
  65     PostTask();
  66   }
  67
  68   // Remove a host from the queue (in case it's being deleted).
  69   void Remove(ExtensionHost* host) {
  70     Queue::iterator it = std::find(queue_.begin(), queue_.end(), host);
  71     if (it != queue_.end())
  72       queue_.erase(it);
  73   }
  74
  75  private:
  76   friend class Singleton<ProcessCreationQueue>;
  77   friend struct DefaultSingletonTraits<ProcessCreationQueue>;
  78   ProcessCreationQueue()
  79       : pending_create_(false),
  80         ptr_factory_(this) {}
  81
  82   // Queue up a delayed task to process the next ExtensionHost in the queue.
  83   void PostTask() {
  84     if (!pending_create_) {
  85       base::MessageLoop::current()->PostTask(FROM_HERE,
  86           base::Bind(&ProcessCreationQueue::ProcessOneHost,
  87                      ptr_factory_.GetWeakPtr()));
  88       pending_create_ = true;
  89     }
  90   }
  91
  92   // Create the RenderView for the next host in the queue.
  93   void ProcessOneHost() {
  94     pending_create_ = false;
  95     if (queue_.empty())
  96       return;  // can happen on shutdown
  97
  98     queue_.front()->CreateRenderViewNow();
  99     queue_.pop_front();
 100
 101     if (!queue_.empty())
 102       PostTask();
 103   }
 104
 105   typedef std::list<ExtensionHost*> Queue;
 106   Queue queue_;
 107   bool pending_create_;
 108   base::WeakPtrFactory<ProcessCreationQueue> ptr_factory_;
 109 };
 110
 111 ////////////////
 112 // ExtensionHost
 113
 114 ExtensionHost::ExtensionHost(const Extension* extension,
 115                              SiteInstance* site_instance,
 116                              const GURL& url,
 117                              ViewType host_type)
 118     : delegate_(ExtensionsBrowserClient::Get()->CreateExtensionHostDelegate()),
 119       extension_(extension),
 120       extension_id_(extension->id()),
 121       browser_context_(site_instance->GetBrowserContext()),
 122       render_view_host_(NULL),
 123       did_stop_loading_(false),
 124       document_element_available_(false),
 125       initial_url_(url),
 126       extension_function_dispatcher_(browser_context_, this),
 127       extension_host_type_(host_type) {
 128   // Not used for panels, see PanelHost.
 129   DCHECK(host_type == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE ||
 130          host_type == VIEW_TYPE_EXTENSION_DIALOG ||
 131          host_type == VIEW_TYPE_EXTENSION_INFOBAR ||
 132          host_type == VIEW_TYPE_EXTENSION_POPUP);
 133   host_contents_.reset(WebContents::Create(
 134       WebContents::CreateParams(browser_context_, site_instance))),
 135   content::WebContentsObserver::Observe(host_contents_.get());
 136   host_contents_->SetDelegate(this);
 137   SetViewType(host_contents_.get(), host_type);
 138
 139   render_view_host_ = host_contents_->GetRenderViewHost();
 140
 141   // Listen for when an extension is unloaded from the same profile, as it may
 142   // be the same extension that this points to.
 143   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
 144                  content::Source<BrowserContext>(browser_context_));
 145
 146   // Set up web contents observers and pref observers.
 147   delegate_->OnExtensionHostCreated(host_contents());
 148 }
 149
 150 ExtensionHost::~ExtensionHost() {
 151   if (extension_host_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE &&
 152       extension_ && BackgroundInfo::HasLazyBackgroundPage(extension_)) {
 153     UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageActiveTime",
 154                              since_created_.Elapsed());
 155   }
 156   content::NotificationService::current()->Notify(
 157       chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
 158       content::Source<BrowserContext>(browser_context_),
 159       content::Details<ExtensionHost>(this));
 160   ProcessCreationQueue::GetInstance()->Remove(this);
 161 }
 162
 163 content::RenderProcessHost* ExtensionHost::render_process_host() const {
 164   return render_view_host()->GetProcess();
 165 }
 166
 167 RenderViewHost* ExtensionHost::render_view_host() const {
 168   // TODO(mpcomplete): This can be NULL. How do we handle that?
 169   return render_view_host_;
 170 }
 171
 172 bool ExtensionHost::IsRenderViewLive() const {
 173   return render_view_host()->IsRenderViewLive();
 174 }
 175
 176 void ExtensionHost::CreateRenderViewSoon() {
 177   if ((render_process_host() && render_process_host()->HasConnection())) {
 178     // If the process is already started, go ahead and initialize the RenderView
 179     // synchronously. The process creation is the real meaty part that we want
 180     // to defer.
 181     CreateRenderViewNow();
 182   } else {
 183     ProcessCreationQueue::GetInstance()->CreateSoon(this);
 184   }
 185 }
 186
 187 void ExtensionHost::CreateRenderViewNow() {
 188   LoadInitialURL();
 189   if (IsBackgroundPage()) {
 190     DCHECK(IsRenderViewLive());
 191     // Connect orphaned dev-tools instances.
 192     delegate_->OnRenderViewCreatedForBackgroundPage(this);
 193   }
 194 }
 195
 196 const GURL& ExtensionHost::GetURL() const {
 197   return host_contents()->GetURL();
 198 }
 199
 200 void ExtensionHost::LoadInitialURL() {
 201   host_contents_->GetController().LoadURL(
 202       initial_url_, content::Referrer(), content::PAGE_TRANSITION_LINK,
 203       std::string());
 204 }
 205
 206 bool ExtensionHost::IsBackgroundPage() const {
 207   DCHECK(extension_host_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
 208   return true;
 209 }
 210
 211 void ExtensionHost::Close() {
 212   content::NotificationService::current()->Notify(
 213       chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
 214       content::Source<BrowserContext>(browser_context_),
 215       content::Details<ExtensionHost>(this));
 216 }
 217
 218 void ExtensionHost::Observe(int type,
 219                             const content::NotificationSource& source,
 220                             const content::NotificationDetails& details) {
 221   switch (type) {
 222     case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED:
 223       // The extension object will be deleted after this notification has been
 224       // sent. NULL it out so that dirty pointer issues don't arise in cases
 225       // when multiple ExtensionHost objects pointing to the same Extension are
 226       // present.
 227       if (extension_ == content::Details<UnloadedExtensionInfo>(details)->
 228           extension) {
 229         extension_ = NULL;
 230       }
 231       break;
 232     default:
 233       NOTREACHED() << "Unexpected notification sent.";
 234       break;
 235   }
 236 }
 237
 238 void ExtensionHost::RenderProcessGone(base::TerminationStatus status) {
 239   // During browser shutdown, we may use sudden termination on an extension
 240   // process, so it is expected to lose our connection to the render view.
 241   // Do nothing.
 242   RenderProcessHost* process_host = host_contents_->GetRenderProcessHost();
 243   if (process_host && process_host->FastShutdownStarted())
 244     return;
 245
 246   // In certain cases, multiple ExtensionHost objects may have pointed to
 247   // the same Extension at some point (one with a background page and a
 248   // popup, for example). When the first ExtensionHost goes away, the extension
 249   // is unloaded, and any other host that pointed to that extension will have
 250   // its pointer to it NULLed out so that any attempt to unload a dirty pointer
 251   // will be averted.
 252   if (!extension_)
 253     return;
 254
 255   // TODO(aa): This is suspicious. There can be multiple views in an extension,
 256   // and they aren't all going to use ExtensionHost. This should be in someplace
 257   // more central, like EPM maybe.
 258   content::NotificationService::current()->Notify(
 259       chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
 260       content::Source<BrowserContext>(browser_context_),
 261       content::Details<ExtensionHost>(this));
 262 }
 263
 264 void ExtensionHost::DidStopLoading(content::RenderViewHost* render_view_host) {
 265   bool notify = !did_stop_loading_;
 266   did_stop_loading_ = true;
 267   OnDidStopLoading();
 268   if (notify) {
 269     if (extension_host_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
 270       if (extension_ && BackgroundInfo::HasLazyBackgroundPage(extension_)) {
 271         UMA_HISTOGRAM_TIMES("Extensions.EventPageLoadTime",
 272                             since_created_.Elapsed());
 273       } else {
 274         UMA_HISTOGRAM_TIMES("Extensions.BackgroundPageLoadTime",
 275                             since_created_.Elapsed());
 276       }
 277     } else if (extension_host_type_ == VIEW_TYPE_EXTENSION_DIALOG) {
 278       UMA_HISTOGRAM_TIMES("Extensions.DialogLoadTime",
 279                           since_created_.Elapsed());
 280     } else if (extension_host_type_ == VIEW_TYPE_EXTENSION_POPUP) {
 281       UMA_HISTOGRAM_TIMES("Extensions.PopupLoadTime",
 282                           since_created_.Elapsed());
 283     } else if (extension_host_type_ == VIEW_TYPE_EXTENSION_INFOBAR) {
 284       UMA_HISTOGRAM_TIMES("Extensions.InfobarLoadTime",
 285         since_created_.Elapsed());
 286     }
 287
 288     // Send the notification last, because it might result in this being
 289     // deleted.
 290     content::NotificationService::current()->Notify(
 291         chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
 292         content::Source<BrowserContext>(browser_context_),
 293         content::Details<ExtensionHost>(this));
 294   }
 295 }
 296
 297 void ExtensionHost::OnDidStopLoading() {
 298   DCHECK(extension_host_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
 299   // Nothing to do for background pages.
 300 }
 301
 302 void ExtensionHost::DocumentAvailableInMainFrame() {
 303   // If the document has already been marked as available for this host, then
 304   // bail. No need for the redundant setup. http://crbug.com/31170
 305   if (document_element_available_)
 306     return;
 307   document_element_available_ = true;
 308   OnDocumentAvailable();
 309 }
 310
 311 void ExtensionHost::OnDocumentAvailable() {
 312   DCHECK(extension_host_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
 313   ExtensionSystem::Get(browser_context_)
 314       ->runtime_data()
 315       ->SetBackgroundPageReady(extension_, true);
 316   content::NotificationService::current()->Notify(
 317       chrome::NOTIFICATION_EXTENSION_BACKGROUND_PAGE_READY,
 318       content::Source<const Extension>(extension_),
 319       content::NotificationService::NoDetails());
 320 }
 321
 322 void ExtensionHost::CloseContents(WebContents* contents) {
 323   Close();
 324 }
 325
 326 bool ExtensionHost::OnMessageReceived(const IPC::Message& message) {
 327   bool handled = true;
 328   IPC_BEGIN_MESSAGE_MAP(ExtensionHost, message)
 329     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
 330     IPC_MESSAGE_HANDLER(ExtensionHostMsg_EventAck, OnEventAck)
 331     IPC_MESSAGE_HANDLER(ExtensionHostMsg_IncrementLazyKeepaliveCount,
 332                         OnIncrementLazyKeepaliveCount)
 333     IPC_MESSAGE_HANDLER(ExtensionHostMsg_DecrementLazyKeepaliveCount,
 334                         OnDecrementLazyKeepaliveCount)
 335     IPC_MESSAGE_UNHANDLED(handled = false)
 336   IPC_END_MESSAGE_MAP()
 337   return handled;
 338 }
 339
 340 void ExtensionHost::OnRequest(const ExtensionHostMsg_Request_Params& params) {
 341   extension_function_dispatcher_.Dispatch(params, render_view_host());
 342 }
 343
 344 void ExtensionHost::OnEventAck() {
 345   EventRouter* router = EventRouter::Get(browser_context_);
 346   if (router)
 347     router->OnEventAck(browser_context_, extension_id());
 348 }
 349
 350 void ExtensionHost::OnIncrementLazyKeepaliveCount() {
 351   ProcessManager* pm = ExtensionSystem::Get(
 352       browser_context_)->process_manager();
 353   if (pm)
 354     pm->IncrementLazyKeepaliveCount(extension());
 355 }
 356
 357 void ExtensionHost::OnDecrementLazyKeepaliveCount() {
 358   ProcessManager* pm = ExtensionSystem::Get(
 359       browser_context_)->process_manager();
 360   if (pm)
 361     pm->DecrementLazyKeepaliveCount(extension());
 362 }
 363
 364 // content::WebContentsObserver
 365
 366 void ExtensionHost::RenderViewCreated(RenderViewHost* render_view_host) {
 367   render_view_host_ = render_view_host;
 368 }
 369
 370 void ExtensionHost::RenderViewDeleted(RenderViewHost* render_view_host) {
 371   // If our RenderViewHost is deleted, fall back to the host_contents' current
 372   // RVH. There is sometimes a small gap between the pending RVH being deleted
 373   // and RenderViewCreated being called, so we update it here.
 374   if (render_view_host == render_view_host_)
 375     render_view_host_ = host_contents_->GetRenderViewHost();
 376 }
 377
 378 content::JavaScriptDialogManager* ExtensionHost::GetJavaScriptDialogManager() {
 379   return delegate_->GetJavaScriptDialogManager();
 380 }
 381
 382 void ExtensionHost::AddNewContents(WebContents* source,
 383                                    WebContents* new_contents,
 384                                    WindowOpenDisposition disposition,
 385                                    const gfx::Rect& initial_pos,
 386                                    bool user_gesture,
 387                                    bool* was_blocked) {
 388   // First, if the creating extension view was associated with a tab contents,
 389   // use that tab content's delegate. We must be careful here that the
 390   // associated tab contents has the same profile as the new tab contents. In
 391   // the case of extensions in 'spanning' incognito mode, they can mismatch.
 392   // We don't want to end up putting a normal tab into an incognito window, or
 393   // vice versa.
 394   // Note that we don't do this for popup windows, because we need to associate
 395   // those with their extension_app_id.
 396   if (disposition != NEW_POPUP) {
 397     WebContents* associated_contents = GetAssociatedWebContents();
 398     if (associated_contents &&
 399         associated_contents->GetBrowserContext() ==
 400             new_contents->GetBrowserContext()) {
 401       WebContentsDelegate* delegate = associated_contents->GetDelegate();
 402       if (delegate) {
 403         delegate->AddNewContents(
 404             associated_contents, new_contents, disposition, initial_pos,
 405             user_gesture, was_blocked);
 406         return;
 407       }
 408     }
 409   }
 410
 411   delegate_->CreateTab(
 412       new_contents, extension_id_, disposition, initial_pos, user_gesture);
 413 }
 414
 415 void ExtensionHost::RenderViewReady() {
 416   content::NotificationService::current()->Notify(
 417       chrome::NOTIFICATION_EXTENSION_HOST_CREATED,
 418       content::Source<BrowserContext>(browser_context_),
 419       content::Details<ExtensionHost>(this));
 420 }
 421
 422 void ExtensionHost::RequestMediaAccessPermission(
 423     content::WebContents* web_contents,
 424     const content::MediaStreamRequest& request,
 425     const content::MediaResponseCallback& callback) {
 426   delegate_->ProcessMediaAccessRequest(
 427       web_contents, request, callback, extension());
 428 }
 429
 430 bool ExtensionHost::IsNeverVisible(content::WebContents* web_contents) {
 431   ViewType view_type = extensions::GetViewType(web_contents);
 432   return view_type == extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE;
 433 }
 434
 435 }  // namespace extensions