Move more extensions code into ChromeExtensionsRendererClient.

chrome/renderer/chrome_content_renderer_client.cc

 // Copyright (c) 2012 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/renderer/chrome_content_renderer_client.h"
 
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_isolated_world_ids.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/crash_keys.h"
-#include "chrome/common/extensions/extension_metrics.h"
 #include "chrome/common/localized_error.h"
 #include "chrome/common/pepper_permission_util.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/secure_origin_whitelist.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/locale_settings.h"
 #include "chrome/grit/renderer_resources.h"
 #include "chrome/renderer/banners/app_banner_client.h"
 #include "chrome/renderer/benchmarking_extension.h"
@@ skipping 70 matching lines @@
 #include "ui/base/webui/jstemplate_builder.h"
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
 #if !defined(DISABLE_NACL)
 #include "components/nacl/common/nacl_constants.h"
 #include "components/nacl/renderer/nacl_helper.h"
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/common/extensions/chrome_extensions_client.h"
-#include "chrome/common/extensions/extension_process_policy.h"
-#include "chrome/renderer/extensions/chrome_extensions_dispatcher_delegate.h"
 #include "chrome/renderer/extensions/chrome_extensions_renderer_client.h"
-#include "chrome/renderer/extensions/renderer_permissions_policy_delegate.h"
-#include "chrome/renderer/extensions/resource_request_policy.h"
-#include "chrome/renderer/media/cast_ipc_dispatcher.h"
-#include "extensions/common/extension.h"
-#include "extensions/common/extension_set.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/switches.h"
 #include "extensions/renderer/dispatcher.h"
-#include "extensions/renderer/extension_frame_helper.h"
-#include "extensions/renderer/extension_helper.h"
-#include "extensions/renderer/extensions_render_frame_observer.h"
-#include "extensions/renderer/guest_view/extensions_guest_view_container.h"
-#include "extensions/renderer/guest_view/extensions_guest_view_container_dispatcher.h"
-#include "extensions/renderer/guest_view/mime_handler_view/mime_handler_view_container.h"
 #include "extensions/renderer/renderer_extension_registry.h"
-#include "extensions/renderer/script_context.h"
 #endif
 
 #if defined(ENABLE_IPC_FUZZER)
 #include "chrome/common/external_ipc_dumper.h"
 #endif
 
 #if defined(ENABLE_PLUGINS)
 #include "chrome/renderer/plugins/chrome_plugin_placeholder.h"
 #endif
 
@@ skipping 13 matching lines @@
 
 #if defined(ENABLE_WEBRTC)
 #include "chrome/renderer/media/webrtc_logging_message_filter.h"
 #endif
 
 using autofill::AutofillAgent;
 using autofill::PasswordAutofillAgent;
 using autofill::PasswordGenerationAgent;
 using base::ASCIIToUTF16;
 using base::UserMetricsAction;
