Implement <webview>.addContentScript/removeContentScript API [2]

extensions/browser/user_script_loader.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_BROWSER_USER_SCRIPT_LOADER_H_
 #define EXTENSIONS_BROWSER_USER_SCRIPT_LOADER_H_
 
 #include <map>
 #include <set>
 
@@ skipping 11 matching lines @@
 class SharedMemory;
 }
 
 namespace content {
 class BrowserContext;
 class RenderProcessHost;
 }
 
 namespace extensions {
 
 class ContentVerifier;

[Devlin, 2015/04/24 17:50:59]

This is no longer needed.

[Xi Han, 2015/04/24 18:28:54]

Move to ExtensionUserScriptLoader.

 
 // Manages one "logical unit" of user scripts in shared memory by constructing a
 // new shared memory region when the set of scripts changes. Also notifies
 // renderers of new shared memory region when new renderers appear, or when
 // script reloading completes. Script loading lives on the UI thread. Instances
 // of this class are embedded within classes with names ending in
 // UserScriptMaster. These "master" classes implement the strategy for which
 // scripts to load/unload on this logical unit of scripts.
 class UserScriptLoader : public content::NotificationObserver {
  public:
-  using PathAndDefaultLocale = std::pair<base::FilePath, std::string>;
-  using HostsInfo = std::map<HostID, PathAndDefaultLocale>;
-
-  using SubstitutionMap = std::map<std::string, std::string>;
-  using LoadUserScriptsContentFunction =
-      base::Callback<bool(const HostID&,
-                          UserScript::File*,
-                          const SubstitutionMap*,
-                          const scoped_refptr<ContentVerifier>&)>;
+  using LoadScriptsCallback =
+      base::Callback<void(scoped_ptr<UserScriptList>,
+                          scoped_ptr<base::SharedMemory>)>;
 
   // Parses the includes out of |script| and returns them in |includes|.
   static bool ParseMetadataHeader(const base::StringPiece& script_text,
                                   UserScript* script);
 
   UserScriptLoader(content::BrowserContext* browser_context,
-                   const HostID& host_id,
-                   const scoped_refptr<ContentVerifier>& content_verifier);
+                   const HostID& host_id);
   ~UserScriptLoader() override;
 
-  // A wrapper around the method to load user scripts, which is normally run on
-  // the file thread. Exposed only for tests.
-  void LoadScriptsForTest(UserScriptList* user_scripts);
-
   // Add |scripts| to the set of scripts managed by this loader.
   void AddScripts(const std::set<UserScript>& scripts);
 
+  // Add |scripts| to the set of scripts managed by this loader.
+  // The fetch of the content of the script starts URL request
+  // to the associated render specified by
+  // |render_process_id, render_view_id|.
+  // TODO(hanxi): The renderer information doesn't really belong in this base
+  // class, but it's not an easy fix.
+  virtual void AddScripts(const std::set<UserScript>& scripts,
+                          int render_process_id,
+                          int render_view_id);
+
   // Remove |scripts| from the set of scripts managed by this loader.
   void RemoveScripts(const std::set<UserScript>& scripts);
 
   // Clears the set of scripts managed by this loader.
   void ClearScripts();
 
   // Initiates procedure to start loading scripts on the file thread.
   void StartLoad();
 
   // Returns true if we have any scripts ready.
   bool scripts_ready() const { return shared_memory_.get() != NULL; }
 
+  // Pickle user scripts and return pointer to the shared memory.
+  static scoped_ptr<base::SharedMemory> Serialize(
+      const extensions::UserScriptList& scripts);
+
  protected:
-  // Updates |hosts_info_| to contain info for each element of
-  // |changed_hosts_|.
-  virtual void UpdateHostsInfo(const std::set<HostID>& changed_hosts) = 0;
-
-  // Returns a function pointer of a static funcion to load user scripts.
-  // Derived classes can specify their ways to load scripts in the static
-  // function they return.
-  // Note: It has to be safe to call multiple times.
-  virtual LoadUserScriptsContentFunction GetLoadUserScriptsFunction() = 0;
-
-  // Adds the |host_id, location| to the |hosts_info_| map.
-  // Only inserts the entry to the map when the given host_id doesn't
-  // exists.
-  void AddHostInfo(const HostID& host_id, const PathAndDefaultLocale& location);
-
-  // Removes the entries with the given host_id from the |hosts_info_| map.
-  void RemoveHostInfo(const HostID& host_id);
+  // Allows the derived classes have different ways to load user scripts.
+  virtual void LoadScripts(scoped_ptr<UserScriptList> user_scripts,
+                           const std::set<HostID>& changed_hosts,
+                           const std::set<int>& added_script_ids,
+                           LoadScriptsCallback callback) = 0;
 
   // Sets the flag if the initial set of hosts has finished loading; if it's
   // set to be true, calls AttempLoad() to bootstrap.
   void SetReady(bool ready);
 
   content::BrowserContext* browser_context() const { return browser_context_; }
   const HostID& host_id() const { return host_id_; }
 
  private:
   // content::NotificationObserver implementation.
@@ skipping 28 matching lines @@
 
   // Manages our notification registrations.
   content::NotificationRegistrar registrar_;
 
   // Contains the scripts that were found the last time scripts were updated.
   scoped_ptr<base::SharedMemory> shared_memory_;
 
   // List of scripts from currently-installed extensions we should load.
   scoped_ptr<UserScriptList> user_scripts_;
 
-  // Maps host info needed for localization to a host ID.
-  HostsInfo hosts_info_;
-
   // The mutually-exclusive sets of scripts that were added or removed since the
   // last script load.
   std::set<UserScript> added_scripts_;
   std::set<UserScript> removed_scripts_;
 
   // Indicates whether the the collection of scripts should be cleared before
   // additions and removals on the next script load.
   bool clear_scripts_;
 
   // The IDs of the extensions which changed in the last update sent to the
@@ skipping 11 matching lines @@
   // Whether or not we are currently loading.
   bool is_loading_;
 
   // The browser_context for which the scripts managed here are installed.
   content::BrowserContext* browser_context_;
 
   // ID of the host that owns these scripts, if any. This is only set to a
   // non-empty value for declarative user script shared memory regions.
   HostID host_id_;
 
-  // Manages content verification of the loaded user scripts.
-  scoped_refptr<ContentVerifier> content_verifier_;
-
   base::WeakPtrFactory<UserScriptLoader> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UserScriptLoader);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_USER_SCRIPT_LOADER_H_