src/chrome/browser/extensions/user_script_master.h

   1 // Copyright (c) 2012 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 CHROME_BROWSER_EXTENSIONS_USER_SCRIPT_MASTER_H_
   6 #define CHROME_BROWSER_EXTENSIONS_USER_SCRIPT_MASTER_H_
   7
   8 #include <map>
   9 #include <string>
  10
  11 #include "base/compiler_specific.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/scoped_observer.h"
  14 #include "content/public/browser/browser_thread.h"
  15 #include "content/public/browser/notification_observer.h"
  16 #include "content/public/browser/notification_registrar.h"
  17 #include "extensions/browser/extension_registry_observer.h"
  18 #include "extensions/common/extension_messages.h"
  19 #include "extensions/common/extension_set.h"
  20 #include "extensions/common/user_script.h"
  21
  22 namespace content {
  23 class RenderProcessHost;
  24 }
  25
  26 class Profile;
  27
  28 namespace extensions {
  29
  30 class ContentVerifier;
  31 class ExtensionRegistry;
  32
  33 typedef std::map<std::string, ExtensionSet::ExtensionPathAndDefaultLocale>
  34     ExtensionsInfo;
  35
  36 // Manages a segment of shared memory that contains the user scripts the user
  37 // has installed.  Lives on the UI thread.
  38 class UserScriptMaster : public base::RefCountedThreadSafe<UserScriptMaster>,
  39                          public content::NotificationObserver,
  40                          public ExtensionRegistryObserver {
  41  public:
  42   explicit UserScriptMaster(Profile* profile);
  43
  44   // Kicks off a process on the file thread to reload scripts from disk
  45   // into a new chunk of shared memory and notify renderers.
  46   virtual void StartLoad();
  47
  48   // Gets the segment of shared memory for the scripts.
  49   base::SharedMemory* GetSharedMemory() const {
  50     return shared_memory_.get();
  51   }
  52
  53   // Called by the script reloader when new scripts have been loaded.
  54   void NewScriptsAvailable(scoped_ptr<base::SharedMemory> handle);
  55
  56   // Return true if we have any scripts ready.
  57   bool ScriptsReady() const { return shared_memory_.get() != NULL; }
  58
  59   // Returns the content verifier for our browser context.
  60   ContentVerifier* content_verifier();
  61
  62  protected:
  63   friend class base::RefCountedThreadSafe<UserScriptMaster>;
  64
  65   virtual ~UserScriptMaster();
  66
  67  public:
  68   // We reload user scripts on the file thread to prevent blocking the UI.
  69   // ScriptReloader lives on the file thread and does the reload
  70   // work, and then sends a message back to its master with a new SharedMemory*.
  71   // ScriptReloader is the worker that manages running the script load
  72   // on the file thread. It must be created on, and its public API must only be
  73   // called from, the master's thread.
  74   class ScriptReloader
  75       : public base::RefCountedThreadSafe<UserScriptMaster::ScriptReloader> {
  76    public:
  77     // Parses the includes out of |script| and returns them in |includes|.
  78     static bool ParseMetadataHeader(const base::StringPiece& script_text,
  79                                     UserScript* script);
  80
  81     explicit ScriptReloader(UserScriptMaster* master);
  82
  83     // Start loading of scripts.
  84     // Will always send a message to the master upon completion.
  85     void StartLoad(const UserScriptList& external_scripts,
  86                    const ExtensionsInfo& extensions_info);
  87
  88     // The master is going away; don't call it back.
  89     void DisownMaster() {
  90       master_ = NULL;
  91     }
  92
  93    private:
  94     FRIEND_TEST_ALL_PREFIXES(UserScriptMasterTest, SkipBOMAtTheBeginning);
  95     FRIEND_TEST_ALL_PREFIXES(UserScriptMasterTest, LeaveBOMNotAtTheBeginning);
  96     friend class base::RefCountedThreadSafe<UserScriptMaster::ScriptReloader>;
  97
  98     ~ScriptReloader();
  99
 100     // Where functions are run:
 101     //    master          file
 102     //   StartLoad   ->  RunLoad
 103     //                     LoadUserScripts()
 104     // NotifyMaster  <-  RunLoad
 105
 106     // Runs on the master thread.
 107     // Notify the master that new scripts are available.
 108     void NotifyMaster(scoped_ptr<base::SharedMemory> memory);
 109
 110     // Runs on the File thread.
 111     // Load the specified user scripts, calling NotifyMaster when done.
 112     // |user_scripts| is intentionally passed by value so its lifetime isn't
 113     // tied to the caller.
 114     void RunLoad(const UserScriptList& user_scripts);
 115
 116     void LoadUserScripts(UserScriptList* user_scripts);
 117
 118     // Uses extensions_info_ to build a map of localization messages.
 119     // Returns NULL if |extension_id| is invalid.
 120     SubstitutionMap* GetLocalizationMessages(const std::string& extension_id);
 121
 122     // A pointer back to our master.
 123     // May be NULL if DisownMaster() is called.
 124     UserScriptMaster* master_;
 125
 126     // Maps extension info needed for localization to an extension ID.
 127     ExtensionsInfo extensions_info_;
 128
 129     // The message loop to call our master back on.
 130     // Expected to always outlive us.
 131     content::BrowserThread::ID master_thread_id_;
 132
 133     scoped_refptr<ContentVerifier> verifier_;
 134
 135     DISALLOW_COPY_AND_ASSIGN(ScriptReloader);
 136   };
 137
 138  private:
 139   // content::NotificationObserver implementation.
 140   virtual void Observe(int type,
 141                        const content::NotificationSource& source,
 142                        const content::NotificationDetails& details) OVERRIDE;
 143
 144   // ExtensionRegistryObserver implementation.
 145   virtual void OnExtensionLoaded(content::BrowserContext* browser_context,
 146                                  const Extension* extension) OVERRIDE;
 147   virtual void OnExtensionUnloaded(
 148       content::BrowserContext* browser_context,
 149       const Extension* extension,
 150       UnloadedExtensionInfo::Reason reason) OVERRIDE;
 151
 152   // Sends the renderer process a new set of user scripts. If
 153   // |changed_extensions| is not empty, this signals that only the scripts from
 154   // those extensions should be updated. Otherwise, all extensions will be
 155   // updated.
 156   void SendUpdate(content::RenderProcessHost* process,
 157                   base::SharedMemory* shared_memory,
 158                   const std::set<std::string>& changed_extensions);
 159
 160   // Manages our notification registrations.
 161   content::NotificationRegistrar registrar_;
 162
 163   // We hang on to our pointer to know if we've already got one running.
 164   scoped_refptr<ScriptReloader> script_reloader_;
 165
 166   // Contains the scripts that were found the last time scripts were updated.
 167   scoped_ptr<base::SharedMemory> shared_memory_;
 168
 169   // List of scripts from currently-installed extensions we should load.
 170   UserScriptList user_scripts_;
 171
 172   // Maps extension info needed for localization to an extension ID.
 173   ExtensionsInfo extensions_info_;
 174
 175   // The IDs of the extensions which have changed since the last update sent to
 176   // the renderer.
 177   std::set<std::string> changed_extensions_;
 178
 179   // If the extensions service has finished loading its initial set of
 180   // extensions.
 181   bool extensions_service_ready_;
 182
 183   // If list of user scripts is modified while we're loading it, we note
 184   // that we're currently mid-load and then start over again once the load
 185   // finishes.  This boolean tracks whether another load is pending.
 186   bool pending_load_;
 187
 188   // The profile for which the scripts managed here are installed.
 189   Profile* profile_;
 190
 191   // Listen to extension load, unloaded notifications.
 192   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
 193       extension_registry_observer_;
 194
 195   DISALLOW_COPY_AND_ASSIGN(UserScriptMaster);
 196 };
 197
 198 }  // namespace extensions
 199
 200 #endif  // CHROME_BROWSER_EXTENSIONS_USER_SCRIPT_MASTER_H_