-using content::PluginInstanceThrottler;
-using content::RenderFrame;
-using content::RenderThread;
-using content::WebPluginInfo;
-using extensions::Extension;
 using blink::WebCache;
 using blink::WebConsoleMessage;
 using blink::WebDataSource;
 using blink::WebDocument;
 using blink::WebLocalFrame;
 using blink::WebPlugin;
 using blink::WebPluginParams;
 using blink::WebSecurityOrigin;
 using blink::WebSecurityPolicy;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebURLError;
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 using blink::WebVector;
+using content::PluginInstanceThrottler;
+using content::RenderFrame;
+using content::RenderThread;
+using content::WebPluginInfo;
+using extensions::Extension;
 
 namespace {
 
-ChromeContentRendererClient* g_current_client;
-
 // Whitelist PPAPI for Android Runtime for Chromium. (See crbug.com/383937)
 #if defined(ENABLE_PLUGINS)
 const char* const kPredefinedAllowedCameraDeviceOrigins[] = {
   "6EAED1924DB611B6EEF2A664BD077BE7EAD33B8F",
   "4EB74897CB187C7633357C2FE832E0AD6A44883A"
 };
 
 const char* const kPredefinedAllowedCompositorOrigins[] = {
   "6EAED1924DB611B6EEF2A664BD077BE7EAD33B8F",
   "4EB74897CB187C7633357C2FE832E0AD6A44883A"
@@ skipping 66 matching lines @@
 };
 
 bool SpellCheckReplacer::Visit(content::RenderView* render_view) {
   SpellCheckProvider* provider = SpellCheckProvider::Get(render_view);
   DCHECK(provider);
   provider->set_spellcheck(spellcheck_);
   return true;
 }
 #endif
 
-#if defined(ENABLE_EXTENSIONS)
-void IsGuestViewApiAvailableToScriptContext(
-    bool* api_is_available,
-    extensions::ScriptContext* context) {
-  if (context->GetAvailability("guestViewInternal").is_available()) {
-    *api_is_available = true;
-  }
-}
-#endif
-
 #if defined(ENABLE_PLUGINS)
 // Presence of the poster param within plugin object tags.
 // These numeric values are used in UMA logs; do not change them.
 enum PosterParamPresence {
   POSTER_PRESENCE_NO_PARAM_PPS_DISABLED = 0,
   POSTER_PRESENCE_NO_PARAM_PPS_ENABLED = 1,
   POSTER_PRESENCE_PARAM_EXISTS_PPS_DISABLED = 2,
   POSTER_PRESENCE_PARAM_EXISTS_PPS_ENABLED = 3,
   POSTER_PRESENCE_NUM_ITEMS
 };
@@ skipping 66 matching lines @@
   }
 
   const base::Closure continue_loading_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaLoadDeferrer);
 };
 
 }  // namespace
 
 ChromeContentRendererClient::ChromeContentRendererClient() {
-  g_current_client = this;
-
 #if defined(ENABLE_EXTENSIONS)
   extensions::ExtensionsClient::Set(
       extensions::ChromeExtensionsClient::GetInstance());
   extensions::ExtensionsRendererClient::Set(
       ChromeExtensionsRendererClient::GetInstance());
 #endif
 #if defined(ENABLE_PLUGINS)
   for (size_t i = 0; i < arraysize(kPredefinedAllowedCameraDeviceOrigins); ++i)
     allowed_camera_device_origins_.insert(
         kPredefinedAllowedCameraDeviceOrigins[i]);
   for (size_t i = 0; i < arraysize(kPredefinedAllowedCompositorOrigins); ++i)
     allowed_compositor_origins_.insert(kPredefinedAllowedCompositorOrigins[i]);
 #endif
 }
 
 ChromeContentRendererClient::~ChromeContentRendererClient() {
-  g_current_client = NULL;
 }
 
 void ChromeContentRendererClient::RenderThreadStarted() {
   RenderThread* thread = RenderThread::Get();
 
   chrome_observer_.reset(new ChromeRenderProcessObserver());
   web_cache_observer_.reset(new web_cache::WebCacheRenderProcessObserver());
 
 #if defined(ENABLE_EXTENSIONS)
-  extension_dispatcher_delegate_.reset(
-      new ChromeExtensionsDispatcherDelegate());
-  // ChromeRenderViewTest::SetUp() creates its own ExtensionDispatcher and
-  // injects it using SetExtensionDispatcher(). Don't overwrite it.
-  if (!extension_dispatcher_) {
-    extension_dispatcher_.reset(
-        new extensions::Dispatcher(extension_dispatcher_delegate_.get()));
-  }
-  permissions_policy_delegate_.reset(
-      new extensions::RendererPermissionsPolicyDelegate(
-          extension_dispatcher_.get()));
-  resource_request_policy_.reset(
-      new extensions::ResourceRequestPolicy(extension_dispatcher_.get()));
-  guest_view_container_dispatcher_.reset(
-      new extensions::ExtensionsGuestViewContainerDispatcher());
+  ChromeExtensionsRendererClient::GetInstance()->RenderThreadStarted();
 #endif
 
   prescient_networking_dispatcher_.reset(
       new network_hints::PrescientNetworkingDispatcher());
 #if defined(ENABLE_SPELLCHECK)
   // ChromeRenderViewTest::SetUp() creates a Spellcheck and injects it using
   // SetSpellcheck(). Don't overwrite it.
   if (!spellcheck_) {
     spellcheck_.reset(new SpellCheck());
     thread->AddObserver(spellcheck_.get());
   }
 #endif
   visited_link_slave_.reset(new visitedlink::VisitedLinkSlave());
 #if defined(FULL_SAFE_BROWSING)
   phishing_classifier_.reset(safe_browsing::PhishingClassifierFilter::Create());
 #endif
   prerender_dispatcher_.reset(new prerender::PrerenderDispatcher());
 #if defined(ENABLE_WEBRTC)
   webrtc_logging_message_filter_ = new WebRtcLoggingMessageFilter(
-      RenderThread::Get()->GetIOMessageLoopProxy());
+      thread->GetIOMessageLoopProxy());
 #endif
 
   thread->AddObserver(chrome_observer_.get());
   thread->AddObserver(web_cache_observer_.get());
