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);
   v8::Extension* search_extension = extensions_v8::SearchExtension::Get();
   // search_extension is null if not enabled.
   if (search_extension)
     RegisterExtension(search_extension, false);
 
   if (command_line.HasSwitch(switches::kEnableBenchmarking))
     RegisterExtension(extensions_v8::BenchmarkingExtension::Get(), false);
 
   if (command_line.HasSwitch(switches::kPlaybackMode) ||
       command_line.HasSwitch(switches::kRecordMode) ||
       command_line.HasSwitch(switches::kNoJsRandomness)) {
     RegisterExtension(extensions_v8::PlaybackExtension::Get(), false);
   }
 
   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);
-
   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));
 
   WebRuntimeFeatures::enableDatabase(
@@ skipping 38 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 84 matching lines @@
 }
 
 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];

[Matt Perry, 2011/03/29 00:48:29]

the restrict_to_extensions boolean is something that only the
ExtensionDispatcher-registered extensions will use. So you might consider moving
it out of this class and into ExtensionDispatcher if you want to purge extension
references from this file. Up to you, if and when you want to do this.

[jam, 2011/03/29 04:55:37]

good point, done

   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) {
   WebScriptController::registerExtension(extension);
   v8_extensions_[extension->name()] = restrict_to_extensions;
 }