Refactor away most of ExtensionRendererInfo

chrome/renderer/render_thread.cc

 // Copyright (c) 2010 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>
@@ skipping 260 matching lines @@
   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;
   task_factory_.reset(new ScopedRunnableMethodFactory<RenderThread>(this));
   callback_factory_.reset(new base::ScopedCallbackFactory<RenderThread>(this));
 
   visited_link_slave_.reset(new VisitedLinkSlave());
-  user_script_slave_.reset(new UserScriptSlave());
+  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();
@@ skipping 51 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 ExtensionRendererInfo* 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 166 matching lines @@
   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::OnExtensionsUpdated(
-    const ViewMsg_ExtensionsUpdated_Params& params) {
-  ExtensionRendererInfo::UpdateExtensions(params);
+void RenderThread::OnExtensionLoaded(
+    const ViewMsg_ExtensionLoaded_Params& params) {
+  scoped_refptr<const Extension> extension(params.ConvertToExtension());
+  CHECK(extension);
+  extensions_.Update(extension);
+}
+
+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,
@@ skipping 55 matching lines @@
     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(ViewMsg_ExtensionMessageInvoke,
                         OnExtensionMessageInvoke)
     IPC_MESSAGE_HANDLER(ViewMsg_Extension_SetFunctionNames,
                         OnSetExtensionFunctionNames)
-    IPC_MESSAGE_HANDLER(ViewMsg_ExtensionsUpdated,
-                        OnExtensionsUpdated)
+    IPC_MESSAGE_HANDLER(ViewMsg_ExtensionLoaded,
+                        OnExtensionLoaded)
+    IPC_MESSAGE_HANDLER(ViewMsg_ExtensionUnloaded,
+                        OnExtensionUnloaded)
     IPC_MESSAGE_HANDLER(ViewMsg_PurgeMemory, OnPurgeMemory)
     IPC_MESSAGE_HANDLER(ViewMsg_PurgePluginListCache,
                         OnPurgePluginListCache)
     IPC_MESSAGE_HANDLER(ViewMsg_Extension_UpdatePageActions,
                         OnPageActionsUpdated)
     IPC_MESSAGE_HANDLER(ViewMsg_Extension_SetAPIPermissions,
                         OnExtensionSetAPIPermissions)
     IPC_MESSAGE_HANDLER(ViewMsg_Extension_SetHostPermissions,
                         OnExtensionSetHostPermissions)
     IPC_MESSAGE_HANDLER(DOMStorageMsg_Event,
@@ skipping 496 matching lines @@
     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 ||
-      ExtensionRendererInfo::ExtensionBindingsAllowed(url)) {
+      extensions_.ExtensionBindingsAllowed(url)) {
     return true;
   }
 
   return false;
 }
 
 void RenderThread::RegisterExtension(v8::Extension* extension,
                                      bool restrict_to_extensions) {
   WebScriptController::registerExtension(extension);
   v8_extensions_[extension->name()] = restrict_to_extensions;
 }