Refactor renderer-side script injection

extensions/renderer/dispatcher.h

 // Copyright 2014 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.
 
 #ifndef EXTENSIONS_RENDERER_DISPATCHER_H_
 #define EXTENSIONS_RENDERER_DISPATCHER_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
-#include "base/memory/shared_memory.h"
+#include "base/scoped_observer.h"
 #include "base/timer/timer.h"
 #include "content/public/renderer/render_process_observer.h"
 #include "extensions/common/event_filter.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/renderer/resource_bundle_source_map.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/script_context_set.h"
+#include "extensions/renderer/user_script_injection_list.h"
 #include "extensions/renderer/v8_schema_registry.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "v8/include/v8.h"
 
 class ChromeRenderViewTest;
 class GURL;
 class ModuleSystem;
 class URLPattern;
 struct ExtensionMsg_ExternalConnectionInfo;
@@ skipping 15 matching lines @@
 }
 
 namespace extensions {
 class ContentWatcher;
 class DispatcherDelegate;
 class Extension;
 class FilteredEventRouter;
 class ManifestPermissionSet;
 class RequestSender;
 class ScriptContext;
-class UserScriptSlave;
+class ScriptInjectionManager;
 struct Message;
 
 // Dispatches extension control messages sent to the renderer and stores
 // renderer extension related state.
-class Dispatcher : public content::RenderProcessObserver {
+class Dispatcher : public content::RenderProcessObserver,
+                   public UserScriptInjectionList::Observer {
  public:
   explicit Dispatcher(DispatcherDelegate* delegate);
   virtual ~Dispatcher();
 
   const std::set<std::string>& function_names() const {
     return function_names_;
   }
 
   bool is_extension_process() const { return is_extension_process_; }
 
   const ExtensionSet* extensions() const { return &extensions_; }
 
   const ScriptContextSet& script_context_set() const {
     return script_context_set_;
   }
 
   V8SchemaRegistry* v8_schema_registry() { return v8_schema_registry_.get(); }
 
   ContentWatcher* content_watcher() { return content_watcher_.get(); }
 
-  UserScriptSlave* user_script_slave() { return user_script_slave_.get(); }
+  RequestSender* request_sender() { return request_sender_.get(); }
 
-  RequestSender* request_sender() { return request_sender_.get(); }
+  void OnRenderViewCreated(content::RenderView* render_view);
 
   bool IsExtensionActive(const std::string& extension_id) const;
 
   // Finds the extension ID for the JavaScript context associated with the
   // specified |frame| and isolated world. If |world_id| is zero, finds the
   // extension ID associated with the main world's JavaScript context. If the
   // JavaScript context isn't from an extension, returns empty string.
   std::string GetExtensionID(const blink::WebFrame* frame, int world_id);
 
   void DidCreateScriptContext(blink::WebFrame* frame,
@@ skipping 76 matching lines @@
                        const std::string& font_size);
   void OnShouldSuspend(const std::string& extension_id, int sequence_id);
   void OnSuspend(const std::string& extension_id);
   void OnTransferBlobs(const std::vector<std::string>& blob_uuids);
   void OnUnloaded(const std::string& id);
   void OnUpdatePermissions(const ExtensionMsg_UpdatePermissions_Params& params);
   void OnUpdateTabSpecificPermissions(int page_id,
                                       int tab_id,
                                       const std::string& extension_id,
                                       const URLPatternSet& origin_set);
-  void OnUpdateUserScripts(base::SharedMemoryHandle scripts,
-                           const std::set<std::string>& extension_ids);
   void OnUsingWebRequestAPI(bool adblock,
                             bool adblock_plus,
                             bool other_webrequest);
 
+  // UserScriptInjectionList::Observer implementation.
+  virtual void OnUserScriptsUpdated(
+      const std::set<std::string>& changed_extensions,
+      const std::vector<UserScript*>& scripts) OVERRIDE;
+
   void UpdateActiveExtensions();
 
   // Sets up the host permissions for |extension|.
   void InitOriginPermissions(const Extension* extension);
   void UpdateOriginPermissions(UpdatedExtensionPermissionsInfo::Reason reason,
                                const Extension* extension,
                                const URLPatternSet& origins);
 
   // Enable custom element whitelist in Apps.
   void EnableCustomElementWhiteList();
@@ skipping 50 matching lines @@
   // The IDs of extensions that failed to load, mapped to the error message
   // generated on failure.
   std::map<std::string, std::string> extension_load_errors_;
 
   // All the bindings contexts that are currently loaded for this renderer.
   // There is zero or one for each v8 context.
   ScriptContextSet script_context_set_;
 
   scoped_ptr<ContentWatcher> content_watcher_;
 
-  scoped_ptr<UserScriptSlave> user_script_slave_;
+  scoped_ptr<ScriptInjectionManager> script_injection_manager_;
 
   // Same as above, but on a longer timer and will run even if the process is
   // not idle, to ensure that IdleHandle gets called eventually.
   scoped_ptr<base::RepeatingTimer<content::RenderThread> > forced_idle_timer_;
 
   // All declared function names.
   std::set<std::string> function_names_;
 
   // The extensions and apps that are active in this process.
   std::set<std::string> active_extension_ids_;
 
   ResourceBundleSourceMap source_map_;
 
   // Cache for the v8 representation of extension API schemas.
   scoped_ptr<V8SchemaRegistry> v8_schema_registry_;
 
   // Sends API requests to the extension host.
   scoped_ptr<RequestSender> request_sender_;
 
   // The platforms system font family and size;
   std::string system_font_family_;
   std::string system_font_size_;
 
   // Mapping of port IDs to tabs. If there is no tab, the value would be -1.
   std::map<int, int> port_to_tab_id_map_;
 
   // True once WebKit has been initialized (and it is therefore safe to poke).
   bool is_webkit_initialized_;
 
+  // It is important for this to come after the ScriptInjectionManager, so that
+  // the observer is destroyed before the UserScriptInjectionList.
+  ScopedObserver<UserScriptInjectionList, UserScriptInjectionList::Observer>
+      user_script_injection_list_observer_;
+
   DISALLOW_COPY_AND_ASSIGN(Dispatcher);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_RENDERER_DISPATCHER_H_