extensions/browser/user_script_loader.h

   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_BROWSER_USER_SCRIPT_LOADER_H_
   6 #define EXTENSIONS_BROWSER_USER_SCRIPT_LOADER_H_
   7
   8 #include <map>
   9 #include <set>
  10
  11 #include "base/compiler_specific.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/memory/shared_memory.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/scoped_observer.h"
  16 #include "content/public/browser/notification_observer.h"
  17 #include "content/public/browser/notification_registrar.h"
  18 #include "extensions/common/host_id.h"
  19 #include "extensions/common/user_script.h"
  20
  21 namespace base {
  22 class SharedMemory;
  23 }
  24
  25 namespace content {
  26 class BrowserContext;
  27 class RenderProcessHost;
  28 }
  29
  30 namespace extensions {
  31
  32 class ContentVerifier;
  33
  34 // Manages one "logical unit" of user scripts in shared memory by constructing a
  35 // new shared memory region when the set of scripts changes. Also notifies
  36 // renderers of new shared memory region when new renderers appear, or when
  37 // script reloading completes. Script loading lives on the UI thread. Instances
  38 // of this class are embedded within classes with names ending in
  39 // UserScriptMaster. These "master" classes implement the strategy for which
  40 // scripts to load/unload on this logical unit of scripts.
  41 class UserScriptLoader : public content::NotificationObserver {
  42  public:
  43   using PathAndDefaultLocale = std::pair<base::FilePath, std::string>;
  44   using HostsInfo = std::map<HostID, PathAndDefaultLocale>;
  45
  46   using SubstitutionMap = std::map<std::string, std::string>;
  47   using LoadUserScriptsContentFunction =
  48       base::Callback<bool(const HostID&,
  49                           UserScript::File*,
  50                           const SubstitutionMap*,
  51                           const scoped_refptr<ContentVerifier>&)>;
  52
  53   // Parses the includes out of |script| and returns them in |includes|.
  54   static bool ParseMetadataHeader(const base::StringPiece& script_text,
  55                                   UserScript* script);
  56
  57   UserScriptLoader(content::BrowserContext* browser_context,
  58                    const HostID& host_id,
  59                    const scoped_refptr<ContentVerifier>& content_verifier);
  60   ~UserScriptLoader() override;
  61
  62   // A wrapper around the method to load user scripts, which is normally run on
  63   // the file thread. Exposed only for tests.
  64   void LoadScriptsForTest(UserScriptList* user_scripts);
  65
  66   // Add |scripts| to the set of scripts managed by this loader.
  67   void AddScripts(const std::set<UserScript>& scripts);
  68
  69   // Remove |scripts| from the set of scripts managed by this loader.
  70   void RemoveScripts(const std::set<UserScript>& scripts);
  71
  72   // Clears the set of scripts managed by this loader.
  73   void ClearScripts();
  74
  75   // Initiates procedure to start loading scripts on the file thread.
  76   void StartLoad();
  77
  78   // Returns true if we have any scripts ready.
  79   bool scripts_ready() const { return shared_memory_.get() != NULL; }
  80
  81  protected:
  82   // Updates |hosts_info_| to contain info for each element of
  83   // |changed_hosts_|.
  84   virtual void UpdateHostsInfo(const std::set<HostID>& changed_hosts) = 0;
  85
  86   // Returns a function pointer of a static funcion to load user scripts.
  87   // Derived classes can specify their ways to load scripts in the static
  88   // function they return.
  89   // Note: It has to be safe to call multiple times.
  90   virtual LoadUserScriptsContentFunction GetLoadUserScriptsFunction() = 0;
  91
  92   // Adds the |host_id, location| to the |hosts_info_| map.
  93   // Only inserts the entry to the map when the given host_id doesn't
  94   // exists.
  95   void AddHostInfo(const HostID& host_id, const PathAndDefaultLocale& location);
  96
  97   // Removes the entries with the given host_id from the |hosts_info_| map.
  98   void RemoveHostInfo(const HostID& host_id);
  99
 100   // Sets the flag if the initial set of hosts has finished loading; if it's
 101   // set to be true, calls AttempLoad() to bootstrap.
 102   void SetReady(bool ready);
 103
 104   content::BrowserContext* browser_context() const { return browser_context_; }
 105   const HostID& host_id() const { return host_id_; }
 106
 107  private:
 108   // content::NotificationObserver implementation.
 109   void Observe(int type,
 110                const content::NotificationSource& source,
 111                const content::NotificationDetails& details) override;
 112
 113   // Returns whether or not it is possible that calls to AddScripts(),
 114   // RemoveScripts(), and/or ClearScripts() have caused any real change in the
 115   // set of scripts to be loaded.
 116   bool ScriptsMayHaveChanged() const;
 117
 118   // Attempts to initiate a load.
 119   void AttemptLoad();
 120
 121   // Called once we have finished loading the scripts on the file thread.
 122   void OnScriptsLoaded(scoped_ptr<UserScriptList> user_scripts,
 123                        scoped_ptr<base::SharedMemory> shared_memory);
 124
 125   // Sends the renderer process a new set of user scripts. If
 126   // |changed_hosts| is not empty, this signals that only the scripts from
 127   // those hosts should be updated. Otherwise, all hosts will be
 128   // updated.
 129   void SendUpdate(content::RenderProcessHost* process,
 130                   base::SharedMemory* shared_memory,
 131                   const std::set<HostID>& changed_hosts);
 132
 133   bool is_loading() const {
 134     // Ownership of |user_scripts_| is passed to the file thread when loading.
 135     return user_scripts_.get() == NULL;
 136   }
 137
 138   // Manages our notification registrations.
 139   content::NotificationRegistrar registrar_;
 140
 141   // Contains the scripts that were found the last time scripts were updated.
 142   scoped_ptr<base::SharedMemory> shared_memory_;
 143
 144   // List of scripts from currently-installed extensions we should load.
 145   scoped_ptr<UserScriptList> user_scripts_;
 146
 147   // Maps host info needed for localization to a host ID.
 148   HostsInfo hosts_info_;
 149
 150   // The mutually-exclusive sets of scripts that were added or removed since the
 151   // last script load.
 152   std::set<UserScript> added_scripts_;
 153   std::set<UserScript> removed_scripts_;
 154
 155   // Indicates whether the the collection of scripts should be cleared before
 156   // additions and removals on the next script load.
 157   bool clear_scripts_;
 158
 159   // The IDs of the extensions which changed in the last update sent to the
 160   // renderer.
 161   std::set<HostID> changed_hosts_;
 162
 163   // If the initial set of hosts has finished loading.
 164   bool ready_;
 165
 166   // If list of user scripts is modified while we're loading it, we note
 167   // that we're currently mid-load and then start over again once the load
 168   // finishes.  This boolean tracks whether another load is pending.
 169   bool pending_load_;
 170
 171   // Whether or not we are currently loading.
 172   bool is_loading_;
 173
 174   // The browser_context for which the scripts managed here are installed.
 175   content::BrowserContext* browser_context_;
 176
 177   // ID of the host that owns these scripts, if any. This is only set to a
 178   // non-empty value for declarative user script shared memory regions.
 179   HostID host_id_;
 180
 181   // Manages content verification of the loaded user scripts.
 182   scoped_refptr<ContentVerifier> content_verifier_;
 183
 184   base::WeakPtrFactory<UserScriptLoader> weak_factory_;
 185
 186   DISALLOW_COPY_AND_ASSIGN(UserScriptLoader);
 187 };
 188
 189 }  // namespace extensions
 190
 191 #endif  // EXTENSIONS_BROWSER_USER_SCRIPT_LOADER_H_