Prepare declarativeContent API for new script injection feature. Added Javascript types and functio…

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/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/content_watcher.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/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;
@@ skipping 11 matching lines @@
 namespace base {
 class DictionaryValue;
 class ListValue;
 }
 
 namespace content {
 class RenderThread;
 }
 
 namespace extensions {
-class ContentWatcher;
 class DispatcherDelegate;
 class Extension;
 class FilteredEventRouter;
 class ManifestPermissionSet;
 class RequestSender;
 class ScriptContext;
 class UserScriptSlave;
 struct Message;
 
+// Map from RuleRegistry::event_name to associated ContentWatcher.
+typedef std::map< std::string, linked_ptr<ContentWatcher> > ContentWatcherMap;
+
 // Dispatches extension control messages sent to the renderer and stores
 // renderer extension related state.
 class Dispatcher : public content::RenderProcessObserver {
  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(); }
 
   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.
@@ skipping 83 matching lines @@
   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 webrequest_used);
 
+  // Handler for ExtensionMsg_WatchPages.
+  void OnWatchPages(const std::string& event_name,
+                    const WatchedPagesRecipient& watched_pages_recipient,
+                    const std::vector<std::string>& css_selectors);
+
   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 48 matching lines @@
   ExtensionSet extensions_;
 
   // 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_;
+  // Content watchers, keyed by event_name.
+  ContentWatcherMap content_watchers_;
 
   scoped_ptr<UserScriptSlave> user_script_slave_;
 
   // 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_;
 
@@ skipping 17 matching lines @@
 
   // True once WebKit has been initialized (and it is therefore safe to poke).
   bool is_webkit_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(Dispatcher);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_RENDERER_DISPATCHER_H_