1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef EXTENSIONS_RENDERER_USER_SCRIPT_SET_MANAGER_H_ 6 #define EXTENSIONS_RENDERER_USER_SCRIPT_SET_MANAGER_H_ 7 8 #include <map> 9 #include <set> 10 #include <string> 11 12 #include "base/memory/linked_ptr.h" 13 #include "base/memory/shared_memory.h" 14 #include "base/observer_list.h" 15 #include "content/public/renderer/render_process_observer.h" 16 #include "extensions/common/extension.h" 17 #include "extensions/common/user_script.h" 18 #include "extensions/renderer/user_script_set.h" 19 20 namespace IPC { 21 class Message; 22 } 23 24 namespace blink { 25 class WebFrame; 26 } 27 28 namespace extensions { 29 30 class ExtensionSet; 31 class ScriptInjection; 32 33 // Manager for separate UserScriptSets, one for each shared memory region. 34 // Regions are organized as follows: 35 // static_scripts -- contains all extensions' scripts that are statically 36 // declared in the extension manifest. 37 // programmatic_scripts -- one region per extension containing only 38 // programmatically-declared scripts, instantiated 39 // when an extension first creates a declarative rule 40 // that would, if triggered, request a script injection. 41 class UserScriptSetManager : public content::RenderProcessObserver { 42 public: 43 // Like a UserScriptSet::Observer, but automatically subscribes to all sets 44 // associated with the manager. 45 class Observer { 46 public: 47 virtual void OnUserScriptsUpdated( 48 const std::set<std::string>& changed_extensions, 49 const std::vector<UserScript*>& scripts) = 0; 50 }; 51 52 UserScriptSetManager(const ExtensionSet* extensions); 53 54 virtual ~UserScriptSetManager(); 55 56 void AddObserver(Observer* observer); 57 void RemoveObserver(Observer* observer); 58 59 // Looks up the script injection associated with |script_id| and |extension| 60 // in the context of the given |web_frame|, |tab_id|, and |url|. 61 scoped_ptr<ScriptInjection> GetInjectionForDeclarativeScript( 62 int script_id, 63 blink::WebFrame* web_frame, 64 int tab_id, 65 const GURL& url, 66 const Extension* extension); 67 68 // Put all injections from |static_scripts| and each of 69 // |programmatic_scripts_| into |injections|. 70 void GetAllInjections(ScopedVector<ScriptInjection>* injections, 71 blink::WebFrame* web_frame, 72 int tab_id, 73 UserScript::RunLocation run_location); 74 75 // Get active extension IDs from |static_scripts| and each of 76 // |programmatic_scripts_|. 77 void GetAllActiveExtensionIds(std::set<std::string>* ids) const; 78 79 const UserScriptSet* static_scripts() const { return &static_scripts_; } 80 81 private: 82 // Map for per-extension sets that may be defined programmatically. 83 typedef std::map<ExtensionId, linked_ptr<UserScriptSet> > UserScriptSetMap; 84 85 // content::RenderProcessObserver implementation. 86 virtual bool OnControlMessageReceived(const IPC::Message& message) OVERRIDE; 87 88 UserScriptSet* GetProgrammaticScriptsByExtension( 89 const ExtensionId& extensionId); 90 91 // Handle the UpdateUserScripts extension message. 92 void OnUpdateUserScripts(base::SharedMemoryHandle shared_memory, 93 const ExtensionId& extension_id, 94 const std::set<std::string>& changed_extensions); 95 96 // Scripts statically defined in extension manifests. 97 UserScriptSet static_scripts_; 98 99 // Scripts programmatically-defined through API calls (initialized and stored 100 // per-extension). 101 UserScriptSetMap programmatic_scripts_; 102 103 // The set of all known extensions. Owned by the Dispatcher. 104 const ExtensionSet* extensions_; 105 106 // The associated observers. 107 ObserverList<Observer> observers_; 108 109 DISALLOW_COPY_AND_ASSIGN(UserScriptSetManager); 110 }; 111 112 } // namespace extensions 113 114 #endif // EXTENSIONS_RENDERER_USER_SCRIPT_SET_MANAGER_H_ 115