Move DeclarativeUserScriptManager/Master and UserScriptLoader to //extensions.

extensions/browser/user_script_loader.cc

 // 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.
 
-#include "chrome/browser/extensions/user_script_loader.h"
+#include "extensions/browser/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/chrome_notification_types.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/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/content_verifier.h"
+#include "extensions/browser/extensions_browser_client.h"
+#include "extensions/browser/notification_types.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/file_util.h"
 
 using content::BrowserThread;
+using content::BrowserContext;
 
 namespace extensions {
 
 namespace {
 
 using LoadScriptsCallback =
     base::Callback<void(scoped_ptr<UserScriptList>,
                         scoped_ptr<base::SharedMemory>)>;
 
 UserScriptLoader::SubstitutionMap* GetLocalizationMessages(
@@ skipping 219 matching lines @@
        it != user_scripts->end();
        ++it) {
     added_script_ids.insert(it->id());
   }
   LoadUserScripts(user_scripts, info, added_script_ids,
                   NULL /* no verifier for testing */,
                   GetLoadUserScriptsFunction());
 }
 
 UserScriptLoader::UserScriptLoader(
-    Profile* profile,
+    BrowserContext* browser_context,
     const HostID& host_id,
     const scoped_refptr<ContentVerifier>& content_verifier)
     : user_scripts_(new UserScriptList()),
       clear_scripts_(false),
       ready_(false),
       pending_load_(false),
-      profile_(profile),
+      browser_context_(browser_context),
       host_id_(host_id),
       content_verifier_(content_verifier),
       weak_factory_(this) {
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 UserScriptLoader::~UserScriptLoader() {
 }
@@ skipping 24 matching lines @@
   removed_scripts_.clear();
   AttemptLoad();
 }
 
 void UserScriptLoader::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   DCHECK_EQ(type, content::NOTIFICATION_RENDERER_PROCESS_CREATED);
   content::RenderProcessHost* process =
       content::Source<content::RenderProcessHost>(source).ptr();
-  Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext());
-  if (!profile_->IsSameProfile(profile))
+  if (!ExtensionsBrowserClient::Get()->IsSameContext(
+          browser_context_, process->GetBrowserContext()))
     return;
   if (scripts_ready()) {
     SendUpdate(process, shared_memory_.get(),
                std::set<HostID>());  // Include all hosts.
   }
 }
 
 bool UserScriptLoader::ScriptsMayHaveChanged() const {
   // Scripts may have changed if there are scripts added, scripts removed, or
   // if scripts were cleared and either:
@@ skipping 116 matching lines @@
   for (content::RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd();
        i.Advance()) {
     SendUpdate(i.GetCurrentValue(), shared_memory_.get(), changed_hosts_);
   }
   changed_hosts_.clear();
 
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_USER_SCRIPTS_UPDATED,
-      content::Source<Profile>(profile_),
+      content::Source<BrowserContext>(browser_context_),
       content::Details<base::SharedMemory>(shared_memory_.get()));
 }
 
 void UserScriptLoader::SendUpdate(content::RenderProcessHost* process,
                                   base::SharedMemory* shared_memory,
                                   const std::set<HostID>& changed_hosts) {
   // Don't allow injection of content scripts into <webview>.
   if (process->IsIsolatedGuest())
     return;
 
-  Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext());
-  // Make sure we only send user scripts to processes in our profile.
-  if (!profile_->IsSameProfile(profile))
+  // Make sure we only send user scripts to processes in our browser_context.
+  if (!ExtensionsBrowserClient::Get()->IsSameContext(
+          browser_context_, process->GetBrowserContext()))
     return;
 
   // If the process is being started asynchronously, early return.  We'll end up
   // calling InitUserScripts when it's created which will call this again.
   base::ProcessHandle handle = process->GetHandle();
   if (!handle)
     return;
 
   base::SharedMemoryHandle handle_for_process;
   if (!shared_memory->ShareToProcess(handle, &handle_for_process))
     return;  // This can legitimately fail if the renderer asserts at startup.
 
   // TODO(hanxi): update the IPC message to send a set of HostIDs to render.
   // Also, remove this function when the refactor is done on render side.
   std::set<std::string> changed_ids_set;
   for (const HostID& id : changed_hosts)
     changed_ids_set.insert(id.id());
 
   if (base::SharedMemory::IsHandleValid(handle_for_process)) {
     process->Send(new ExtensionMsg_UpdateUserScripts(
         handle_for_process, host_id().id(), changed_ids_set));
   }
 }
 
 }  // namespace extensions