Move the dispatching of extension messages out of RenderThread. This also moves a bunch of exten...

chrome/renderer/render_thread.cc

 // Copyright (c) 2011 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/render_thread.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/stats_table.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/threading/thread_local.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_localization_peer.h"
-#include "chrome/common/extensions/extension_messages.h"
-#include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/spellcheck_messages.h"
 #include "chrome/common/safebrowsing_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/automation/dom_automation_v8_extension.h"
 #include "chrome/renderer/devtools_agent_filter.h"
-#include "chrome/renderer/extension_groups.h"
-#include "chrome/renderer/extensions/chrome_app_bindings.h"
-#include "chrome/renderer/extensions/event_bindings.h"
-#include "chrome/renderer/extensions/extension_process_bindings.h"
-#include "chrome/renderer/extensions/js_only_v8_extensions.h"
-#include "chrome/renderer/extensions/renderer_extension_bindings.h"
+#include "chrome/renderer/extensions/extension_dispatcher.h"
 #include "chrome/renderer/external_extension.h"
 #include "chrome/renderer/loadtimes_extension_bindings.h"
 #include "chrome/renderer/net/renderer_net_predictor.h"
 #include "chrome/renderer/render_process_impl.h"
 #include "chrome/renderer/renderer_histogram_snapshots.h"
 #include "chrome/renderer/safe_browsing/phishing_classifier_delegate.h"
 #include "chrome/renderer/search_extension.h"
 #include "chrome/renderer/searchbox_extension.h"
 #include "chrome/renderer/security_filter_peer.h"
 #include "chrome/renderer/spellchecker/spellcheck.h"
-#include "chrome/renderer/user_script_slave.h"
 #include "content/common/appcache/appcache_dispatcher.h"
 #include "content/common/database_messages.h"
 #include "content/common/db_message_filter.h"
 #include "content/common/dom_storage_messages.h"
 #include "content/common/gpu_messages.h"
 #include "content/common/plugin_messages.h"
 #include "content/common/renderer_preferences.h"
 #include "content/common/resource_dispatcher.h"
 #include "content/common/resource_messages.h"
 #include "content/common/view_messages.h"
 #include "content/common/web_database_observer_impl.h"
 #include "content/plugin/npobject_util.h"
+#include "content/renderer/content_renderer_client.h"
 #include "content/renderer/cookie_message_filter.h"
 #include "content/renderer/gpu_channel_host.h"
 #include "content/renderer/gpu_video_service_host.h"
 #include "content/renderer/indexed_db_dispatcher.h"
 #include "content/renderer/plugin_channel_host.h"
 #include "content/renderer/render_process_observer.h"
 #include "content/renderer/render_view.h"
 #include "content/renderer/render_view_visitor.h"
 #include "content/renderer/renderer_webidbfactory_impl.h"
 #include "content/renderer/renderer_webkitclient_impl.h"