-#if defined(ENABLE_EXTENSIONS)
-  thread->AddObserver(extension_dispatcher_.get());
-  thread->AddObserver(guest_view_container_dispatcher_.get());
-#endif
 #if defined(FULL_SAFE_BROWSING)
   thread->AddObserver(phishing_classifier_.get());
 #endif
   thread->AddObserver(visited_link_slave_.get());
   thread->AddObserver(prerender_dispatcher_.get());
   thread->AddObserver(SearchBouncer::GetInstance());
 
 #if defined(ENABLE_WEBRTC)
   thread->AddFilter(webrtc_logging_message_filter_.get());
 #endif
-#if defined(ENABLE_EXTENSIONS)
-  thread->AddFilter(new CastIPCDispatcher(
-      RenderThread::Get()->GetIOMessageLoopProxy()));
-#endif
 
   thread->RegisterExtension(extensions_v8::ExternalExtension::Get());
   thread->RegisterExtension(extensions_v8::LoadTimesExtension::Get());
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kEnableBenchmarking))
     thread->RegisterExtension(extensions_v8::BenchmarkingExtension::Get());
   if (command_line->HasSwitch(switches::kEnableNetBenchmarking))
     thread->RegisterExtension(extensions_v8::NetBenchmarkingExtension::Get());
   if (command_line->HasSwitch(switches::kInstantProcess))
@@ skipping 54 matching lines @@
 
 void ChromeContentRendererClient::RenderFrameCreated(
     content::RenderFrame* render_frame) {
   new ChromeRenderFrameObserver(render_frame);
 
   bool should_whitelist_for_content_settings =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kInstantProcess);
   extensions::Dispatcher* ext_dispatcher = NULL;
 #if defined(ENABLE_EXTENSIONS)
-  ext_dispatcher = extension_dispatcher_.get();
+  ext_dispatcher =
+      ChromeExtensionsRendererClient::GetInstance()->extension_dispatcher();
 #endif
   ContentSettingsObserver* content_settings = new ContentSettingsObserver(
       render_frame, ext_dispatcher, should_whitelist_for_content_settings);
   if (chrome_observer_.get()) {
     content_settings->SetContentSettingRules(
         chrome_observer_->content_setting_rules());
   }
 
 #if defined(ENABLE_EXTENSIONS)
-  new extensions::ExtensionsRenderFrameObserver(render_frame);
-  new extensions::ExtensionFrameHelper(render_frame, ext_dispatcher);
-  ext_dispatcher->OnRenderFrameCreated(render_frame);
+  ChromeExtensionsRendererClient::GetInstance()->RenderFrameCreated(
+      render_frame);
 #endif
 
 #if defined(ENABLE_PLUGINS)
   new PepperHelper(render_frame);
 #endif
 
 #if !defined(DISABLE_NACL)
   new nacl::NaClHelper(render_frame);
 #endif
 
