Convert //extensions/browser from scoped_ptr to std::unique_ptr

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 "extensions/browser/extension_user_script_loader.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <string>
@@ skipping 111 matching lines @@
       iter->second.first, host_id.id(), iter->second.second);
 }
 
 void LoadUserScripts(UserScriptList* user_scripts,
                      const ExtensionUserScriptLoader::HostsInfo& hosts_info,
                      const std::set<int>& added_script_ids,
                      const scoped_refptr<ContentVerifier>& verifier) {
   for (UserScript& script : *user_scripts) {
     if (added_script_ids.count(script.id()) == 0)
       continue;
-    scoped_ptr<SubstitutionMap> localization_messages(
+    std::unique_ptr<SubstitutionMap> localization_messages(
         GetLocalizationMessages(hosts_info, script.host_id()));
     for (UserScript::File& script_file : script.js_scripts()) {
       if (script_file.GetContent().empty())
         LoadScriptContent(script.host_id(), &script_file, nullptr, verifier);
     }
     for (UserScript::File& script_file : script.css_scripts()) {
       if (script_file.GetContent().empty())
         LoadScriptContent(script.host_id(), &script_file,
                           localization_messages.get(), verifier);
     }
   }
 }
 
 void LoadScriptsOnFileThread(
-    scoped_ptr<UserScriptList> user_scripts,
+    std::unique_ptr<UserScriptList> user_scripts,
     const ExtensionUserScriptLoader::HostsInfo& hosts_info,
     const std::set<int>& added_script_ids,
     const scoped_refptr<ContentVerifier>& verifier,
     UserScriptLoader::LoadScriptsCallback callback) {
   DCHECK(user_scripts.get());
   LoadUserScripts(user_scripts.get(), hosts_info, added_script_ids, verifier);
-  scoped_ptr<base::SharedMemory> memory =
+  std::unique_ptr<base::SharedMemory> memory =
       UserScriptLoader::Serialize(*user_scripts);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(callback, base::Passed(&user_scripts), base::Passed(&memory)));
 }
 
 }  // namespace
 
 ExtensionUserScriptLoader::ExtensionUserScriptLoader(
     BrowserContext* browser_context,
@@ skipping 24 matching lines @@
   HostsInfo info;
   std::set<int> added_script_ids;
   for (UserScript& script : *user_scripts)
     added_script_ids.insert(script.id());
 
   LoadUserScripts(user_scripts, info, added_script_ids,
                   nullptr /* no verifier for testing */);
 }
 
 void ExtensionUserScriptLoader::LoadScripts(
-    scoped_ptr<UserScriptList> user_scripts,
+    std::unique_ptr<UserScriptList> user_scripts,
     const std::set<HostID>& changed_hosts,
     const std::set<int>& added_script_ids,
     LoadScriptsCallback callback) {
   UpdateHostsInfo(changed_hosts);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&LoadScriptsOnFileThread, base::Passed(&user_scripts),
                  hosts_info_, added_script_ids, content_verifier_, callback));
 }
@@ skipping 20 matching lines @@
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   hosts_info_.erase(HostID(HostID::EXTENSIONS, extension->id()));
 }
 
 void ExtensionUserScriptLoader::OnExtensionSystemReady() {
   SetReady(true);
 }
 
 }  // namespace extensions