extensions/browser/extension_host.h

   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 #ifndef EXTENSIONS_BROWSER_EXTENSION_HOST_H_
   6 #define EXTENSIONS_BROWSER_EXTENSION_HOST_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/timer/elapsed_timer.h"
  14 #include "content/public/browser/notification_observer.h"
  15 #include "content/public/browser/notification_registrar.h"
  16 #include "content/public/browser/web_contents_delegate.h"
  17 #include "content/public/browser/web_contents_observer.h"
  18 #include "extensions/browser/extension_function_dispatcher.h"
  19 #include "extensions/common/stack_frame.h"
  20 #include "extensions/common/view_type.h"
  21
  22 class PrefsTabHelper;
  23
  24 namespace content {
  25 class BrowserContext;
  26 class RenderProcessHost;
  27 class RenderWidgetHostView;
  28 class SiteInstance;
  29 }
  30
  31 namespace extensions {
  32 class Extension;
  33 class ExtensionHostDelegate;
  34 class WindowController;
  35
  36 // This class is the browser component of an extension component's RenderView.
  37 // It handles setting up the renderer process, if needed, with special
  38 // privileges available to extensions.  It may have a view to be shown in the
  39 // browser UI, or it may be hidden.
  40 //
  41 // If you are adding code that only affects visible extension views (and not
  42 // invisible background pages) you should add it to ExtensionViewHost.
  43 class ExtensionHost : public content::WebContentsDelegate,
  44                       public content::WebContentsObserver,
  45                       public ExtensionFunctionDispatcher::Delegate,
  46                       public content::NotificationObserver {
  47  public:
  48   class ProcessCreationQueue;
  49
  50   ExtensionHost(const Extension* extension,
  51                 content::SiteInstance* site_instance,
  52                 const GURL& url, ViewType host_type);
  53   virtual ~ExtensionHost();
  54
  55   const Extension* extension() const { return extension_; }
  56   const std::string& extension_id() const { return extension_id_; }
  57   content::WebContents* host_contents() const { return host_contents_.get(); }
  58   content::RenderViewHost* render_view_host() const;
  59   content::RenderProcessHost* render_process_host() const;
  60   bool did_stop_loading() const { return did_stop_loading_; }
  61   bool document_element_available() const {
  62     return document_element_available_;
  63   }
  64
  65   content::BrowserContext* browser_context() { return browser_context_; }
  66
  67   ViewType extension_host_type() const { return extension_host_type_; }
  68   const GURL& GetURL() const;
  69
  70   // Returns true if the render view is initialized and didn't crash.
  71   bool IsRenderViewLive() const;
  72
  73   // Prepares to initializes our RenderViewHost by creating its RenderView and
  74   // navigating to this host's url. Uses host_view for the RenderViewHost's view
  75   // (can be NULL). This happens delayed to avoid locking the UI.
  76   void CreateRenderViewSoon();
  77
  78   // content::WebContentsObserver
  79   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
  80   virtual void RenderViewCreated(
  81       content::RenderViewHost* render_view_host) OVERRIDE;
  82   virtual void RenderViewDeleted(
  83       content::RenderViewHost* render_view_host) OVERRIDE;
  84   virtual void RenderViewReady() OVERRIDE;
  85   virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE;
  86   virtual void DocumentAvailableInMainFrame() OVERRIDE;
  87   virtual void DidStopLoading(
  88       content::RenderViewHost* render_view_host) OVERRIDE;
  89
  90   // content::WebContentsDelegate
  91   virtual content::JavaScriptDialogManager*
  92       GetJavaScriptDialogManager() OVERRIDE;
  93   virtual void AddNewContents(content::WebContents* source,
  94                               content::WebContents* new_contents,
  95                               WindowOpenDisposition disposition,
  96                               const gfx::Rect& initial_pos,
  97                               bool user_gesture,
  98                               bool* was_blocked) OVERRIDE;
  99   virtual void CloseContents(content::WebContents* contents) OVERRIDE;
 100   virtual void RequestMediaAccessPermission(
 101       content::WebContents* web_contents,
 102       const content::MediaStreamRequest& request,
 103       const content::MediaResponseCallback& callback) OVERRIDE;
 104   virtual bool IsNeverVisible(content::WebContents* web_contents) OVERRIDE;
 105
 106   // content::NotificationObserver
 107   virtual void Observe(int type,
 108                        const content::NotificationSource& source,
 109                        const content::NotificationDetails& details) OVERRIDE;
 110
 111  protected:
 112   content::NotificationRegistrar* registrar() { return &registrar_; }
 113
 114   // Called after the extension page finishes loading but before the
 115   // EXTENSION_HOST_DID_STOP_LOADING notification is sent.
 116   virtual void OnDidStopLoading();
 117
 118   // Called once when the document first becomes available.
 119   virtual void OnDocumentAvailable();
 120
 121   // Navigates to the initial page.
 122   virtual void LoadInitialURL();
 123
 124   // Returns true if we're hosting a background page.
 125   virtual bool IsBackgroundPage() const;
 126
 127   // Closes this host (results in deletion).
 128   void Close();
 129
 130  private:
 131   friend class ProcessCreationQueue;
 132
 133   // Actually create the RenderView for this host. See CreateRenderViewSoon.
 134   void CreateRenderViewNow();
 135
 136   // Message handlers.
 137   void OnRequest(const ExtensionHostMsg_Request_Params& params);
 138   void OnEventAck();
 139   void OnIncrementLazyKeepaliveCount();
 140   void OnDecrementLazyKeepaliveCount();
 141
 142   // Delegate for functionality that cannot exist in the extensions module.
 143   scoped_ptr<ExtensionHostDelegate> delegate_;
 144
 145   // The extension that we're hosting in this view.
 146   const Extension* extension_;
 147
 148   // Id of extension that we're hosting in this view.
 149   const std::string extension_id_;
 150
 151   // The browser context that this host is tied to.
 152   content::BrowserContext* browser_context_;
 153
 154   // The host for our HTML content.
 155   scoped_ptr<content::WebContents> host_contents_;
 156
 157   // A weak pointer to the current or pending RenderViewHost. We don't access
 158   // this through the host_contents because we want to deal with the pending
 159   // host, so we can send messages to it before it finishes loading.
 160   content::RenderViewHost* render_view_host_;
 161
 162   // Whether the RenderWidget has reported that it has stopped loading.
 163   bool did_stop_loading_;
 164
 165   // True if the main frame has finished parsing.
 166   bool document_element_available_;
 167
 168   // The original URL of the page being hosted.
 169   GURL initial_url_;
 170
 171   content::NotificationRegistrar registrar_;
 172
 173   ExtensionFunctionDispatcher extension_function_dispatcher_;
 174
 175   // The type of view being hosted.
 176   ViewType extension_host_type_;
 177
 178   // Used to measure how long it's been since the host was created.
 179   base::ElapsedTimer since_created_;
 180
 181   DISALLOW_COPY_AND_ASSIGN(ExtensionHost);
 182 };
 183
 184 }  // namespace extensions
 185
 186 #endif  // EXTENSIONS_BROWSER_EXTENSION_HOST_H_