Move DeclarativeUserScriptManager/Master and UserScriptLoader to //extensions.

extensions/browser/extension_user_script_loader.cc

 // Copyright 2015 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.
 
-#include "chrome/browser/extensions/extension_user_script_loader.h"
+#include "extensions/browser/extension_user_script_loader.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/version.h"
-#include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/component_extension_resource_manager.h"
 #include "extensions/browser/content_verifier.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/manifest_handlers/default_locale_handler.h"
 #include "extensions/common/message_bundle.h"
 #include "extensions/common/one_shot_event.h"
 #include "ui/base/resource/resource_bundle.h"
 
+using content::BrowserContext;
+
 namespace extensions {
 
 namespace {
 
 // Verifies file contents as they are read.
 void VerifyContent(const scoped_refptr<ContentVerifier>& verifier,
                    const std::string& extension_id,
                    const base::FilePath& extension_root,
                    const base::FilePath& relative_path,
                    const std::string& content) {
@@ skipping 62 matching lines @@
     script_file->set_content(content.substr(strlen(base::kUtf8ByteOrderMark)));
   else
     script_file->set_content(content);
 
   return true;
 }
 
 }  // namespace
 
 ExtensionUserScriptLoader::ExtensionUserScriptLoader(
-    Profile* profile,
+    BrowserContext* browser_context,
     const HostID& host_id,
     bool listen_for_extension_system_loaded)
-    : UserScriptLoader(profile,
-                       host_id,
-                       ExtensionSystem::Get(profile)->content_verifier()),
+    : UserScriptLoader(
+          browser_context,
+          host_id,
+          ExtensionSystem::Get(browser_context)->content_verifier()),
       extension_registry_observer_(this),
       weak_factory_(this) {
-  extension_registry_observer_.Add(ExtensionRegistry::Get(profile));
+  extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context));
   if (listen_for_extension_system_loaded) {
-    ExtensionSystem::Get(profile)->ready().Post(
-        FROM_HERE,
-        base::Bind(&ExtensionUserScriptLoader::OnExtensionSystemReady,
-                   weak_factory_.GetWeakPtr()));
+    ExtensionSystem::Get(browser_context)
+        ->ready()
+        .Post(FROM_HERE,
+              base::Bind(&ExtensionUserScriptLoader::OnExtensionSystemReady,
+                         weak_factory_.GetWeakPtr()));
   } else {
     SetReady(true);
   }
 }
 
 ExtensionUserScriptLoader::~ExtensionUserScriptLoader() {
 }
 
 void ExtensionUserScriptLoader::UpdateHostsInfo(
     const std::set<HostID>& changed_hosts) {
-  ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
+  ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context());
   for (const HostID& host_id : changed_hosts) {
     const Extension* extension =
         registry->GetExtensionById(host_id.id(), ExtensionRegistry::ENABLED);
     // |changed_hosts_| may include hosts that have been removed,
     // which leads to the above lookup failing. In this case, just continue.
     if (!extension)
       continue;
     AddHostInfo(host_id, ExtensionSet::ExtensionPathAndDefaultLocale(
                              extension->path(),
                              LocaleInfo::GetDefaultLocale(extension)));
@@ skipping 10 matching lines @@
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   RemoveHostInfo(HostID(HostID::EXTENSIONS, extension->id()));
 }
 
 void ExtensionUserScriptLoader::OnExtensionSystemReady() {
   SetReady(true);
 }
 
 }  // namespace extensions