@@ skipping 50 matching lines @@
 using WebKit::WebRuntimeFeatures;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebScriptController;
 using WebKit::WebString;
 using WebKit::WebStorageEventDispatcher;
 using WebKit::WebView;
 
 namespace {
 static const unsigned int kCacheStatsDelayMS = 2000 /* milliseconds */;
 static const double kInitialIdleHandlerDelayS = 1.0 /* seconds */;
-static const double kInitialExtensionIdleHandlerDelayS = 5.0 /* seconds */;
-static const int64 kMaxExtensionIdleHandlerDelayS = 5*60 /* seconds */;
 
 // Keep the global RenderThread in a TLS slot so it is impossible to access
 // incorrectly from the wrong thread.
 static base::LazyInstance<base::ThreadLocalPointer<RenderThread> > lazy_tls(
     base::LINKER_INITIALIZED);
 
 #if defined(OS_POSIX)
 class SuicideOnChannelErrorFilter : public IPC::ChannelProxy::MessageFilter {
   void OnChannelError() {
     // On POSIX, at least, one can install an unload handler which loops
@@ skipping 134 matching lines @@
 #endif
 
   lazy_tls.Pointer()->Set(this);
 #if defined(OS_WIN)
   // If you are running plugins in this thread you need COM active but in
   // the normal case you don't.
   if (RenderProcessImpl::InProcessPlugins())
     CoInitialize(0);
 #endif
 
-  std::string type_str = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-      switches::kProcessType);
   // In single process the single process is all there is.
-  is_extension_process_ = type_str == switches::kExtensionProcess ||
-      CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess);
   is_incognito_process_ = false;
   suspend_webkit_shared_timer_ = true;
   notify_webkit_of_modal_loop_ = true;
   plugin_refresh_allowed_ = true;
   cache_stats_task_pending_ = false;
   widget_count_ = 0;
   hidden_widget_count_ = 0;
-  idle_notification_delay_in_s_ = is_extension_process_ ?
-      kInitialExtensionIdleHandlerDelayS : kInitialIdleHandlerDelayS;
+  idle_notification_delay_in_s_ = kInitialIdleHandlerDelayS;
   task_factory_.reset(new ScopedRunnableMethodFactory<RenderThread>(this));
 
   resource_dispatcher()->set_observer(new RenderResourceObserver());
 
   visited_link_slave_.reset(new VisitedLinkSlave());
-  user_script_slave_.reset(new UserScriptSlave(&extensions_));
   renderer_net_predictor_.reset(new RendererNetPredictor());
   histogram_snapshots_.reset(new RendererHistogramSnapshots());
   appcache_dispatcher_.reset(new AppCacheDispatcher(this));
   indexed_db_dispatcher_.reset(new IndexedDBDispatcher());
   spellchecker_.reset(new SpellCheck());
 
   devtools_agent_filter_ = new DevToolsAgentFilter();
   AddFilter(devtools_agent_filter_.get());
 
   db_message_filter_ = new DBMessageFilter();
   AddFilter(db_message_filter_.get());
 
   cookie_message_filter_ = new CookieMessageFilter();
   AddFilter(cookie_message_filter_.get());
 
 #if defined(OS_POSIX)
   suicide_on_channel_error_filter_ = new SuicideOnChannelErrorFilter;
   AddFilter(suicide_on_channel_error_filter_.get());
 #endif
 
+  AddObserver(new ExtensionDispatcher());
+
   TRACE_EVENT_END("RenderThread::Init", 0, "");
 }
 
 RenderThread::~RenderThread() {
   FOR_EACH_OBSERVER(
       RenderProcessObserver, observers_, OnRenderProcessShutdown());
 
   // Wait for all databases to be closed.
   if (web_database_observer_impl_.get())
     web_database_observer_impl_->WaitForAllDatabasesToClose();
@@ skipping 34 matching lines @@
       RenderView* view = RenderView::FromWebView(frame->view());
       if (view)
         routing_id = view->routing_id();
     }
   } else {
     DLOG(WARNING) << "Not called within a script context!";
   }
   return routing_id;
 }
 
-const ExtensionSet* RenderThread::GetExtensions() const {
-  return &extensions_;
-}
-
 bool RenderThread::Send(IPC::Message* msg) {
   // Certain synchronous messages cannot always be processed synchronously by
   // the browser, e.g., Chrome frame communicating with the embedding browser.
   // This could cause a complete hang of Chrome if a windowed plug-in is trying
   // to communicate with the renderer thread since the browser's UI thread
   // could be stuck (within a Windows API call) trying to synchronously
   // communicate with the plug-in.  The remedy is to pump messages on this
   // thread while the browser is processing this request. This creates an
   // opportunity for re-entrancy into WebKit, so we need to take care to disable
   // callbacks, timers, and pending network loads that could trigger such
@@ skipping 101 matching lines @@
   channel()->AddFilter(filter);
 }
 
 void RenderThread::RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) {
   channel()->RemoveFilter(filter);
 }
 
 void RenderThread::WidgetHidden() {
   DCHECK(hidden_widget_count_ < widget_count_);
   hidden_widget_count_++;
-  if (!is_extension_process_ &&
-      widget_count_ && hidden_widget_count_ == widget_count_)
+
+  if (!content::GetContentClient()->renderer()->
+          RunIdleHandlerWhenWidgetsHidden()) {
+    return;
+  }
+
+  if (widget_count_ && hidden_widget_count_ == widget_count_)
     ScheduleIdleHandler(kInitialIdleHandlerDelayS);
 }
 
 void RenderThread::WidgetRestored() {
   DCHECK_GT(hidden_widget_count_, 0);
   hidden_widget_count_--;
-  if (!is_extension_process_)
-    idle_timer_.Stop();
-}
+  if (!content::GetContentClient()->renderer()->
+          RunIdleHandlerWhenWidgetsHidden()) {
+    return;
+  }
 