@@ skipping 21 matching lines @@
   PasswordAutofillAgent* password_autofill_agent =
       new PasswordAutofillAgent(render_frame);
   PasswordGenerationAgent* password_generation_agent =
       new PasswordGenerationAgent(render_frame, password_autofill_agent);
   new AutofillAgent(render_frame, password_autofill_agent,
                     password_generation_agent);
 }
 
 void ChromeContentRendererClient::RenderViewCreated(
     content::RenderView* render_view) {
-
 #if defined(ENABLE_EXTENSIONS)
-  new extensions::ExtensionHelper(render_view, extension_dispatcher_.get());
+  ChromeExtensionsRendererClient::GetInstance()->RenderViewCreated(render_view);
 #endif
   new PageLoadHistograms(render_view);
 #if defined(ENABLE_PRINTING)
   new printing::PrintWebViewHelper(
       render_view,
       scoped_ptr<printing::PrintWebViewHelper::Delegate>(
           new ChromePrintWebViewHelperDelegate()));
 #endif
 #if defined(ENABLE_SPELLCHECK)
   new SpellCheckProvider(render_view, spellcheck_.get());
@@ skipping 16 matching lines @@
 SkBitmap* ChromeContentRendererClient::GetSadPluginBitmap() {
   return const_cast<SkBitmap*>(ResourceBundle::GetSharedInstance().
       GetImageNamed(IDR_SAD_PLUGIN).ToSkBitmap());
 }
 
 SkBitmap* ChromeContentRendererClient::GetSadWebViewBitmap() {
   return const_cast<SkBitmap*>(ResourceBundle::GetSharedInstance().
       GetImageNamed(IDR_SAD_WEBVIEW).ToSkBitmap());
 }
 
-#if defined(ENABLE_EXTENSIONS)
-const Extension* ChromeContentRendererClient::GetExtensionByOrigin(
-    const WebSecurityOrigin& origin) const {
-  if (!base::EqualsASCII(base::StringPiece16(origin.protocol()),
-                         extensions::kExtensionScheme))
-    return NULL;
-
-  const std::string extension_id = origin.host().utf8().data();
-  return extensions::RendererExtensionRegistry::Get()->GetByID(extension_id);
-}
-#endif
-
 bool ChromeContentRendererClient::OverrideCreatePlugin(
     content::RenderFrame* render_frame,
     blink::WebLocalFrame* frame,
     const WebPluginParams& params,
     WebPlugin** plugin) {
   std::string orig_mime_type = params.mimeType.utf8();
 #if defined(ENABLE_EXTENSIONS)
-  if (orig_mime_type == content::kBrowserPluginMimeType) {
-    bool guest_view_api_available = false;
-    extension_dispatcher_->script_context_set().ForEach(
-        render_frame, base::Bind(&IsGuestViewApiAvailableToScriptContext,
-                                 &guest_view_api_available));
-    if (guest_view_api_available)
-      return false;
+  if (!ChromeExtensionsRendererClient::GetInstance()->OverrideCreatePlugin(
+          render_frame, params)) {
+    return false;
   }
 #endif
 
   GURL url(params.url);
 #if defined(ENABLE_PLUGINS)
   ChromeViewHostMsg_GetPluginInfo_Output output;
   WebString top_origin = frame->top()->securityOrigin().toString();
   render_frame->Send(new ChromeViewHostMsg_GetPluginInfo(
       render_frame->GetRoutingID(), url, GURL(top_origin), orig_mime_type,
       &output));
@@ skipping 523 matching lines @@
     AllowTimerSuspensionWhenProcessBackgrounded() {
 #if defined(OS_ANDROID)
   return true;
 #else
   return false;
 #endif
 }
 
 bool ChromeContentRendererClient::AllowPopup() {
 #if defined(ENABLE_EXTENSIONS)
-  extensions::ScriptContext* current_context =
-      extension_dispatcher_->script_context_set().GetCurrent();
-  if (!current_context || !current_context->extension())
-    return false;
-  // See http://crbug.com/117446 for the subtlety of this check.
-  switch (current_context->context_type()) {
-    case extensions::Feature::UNSPECIFIED_CONTEXT:
-    case extensions::Feature::WEB_PAGE_CONTEXT:
-    case extensions::Feature::UNBLESSED_EXTENSION_CONTEXT:
-    case extensions::Feature::WEBUI_CONTEXT:
-    case extensions::Feature::SERVICE_WORKER_CONTEXT:
-      return false;
-    case extensions::Feature::BLESSED_EXTENSION_CONTEXT:
-    case extensions::Feature::CONTENT_SCRIPT_CONTEXT:
-      return true;
-    case extensions::Feature::BLESSED_WEB_PAGE_CONTEXT:
-      return !current_context->web_frame()->parent();
-  }
-  NOTREACHED();
+  return ChromeExtensionsRendererClient::GetInstance()->AllowPopup();
+#else
+  return false;
 #endif
-  return false;
 }
 
 bool ChromeContentRendererClient::ShouldFork(blink::WebLocalFrame* frame,
                                              const GURL& url,
                                              const std::string& http_method,
                                              bool is_initial_navigation,
                                              bool is_server_redirect,
                                              bool* send_referrer) {
   DCHECK(!frame->parent());
 
@@ skipping 20 matching lines @@
   // to swap in the prerendered page on the browser process. If the prerendered
   // page no longer exists by the time the OpenURL IPC is handled, a normal
   // navigation is attempted.
   if (prerender_dispatcher_.get() &&
       prerender_dispatcher_->IsPrerenderURL(url)) {
     *send_referrer = true;
     return true;
   }
 
 #if defined(ENABLE_EXTENSIONS)
-  const extensions::RendererExtensionRegistry* extension_registry =
-      extensions::RendererExtensionRegistry::Get();
-
-  // Determine if the new URL is an extension (excluding bookmark apps).
-  const Extension* new_url_extension = extensions::GetNonBookmarkAppExtension(
-      *extension_registry->GetMainThreadExtensionSet(), url);
-  bool is_extension_url = !!new_url_extension;
-
-  // If the navigation would cross an app extent boundary, we also need
-  // to defer to the browser to ensure process isolation.  This is not necessary
-  // for server redirects, which will be transferred to a new process by the
-  // browser process when they are ready to commit.  It is necessary for client
-  // redirects, which won't be transferred in the same way.
-  if (!is_server_redirect &&
-      CrossesExtensionExtents(frame, url, is_extension_url,
-                              is_initial_navigation)) {
-    // Include the referrer in this case since we're going from a hosted web
-    // page. (the packaged case is handled previously by the extension
-    // navigation test)
-    *send_referrer = true;
-
-    const Extension* extension =
-        extension_registry->GetExtensionOrAppByURL(url);
-    if (extension && extension->is_app()) {
-      extensions::RecordAppLaunchType(
-          extension_misc::APP_LAUNCH_CONTENT_NAVIGATION, extension->GetType());
-    }
+  bool should_fork = ChromeExtensionsRendererClient::ShouldFork(
+      frame, url, is_initial_navigation, is_server_redirect, send_referrer);
+  if (should_fork)
     return true;
-  }
-
-  // If this is a reload, check whether it has the wrong process type.  We
-  // should send it to the browser if it's an extension URL (e.g., hosted app)
-  // in a normal process, or if it's a process for an extension that has been
-  // uninstalled.  Without --site-per-process mode, we never fork processes for
-  // subframes, so this check only makes sense for top-level frames.
-  // TODO(alexmos,nasko): Figure out how this check should work when reloading
-  // subframes in --site-per-process mode.
-  if (!frame->parent() && frame->document().url() == url) {
-    if (is_extension_url != IsStandaloneExtensionProcess())
-      return true;
-  }
 #endif  // defined(ENABLE_EXTENSIONS)
 
   return false;
 }
 
 bool ChromeContentRendererClient::WillSendRequest(
     blink::WebFrame* frame,
     ui::PageTransition transition_type,
     const GURL& url,
     const GURL& first_party_for_cookies,
     GURL* new_url) {
   // Check whether the request should be allowed. If not allowed, we reset the
   // URL to something invalid to prevent the request and cause an error.
 #if defined(ENABLE_EXTENSIONS)
-  if (url.SchemeIs(extensions::kExtensionScheme) &&
-      !resource_request_policy_->CanRequestResource(url, frame,
-                                                    transition_type)) {
-    *new_url = GURL(chrome::kExtensionInvalidRequestURL);
-    return true;
-  }
-
-  if (url.SchemeIs(extensions::kExtensionResourceScheme) &&
-      !resource_request_policy_->CanRequestExtensionResourceScheme(url,
-                                                                   frame)) {
-    *new_url = GURL(chrome::kExtensionResourceInvalidRequestURL);
+  if (ChromeExtensionsRendererClient::GetInstance()->WillSendRequest(
+          frame, transition_type, url, new_url)) {
     return true;
   }
 #endif
 
   const content::RenderView* render_view =
       content::RenderView::FromWebView(frame->view());
   SearchBox* search_box = SearchBox::Get(render_view);
   if (search_box && url.SchemeIs(chrome::kChromeSearchScheme)) {
     SearchBox::ImageSourceType type = SearchBox::NONE;
     if (url.host() == chrome::kChromeUIFaviconHost)
       type = SearchBox::FAVICON;
     else if (url.host() == chrome::kChromeUILargeIconHost)
       type = SearchBox::LARGE_ICON;
     else if (url.host() == chrome::kChromeUIFallbackIconHost)
       type = SearchBox::FALLBACK_ICON;
     else if (url.host() == chrome::kChromeUIThumbnailHost)
       type = SearchBox::THUMB;
+
     if (type != SearchBox::NONE)
       return search_box->GenerateImageURLFromTransientURL(url, type, new_url);
   }
 
   return false;
 }
 
 unsigned long long ChromeContentRendererClient::VisitedLinkHash(
     const char* canonical_url, size_t length) {
   return visited_link_slave_->ComputeURLFingerprint(canonical_url, length);
@@ skipping 11 matching lines @@
 bool ChromeContentRendererClient::ShouldOverridePageVisibilityState(
     const content::RenderFrame* render_frame,
     blink::WebPageVisibilityState* override_state) {
   if (!prerender::PrerenderHelper::IsPrerendering(render_frame))
     return false;
 
   *override_state = blink::WebPageVisibilityStatePrerender;
   return true;
 }
 
-#if defined(ENABLE_EXTENSIONS)
-void ChromeContentRendererClient::SetExtensionDispatcherForTest(
-    extensions::Dispatcher* extension_dispatcher) {
-  extension_dispatcher_.reset(extension_dispatcher);
-  permissions_policy_delegate_.reset(
-      new extensions::RendererPermissionsPolicyDelegate(
-          extension_dispatcher_.get()));
-  RenderThread::Get()->RegisterExtension(
-      extensions::SafeBuiltins::CreateV8Extension());
-}
-
-extensions::Dispatcher*
-ChromeContentRendererClient::GetExtensionDispatcherForTest() {
-  return extension_dispatcher_.get();
-}
-
-bool ChromeContentRendererClient::CrossesExtensionExtents(
-    blink::WebLocalFrame* frame,
-    const GURL& new_url,
-    bool is_extension_url,
-    bool is_initial_navigation) {
-  DCHECK(!frame->parent());
-  GURL old_url(frame->document().url());
-
-  extensions::RendererExtensionRegistry* extension_registry =
-      extensions::RendererExtensionRegistry::Get();
-
-  // If old_url is still empty and this is an initial navigation, then this is
-  // a window.open operation.  We should look at the opener URL.  Note that the
-  // opener is a local frame in this case.
-  if (is_initial_navigation && old_url.is_empty() && frame->opener()) {
-    WebLocalFrame* opener_frame = frame->opener()->toWebLocalFrame();
-
-    // If we're about to open a normal web page from a same-origin opener stuck
-    // in an extension process, we want to keep it in process to allow the
-    // opener to script it.
-    WebDocument opener_document = opener_frame->document();
-    WebSecurityOrigin opener_origin = opener_document.securityOrigin();
-    bool opener_is_extension_url = !opener_origin.isUnique() &&
-                                   extension_registry->GetExtensionOrAppByURL(
-                                       opener_document.url()) != NULL;
-    if (!is_extension_url &&
-        !opener_is_extension_url &&
-        IsStandaloneExtensionProcess() &&
-        opener_origin.canRequest(WebURL(new_url)))
-      return false;
-
-    // In all other cases, we want to compare against the URL that determines
-    // the type of process.  In default Chrome, that's the URL of the opener's
-    // top frame and not the opener frame itself.  In --site-per-process, we
-    // can use the opener frame itself.
-    // TODO(nick): Either wire this up to SiteIsolationPolicy, or to state on
-    // |opener_frame|/its ancestors.
-    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kSitePerProcess) ||
-        base::CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kIsolateExtensions))
-      old_url = opener_frame->document().url();
-    else
-      old_url = opener_frame->top()->document().url();
-  }
-
-  // Only consider keeping non-app URLs in an app process if this window
-  // has an opener (in which case it might be an OAuth popup that tries to
-  // script an iframe within the app).
-  bool should_consider_workaround = !!frame->opener();
-
-  return extensions::CrossesExtensionProcessBoundary(
-      *extension_registry->GetMainThreadExtensionSet(), old_url, new_url,
-      should_consider_workaround);
-}
-#endif  // defined(ENABLE_EXTENSIONS)
-
 #if defined(ENABLE_SPELLCHECK)
 void ChromeContentRendererClient::SetSpellcheck(SpellCheck* spellcheck) {
   RenderThread* thread = RenderThread::Get();
   if (spellcheck_.get() && thread)
     thread->RemoveObserver(spellcheck_.get());
   spellcheck_.reset(spellcheck);
   SpellCheckReplacer replacer(spellcheck_.get());
   content::RenderView::ForEach(&replacer);
   if (thread)
     thread->AddObserver(spellcheck_.get());
 }
 #endif
 
-// static
-bool ChromeContentRendererClient::WasWebRequestUsedBySomeExtensions() {
-#if defined(ENABLE_EXTENSIONS)
-  return g_current_client->extension_dispatcher_
-      ->WasWebRequestUsedBySomeExtensions();
-#else
-  return false;
-#endif
-}
-
 const void* ChromeContentRendererClient::CreatePPAPIInterface(
     const std::string& interface_name) {
 #if defined(ENABLE_PLUGINS) && !defined(DISABLE_NACL)
   if (interface_name == PPB_NACL_PRIVATE_INTERFACE)
     return nacl::GetNaClPrivateInterface();
 #endif
   return NULL;
 }
 
 bool ChromeContentRendererClient::IsExternalPepperPlugin(
@@ skipping 129 matching lines @@
   return false;
 #endif
 }
 
 content::BrowserPluginDelegate*
 ChromeContentRendererClient::CreateBrowserPluginDelegate(
     content::RenderFrame* render_frame,
     const std::string& mime_type,
     const GURL& original_url) {
 #if defined(ENABLE_EXTENSIONS)
-  if (mime_type == content::kBrowserPluginMimeType) {
-    return new extensions::ExtensionsGuestViewContainer(render_frame);
-  } else {
-    return new extensions::MimeHandlerViewContainer(
-        render_frame, mime_type, original_url);
-  }
+  return ChromeExtensionsRendererClient::CreateBrowserPluginDelegate(
+    render_frame, mime_type, original_url);
 #else
-  return NULL;
+  return nullptr;
 #endif
 }
 
 void ChromeContentRendererClient::RecordRappor(const std::string& metric,
                                                const std::string& sample) {
   RenderThread::Get()->Send(new ChromeViewHostMsg_RecordRappor(metric, sample));
 }
 
 void ChromeContentRendererClient::RecordRapporURL(const std::string& metric,
                                                   const GURL& url) {
@@ skipping 45 matching lines @@
 // chrome.system.network.getNetworkInterfaces provides the same
 // information. Also, the enforcement of sending and binding UDP is already done
 // by chrome extension permission model.
 bool ChromeContentRendererClient::ShouldEnforceWebRTCRoutingPreferences() {
 #if defined(ENABLE_EXTENSIONS)
   return !IsStandaloneExtensionProcess();
 #else
   return true;
 #endif
 }