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