src/extensions/shell/renderer/shell_content_renderer_client.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/shell/renderer/shell_content_renderer_client.h"
   6
   7 #include "content/public/common/content_constants.h"
   8 #include "content/public/renderer/render_frame.h"
   9 #include "content/public/renderer/render_frame_observer.h"
  10 #include "content/public/renderer/render_frame_observer_tracker.h"
  11 #include "content/public/renderer/render_thread.h"
  12 #include "extensions/common/extensions_client.h"
  13 #include "extensions/renderer/default_dispatcher_delegate.h"
  14 #include "extensions/renderer/dispatcher.h"
  15 #include "extensions/renderer/extension_helper.h"
  16 #include "extensions/renderer/guest_view/extensions_guest_view_container.h"
  17 #include "extensions/renderer/guest_view/mime_handler_view_container.h"
  18 #include "extensions/shell/common/shell_extensions_client.h"
  19 #include "extensions/shell/renderer/shell_extensions_renderer_client.h"
  20 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  21
  22 #if !defined(DISABLE_NACL)
  23 #include "components/nacl/common/nacl_constants.h"
  24 #include "components/nacl/renderer/nacl_helper.h"
  25 #include "components/nacl/renderer/ppb_nacl_private_impl.h"
  26 #include "ppapi/c/private/ppb_nacl_private.h"
  27 #endif
  28
  29 using blink::WebFrame;
  30 using blink::WebString;
  31 using content::RenderThread;
  32
  33 namespace extensions {
  34
  35 namespace {
  36
  37 // TODO: promote ExtensionFrameHelper to a common place and share with this.
  38 class ShellFrameHelper
  39     : public content::RenderFrameObserver,
  40       public content::RenderFrameObserverTracker<ShellFrameHelper> {
  41  public:
  42   ShellFrameHelper(content::RenderFrame* render_frame,
  43                    Dispatcher* extension_dispatcher);
  44   ~ShellFrameHelper() override;
  45
  46   // RenderFrameObserver implementation.
  47   void WillReleaseScriptContext(v8::Handle<v8::Context>, int world_id) override;
  48
  49  private:
  50   Dispatcher* extension_dispatcher_;
  51
  52   DISALLOW_COPY_AND_ASSIGN(ShellFrameHelper);
  53 };
  54
  55 ShellFrameHelper::ShellFrameHelper(content::RenderFrame* render_frame,
  56                                    Dispatcher* extension_dispatcher)
  57     : content::RenderFrameObserver(render_frame),
  58       content::RenderFrameObserverTracker<ShellFrameHelper>(render_frame),
  59       extension_dispatcher_(extension_dispatcher) {
  60 }
  61
  62 ShellFrameHelper::~ShellFrameHelper() {
  63 }
  64
  65 void ShellFrameHelper::WillReleaseScriptContext(v8::Handle<v8::Context> context,
  66                                                 int world_id) {
  67   extension_dispatcher_->WillReleaseScriptContext(
  68       render_frame()->GetWebFrame(), context, world_id);
  69 }
  70
  71 }  // namespace
  72
  73 ShellContentRendererClient::ShellContentRendererClient() {
  74 }
  75
  76 ShellContentRendererClient::~ShellContentRendererClient() {
  77 }
  78
  79 void ShellContentRendererClient::RenderThreadStarted() {
  80   RenderThread* thread = RenderThread::Get();
  81
  82   extensions_client_.reset(new ShellExtensionsClient);
  83   ExtensionsClient::Set(extensions_client_.get());
  84
  85   extensions_renderer_client_.reset(new ShellExtensionsRendererClient);
  86   ExtensionsRendererClient::Set(extensions_renderer_client_.get());
  87
  88   extension_dispatcher_delegate_.reset(new DefaultDispatcherDelegate());
  89
  90   // Must be initialized after ExtensionsRendererClient.
  91   extension_dispatcher_.reset(
  92       new Dispatcher(extension_dispatcher_delegate_.get()));
  93   thread->AddObserver(extension_dispatcher_.get());
  94
  95   // TODO(jamescook): Init WebSecurityPolicy for chrome-extension: schemes.
  96   // See ChromeContentRendererClient for details.
  97 }
  98
  99 void ShellContentRendererClient::RenderFrameCreated(
 100     content::RenderFrame* render_frame) {
 101   // ShellFrameHelper destroys itself when the RenderFrame is destroyed.
 102   new ShellFrameHelper(render_frame, extension_dispatcher_.get());
 103
 104   // TODO(jamescook): Do we need to add a new PepperHelper(render_frame) here?
 105   // It doesn't seem necessary for either Pepper or NaCl.
 106   // http://crbug.com/403004
 107 #if !defined(DISABLE_NACL)
 108   new nacl::NaClHelper(render_frame);
 109 #endif
 110 }
 111
 112 void ShellContentRendererClient::RenderViewCreated(
 113     content::RenderView* render_view) {
 114   new ExtensionHelper(render_view, extension_dispatcher_.get());
 115   extension_dispatcher_->OnRenderViewCreated(render_view);
 116 }
 117
 118 bool ShellContentRendererClient::OverrideCreatePlugin(
 119     content::RenderFrame* render_frame,
 120     blink::WebLocalFrame* frame,
 121     const blink::WebPluginParams& params,
 122     blink::WebPlugin** plugin) {
 123   // Allow the content module to create the plugin.
 124   return false;
 125 }
 126
 127 blink::WebPlugin* ShellContentRendererClient::CreatePluginReplacement(
 128     content::RenderFrame* render_frame,
 129     const base::FilePath& plugin_path) {
 130   // Don't provide a custom "failed to load" plugin.
 131   return NULL;
 132 }
 133
 134 bool ShellContentRendererClient::WillSendRequest(
 135     blink::WebFrame* frame,
 136     ui::PageTransition transition_type,
 137     const GURL& url,
 138     const GURL& first_party_for_cookies,
 139     GURL* new_url) {
 140   // TODO(jamescook): Cause an error for bad extension scheme requests?
 141   return false;
 142 }
 143
 144 void ShellContentRendererClient::DidCreateScriptContext(
 145     WebFrame* frame,
 146     v8::Handle<v8::Context> context,
 147     int extension_group,
 148     int world_id) {
 149   extension_dispatcher_->DidCreateScriptContext(
 150       frame, context, extension_group, world_id);
 151 }
 152
 153 const void* ShellContentRendererClient::CreatePPAPIInterface(
 154     const std::string& interface_name) {
 155 #if !defined(DISABLE_NACL)
 156   if (interface_name == PPB_NACL_PRIVATE_INTERFACE)
 157     return nacl::GetNaClPrivateInterface();
 158 #endif
 159   return NULL;
 160 }
 161
 162 bool ShellContentRendererClient::IsExternalPepperPlugin(
 163     const std::string& module_name) {
 164 #if !defined(DISABLE_NACL)
 165   // TODO(bbudge) remove this when the trusted NaCl plugin has been removed.
 166   // We must defer certain plugin events for NaCl instances since we switch
 167   // from the in-process to the out-of-process proxy after instantiating them.
 168   return module_name == nacl::kNaClPluginName;
 169 #else
 170   return false;
 171 #endif
 172 }
 173
 174 bool ShellContentRendererClient::ShouldEnableSiteIsolationPolicy() const {
 175   // Extension renderers don't need site isolation.
 176   return false;
 177 }
 178
 179 content::BrowserPluginDelegate*
 180 ShellContentRendererClient::CreateBrowserPluginDelegate(
 181     content::RenderFrame* render_frame,
 182     const std::string& mime_type,
 183     const GURL& original_url) {
 184   if (mime_type == content::kBrowserPluginMimeType) {
 185     return new extensions::ExtensionsGuestViewContainer(render_frame);
 186   } else {
 187     return new extensions::MimeHandlerViewContainer(
 188         render_frame, mime_type, original_url);
 189   }
 190 }
 191
 192 }  // namespace extensions