-bool RenderThread::IsExtensionProcess() const {
-  return is_extension_process_;
+  idle_timer_.Stop();
 }
 
 bool RenderThread::IsIncognitoProcess() const {
   return is_incognito_process_;
 }
 
 void RenderThread::AddObserver(RenderProcessObserver* observer) {
   observers_.AddObserver(observer);
 }
 
@@ skipping 38 matching lines @@
   RenderViewContentSettingsSetter setter(url, content_settings);
   RenderView::ForEach(&setter);
 }
 
 void RenderThread::OnSetZoomLevelForCurrentURL(const GURL& url,
                                                double zoom_level) {
   RenderViewZoomer zoomer(url, zoom_level);
   RenderView::ForEach(&zoomer);
 }
 
-void RenderThread::OnUpdateUserScripts(base::SharedMemoryHandle scripts) {
-  DCHECK(base::SharedMemory::IsHandleValid(scripts)) << "Bad scripts handle";
-  user_script_slave_->UpdateScripts(scripts);
-  UpdateActiveExtensions();
-}
-
-void RenderThread::OnSetExtensionFunctionNames(
-    const std::vector<std::string>& names) {
-  ExtensionProcessBindings::SetFunctionNames(names);
-}
-
-void RenderThread::OnExtensionLoaded(const ExtensionMsg_Loaded_Params& params) {
-  scoped_refptr<const Extension> extension(params.ConvertToExtension());
-  if (!extension) {
-    // This can happen if extension parsing fails for any reason. One reason
-    // this can legitimately happen is if the
-    // --enable-experimental-extension-apis changes at runtime, which happens
-    // during browser tests. Existing renderers won't know about the change.
-    return;
-  }
-
-  extensions_.Insert(extension);
-}
-
-void RenderThread::OnSetExtensionScriptingWhitelist(
-    const Extension::ScriptingWhitelist& extension_ids) {
-  Extension::SetScriptingWhitelist(extension_ids);
-}
-
-void RenderThread::OnExtensionUnloaded(const std::string& id) {
-  extensions_.Remove(id);
-}
-
-void RenderThread::OnPageActionsUpdated(
-    const std::string& extension_id,
-    const std::vector<std::string>& page_actions) {
-  ExtensionProcessBindings::SetPageActions(extension_id, page_actions);
-}
-
-void RenderThread::OnExtensionSetAPIPermissions(
-    const std::string& extension_id,
-    const std::set<std::string>& permissions) {
-  ExtensionProcessBindings::SetAPIPermissions(extension_id, permissions);
-
-  // This is called when starting a new extension page, so start the idle
-  // handler ticking.
-  ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayS);
-
-  UpdateActiveExtensions();
-}
-
-void RenderThread::OnExtensionSetHostPermissions(
-    const GURL& extension_url, const std::vector<URLPattern>& permissions) {
-  ExtensionProcessBindings::SetHostPermissions(extension_url, permissions);
-}
-
 void RenderThread::OnDOMStorageEvent(
     const DOMStorageMsg_Event_Params& params) {
   if (!dom_storage_event_dispatcher_.get())
     dom_storage_event_dispatcher_.reset(WebStorageEventDispatcher::create());
   dom_storage_event_dispatcher_->dispatchStorageEvent(params.key,
       params.old_value, params.new_value, params.origin, params.url,
       params.storage_type == DOM_STORAGE_LOCAL);
 }
 
 bool RenderThread::OnControlMessageReceived(const IPC::Message& msg) {
@@ skipping 26 matching lines @@
     // is there a new non-windows message I should add here?
     IPC_MESSAGE_HANDLER(ViewMsg_New, OnCreateNewView)
     IPC_MESSAGE_HANDLER(ViewMsg_SetCacheCapacities, OnSetCacheCapacities)
     IPC_MESSAGE_HANDLER(ViewMsg_ClearCache, OnClearCache)
     IPC_MESSAGE_HANDLER(ViewMsg_GetRendererHistograms, OnGetRendererHistograms)
 #if defined(USE_TCMALLOC)
     IPC_MESSAGE_HANDLER(ViewMsg_GetRendererTcmalloc, OnGetRendererTcmalloc)
 #endif
     IPC_MESSAGE_HANDLER(ViewMsg_GetV8HeapStats, OnGetV8HeapStats)
     IPC_MESSAGE_HANDLER(ViewMsg_GetCacheResourceStats, OnGetCacheResourceStats)
-    IPC_MESSAGE_HANDLER(ViewMsg_UserScripts_UpdatedScripts, OnUpdateUserScripts)
-    // TODO(rafaelw): create an ExtensionDispatcher that handles extension
-    // messages seperates their handling from the RenderThread.
-    IPC_MESSAGE_HANDLER(ExtensionMsg_MessageInvoke, OnExtensionMessageInvoke)
-    IPC_MESSAGE_HANDLER(ExtensionMsg_SetFunctionNames,
-                        OnSetExtensionFunctionNames)
-    IPC_MESSAGE_HANDLER(ExtensionMsg_Loaded, OnExtensionLoaded)
-    IPC_MESSAGE_HANDLER(ExtensionMsg_Unloaded, OnExtensionUnloaded)
-    IPC_MESSAGE_HANDLER(ExtensionMsg_SetScriptingWhitelist,
-                        OnSetExtensionScriptingWhitelist)
     IPC_MESSAGE_HANDLER(ViewMsg_PurgeMemory, OnPurgeMemory)
     IPC_MESSAGE_HANDLER(ViewMsg_PurgePluginListCache, OnPurgePluginListCache)
-    IPC_MESSAGE_HANDLER(ExtensionMsg_UpdatePageActions, OnPageActionsUpdated)
-    IPC_MESSAGE_HANDLER(ExtensionMsg_SetAPIPermissions,
-                        OnExtensionSetAPIPermissions)
-    IPC_MESSAGE_HANDLER(ExtensionMsg_SetHostPermissions,
-                        OnExtensionSetHostPermissions)
     IPC_MESSAGE_HANDLER(DOMStorageMsg_Event, OnDOMStorageEvent)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_Init, OnInitSpellChecker)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_WordAdded, OnSpellCheckWordAdded)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_EnableAutoSpellCorrect,
                         OnSpellCheckEnableAutoSpellCorrect)
     IPC_MESSAGE_HANDLER(GpuMsg_GpuChannelEstablished, OnGpuChannelEstablished)
     IPC_MESSAGE_HANDLER(SafeBrowsingMsg_SetPhishingModel, OnSetPhishingModel)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ skipping 113 matching lines @@
 
 void RenderThread::ClearCache(bool preserve_ssl_host_info) {
   int rv;
   Send(new ViewHostMsg_ClearCache(preserve_ssl_host_info, &rv));
 }
 
 void RenderThread::EnableSpdy(bool enable) {
   Send(new ViewHostMsg_EnableSpdy(enable));
 }
 
