Move DeclarativeUserScriptManager/Master and UserScriptLoader to //extensions.

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 CHROME_BROWSER_EXTENSIONS_USER_SCRIPT_LOADER_H_
-#define CHROME_BROWSER_EXTENSIONS_USER_SCRIPT_LOADER_H_
+#ifndef EXTENSIONS_BROWSER_USER_SCRIPT_LOADER_H_
+#define EXTENSIONS_BROWSER_USER_SCRIPT_LOADER_H_
 
 #include <map>
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/common/host_id.h"
 #include "extensions/common/user_script.h"
 
 namespace base {
 class SharedMemory;
 }
 
 namespace content {
 class BrowserContext;
 class RenderProcessHost;
 }
 
-class Profile;
-
 namespace extensions {
 
 class ContentVerifier;
 
 // 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>&)>;
 
   // Parses the includes out of |script| and returns them in |includes|.
   static bool ParseMetadataHeader(const base::StringPiece& script_text,
                                   UserScript* script);
 
-  UserScriptLoader(Profile* profile,
+  UserScriptLoader(content::BrowserContext* browser_context,
                    const HostID& host_id,
                    const scoped_refptr<ContentVerifier>& content_verifier);
   ~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);
@@ skipping 26 matching lines @@
   // 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);
 
   // 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);
 
-  Profile* profile() const { return profile_; }
+  content::BrowserContext* browser_context() const { return browser_context_; }
   const HostID& host_id() const { return host_id_; }
 
  private:
   // content::NotificationObserver implementation.
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
   // Returns whether or not it is possible that calls to AddScripts(),
   // RemoveScripts(), and/or ClearScripts() have caused any real change in the
@@ skipping 49 matching lines @@
   bool ready_;
 
   // If list of user scripts is modified while we're loading it, we note
   // that we're currently mid-load and then start over again once the load
   // finishes.  This boolean tracks whether another load is pending.
   bool pending_load_;
 
   // Whether or not we are currently loading.
   bool is_loading_;
 
-  // The profile for which the scripts managed here are installed.
-  Profile* profile_;
+  // 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  // CHROME_BROWSER_EXTENSIONS_USER_SCRIPT_LOADER_H_
+#endif  // EXTENSIONS_BROWSER_USER_SCRIPT_LOADER_H_