-void RenderThread::UpdateActiveExtensions() {
-  // In single-process mode, the browser process reports the active extensions.
-  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess))
-    return;
-
-  std::set<std::string> active_extensions;
-  user_script_slave_->GetActiveExtensions(&active_extensions);
-  ExtensionProcessBindings::GetActiveExtensions(&active_extensions);
-  child_process_logging::SetActiveExtensions(active_extensions);
-}
-
 void RenderThread::EstablishGpuChannel() {
   if (gpu_channel_.get()) {
     // Do nothing if we already have a GPU channel or are already
     // establishing one.
     if (gpu_channel_->state() == GpuChannelHost::kUnconnected ||
         gpu_channel_->state() == GpuChannelHost::kConnected)
       return;
 
     // Recreate the channel if it has been lost.
     if (gpu_channel_->state() == GpuChannelHost::kLost)
@@ skipping 38 matching lines @@
 
 static void AddHistogramSample(void* hist, int sample) {
   base::Histogram* histogram = static_cast<base::Histogram*>(hist);
   histogram->Add(sample);
 }
 
 void RenderThread::EnsureWebKitInitialized() {
   if (webkit_client_.get())
     return;
 
-  // For extensions, we want to ensure we call the IdleHandler every so often,
-  // even if the extension keeps up activity.
-  if (is_extension_process_) {
-    forced_idle_timer_.Start(
-        base::TimeDelta::FromSeconds(kMaxExtensionIdleHandlerDelayS),
-        this, &RenderThread::IdleHandler);
-  }
-
   v8::V8::SetCounterFunction(base::StatsTable::FindLocation);
   v8::V8::SetCreateHistogramFunction(CreateHistogram);
   v8::V8::SetAddHistogramSampleFunction(AddHistogramSample);
 
   webkit_client_.reset(new RendererWebKitClientImpl);
   WebKit::initialize(webkit_client_.get());
 
   WebScriptController::enableV8SingleThreadMode();
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   webkit_glue::EnableWebCoreLogChannels(
       command_line.GetSwitchValueASCII(switches::kWebCoreLogChannels));
 
   // chrome: pages should not be accessible by normal content, and should
   // also be unable to script anything but themselves (to help limit the damage
   // that a corrupt chrome: page could cause).
   WebString chrome_ui_scheme(ASCIIToUTF16(chrome::kChromeUIScheme));
   WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(chrome_ui_scheme);
 
   // chrome-extension: resources shouldn't trigger insecure content warnings.
   WebString extension_scheme(ASCIIToUTF16(chrome::kExtensionScheme));
   WebSecurityPolicy::registerURLSchemeAsSecure(extension_scheme);
 
-  RegisterExtension(extensions_v8::LoadTimesExtension::Get(), false);
-  RegisterExtension(extensions_v8::ChromeAppExtension::Get(), false);
-  RegisterExtension(extensions_v8::ExternalExtension::Get(), false);
-  RegisterExtension(extensions_v8::SearchBoxExtension::Get(), false);
+  RegisterExtension(extensions_v8::LoadTimesExtension::Get());
+  RegisterExtension(extensions_v8::ExternalExtension::Get());
+  RegisterExtension(extensions_v8::SearchBoxExtension::Get());
   v8::Extension* search_extension = extensions_v8::SearchExtension::Get();
   // search_extension is null if not enabled.
   if (search_extension)
-    RegisterExtension(search_extension, false);
+    RegisterExtension(search_extension);
 
   if (command_line.HasSwitch(switches::kEnableBenchmarking))
-    RegisterExtension(extensions_v8::BenchmarkingExtension::Get(), false);
+    RegisterExtension(extensions_v8::BenchmarkingExtension::Get());
 
   if (command_line.HasSwitch(switches::kPlaybackMode) ||
       command_line.HasSwitch(switches::kRecordMode) ||
       command_line.HasSwitch(switches::kNoJsRandomness)) {
-    RegisterExtension(extensions_v8::PlaybackExtension::Get(), false);
+    RegisterExtension(extensions_v8::PlaybackExtension::Get());
   }
 
   if (command_line.HasSwitch(switches::kDomAutomationController))
-    RegisterExtension(DomAutomationV8Extension::Get(), false);
-
-  // Add v8 extensions related to chrome extensions.
-  RegisterExtension(ExtensionProcessBindings::Get(), true);
-  RegisterExtension(BaseJsV8Extension::Get(), true);
-  RegisterExtension(JsonSchemaJsV8Extension::Get(), true);
-  RegisterExtension(EventBindings::Get(), true);
-  RegisterExtension(RendererExtensionBindings::Get(), true);
-  RegisterExtension(ExtensionApiTestV8Extension::Get(), true);
+    RegisterExtension(DomAutomationV8Extension::Get());
 
   web_database_observer_impl_.reset(new WebDatabaseObserverImpl(this));
   WebKit::WebDatabase::setObserver(web_database_observer_impl_.get());
 
   WebRuntimeFeatures::enableMediaPlayer(
       RenderProcess::current()->HasInitializedMediaLibrary());
 
   WebRuntimeFeatures::enableSockets(
       !command_line.HasSwitch(switches::kDisableWebSockets));
 
@@ skipping 39 matching lines @@
       !command_line.HasSwitch(switches::kDisableDeviceOrientation));
 
   WebRuntimeFeatures::enableSpeechInput(
       !command_line.HasSwitch(switches::kDisableSpeechInput));
 
   WebRuntimeFeatures::enableFileSystem(
       !command_line.HasSwitch(switches::kDisableFileSystem));
 
   WebRuntimeFeatures::enableJavaScriptI18NAPI(
       !command_line.HasSwitch(switches::kDisableJavaScriptI18NAPI));
+
+  FOR_EACH_OBSERVER(RenderProcessObserver, observers_, WebKitInitialized());
 }
 
 void RenderThread::IdleHandler() {
 #if (defined(OS_WIN) || defined(OS_LINUX)) && defined(USE_TCMALLOC)
   MallocExtension::instance()->ReleaseFreeMemory();
 #endif
 
   v8::V8::IdleNotification();
 
   // Schedule next invocation.
   // Dampen the delay using the algorithm:
   //    delay = delay + 1 / (delay + 2)
   // Using floor(delay) has a dampening effect such as:
   //    1s, 1, 1, 2, 2, 2, 2, 3, 3, ...
   // Note that idle_notification_delay_in_s_ would be reset to
   // kInitialIdleHandlerDelayS in RenderThread::WidgetHidden.
   ScheduleIdleHandler(idle_notification_delay_in_s_ +
                       1.0 / (idle_notification_delay_in_s_ + 2.0));
-  if (is_extension_process_) {
-    // Dampen the forced delay as well if the extension stays idle for long
-    // periods of time.
-    int64 forced_delay_s =
-        std::max(static_cast<int64>(idle_notification_delay_in_s_),
-                 kMaxExtensionIdleHandlerDelayS);
-    forced_idle_timer_.Stop();
-    forced_idle_timer_.Start(
-        base::TimeDelta::FromSeconds(forced_delay_s),
-        this, &RenderThread::IdleHandler);
-  }
+
+  FOR_EACH_OBSERVER(RenderProcessObserver, observers_, IdleNotification());
 }
 
 void RenderThread::ScheduleIdleHandler(double initial_delay_s) {
   idle_notification_delay_in_s_ = initial_delay_s;
   idle_timer_.Stop();
   idle_timer_.Start(
       base::TimeDelta::FromSeconds(static_cast<int64>(initial_delay_s)),
       this, &RenderThread::IdleHandler);
 }
 
-void RenderThread::OnExtensionMessageInvoke(const std::string& extension_id,
-                                            const std::string& function_name,
-                                            const ListValue& args,
-                                            const GURL& event_url) {
-  RendererExtensionBindings::Invoke(
-      extension_id, function_name, args, NULL, event_url);
-
-  // Reset the idle handler each time there's any activity like event or message
-  // dispatch, for which Invoke is the chokepoint.
-  if (is_extension_process_)
-    ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayS);
-}
-
 void RenderThread::OnPurgeMemory() {
   spellchecker_.reset(new SpellCheck());
 
   EnsureWebKitInitialized();
 
   // Clear the object cache (as much as possible; some live objects cannot be
   // freed).
   WebCache::clear();
 
   // Clear the font/glyph cache.
@@ skipping 83 matching lines @@
   return file_thread_->message_loop_proxy();
 }
 
 bool RenderThread::AllowScriptExtension(const std::string& v8_extension_name,
                                         const GURL& url,
                                         int extension_group) {
   // If we don't know about it, it was added by WebCore, so we should allow it.
   if (v8_extensions_.find(v8_extension_name) == v8_extensions_.end())
     return true;
 
-  // If the V8 extension is not restricted, allow it to run anywhere.
-  bool restrict_to_extensions = v8_extensions_[v8_extension_name];
-  if (!restrict_to_extensions)
-    return true;
-
-  // Extension-only bindings should be restricted to content scripts and
-  // extension-blessed URLs.
-  if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS ||
-      extensions_.ExtensionBindingsAllowed(url)) {
-    return true;
+  ObserverListBase<RenderProcessObserver>::Iterator it(observers_);
+  RenderProcessObserver* observer;
+  while ((observer = it.GetNext()) != NULL) {
+    if (observer->AllowScriptExtension(v8_extension_name, url, extension_group))
+      return true;
   }
 
   return false;
 }
 
-void RenderThread::RegisterExtension(v8::Extension* extension,
-                                     bool restrict_to_extensions) {
+void RenderThread::RegisterExtension(v8::Extension* extension) {
   WebScriptController::registerExtension(extension);
-  v8_extensions_[extension->name()] = restrict_to_extensions;
+  v8_extensions_.insert(extension->name());
 }