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

extensions/browser/web_ui_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/web_ui_user_script_loader.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/guest_view/web_view/web_ui/web_ui_url_fetcher.h"
 
 namespace {
 
 void SerializeOnFileThread(
-    scoped_ptr<extensions::UserScriptList> user_scripts,
+    std::unique_ptr<extensions::UserScriptList> user_scripts,
     extensions::UserScriptLoader::LoadScriptsCallback callback) {
-  scoped_ptr<base::SharedMemory> memory =
+  std::unique_ptr<base::SharedMemory> memory =
       extensions::UserScriptLoader::Serialize(*user_scripts);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(callback, base::Passed(&user_scripts), base::Passed(&memory)));
 }
 
 }  // namespace
 
 struct WebUIUserScriptLoader::UserScriptRenderInfo {
   int render_process_id;
@@ skipping 22 matching lines @@
   UserScriptRenderInfo info(render_process_id, render_view_id);
   for (const extensions::UserScript& script : scripts) {
     script_render_info_map_.insert(
         std::pair<int, UserScriptRenderInfo>(script.id(), info));
   }
 
   extensions::UserScriptLoader::AddScripts(scripts);
 }
 
 void WebUIUserScriptLoader::LoadScripts(
-    scoped_ptr<extensions::UserScriptList> user_scripts,
+    std::unique_ptr<extensions::UserScriptList> user_scripts,
     const std::set<HostID>& changed_hosts,
     const std::set<int>& added_script_ids,
     LoadScriptsCallback callback) {
   user_scripts_cache_.swap(user_scripts);
   scripts_loaded_callback_ = callback;
 
   // The total number of the tasks is used to trace whether all the fetches
   // are complete. Therefore, we store all the fetcher pointers in |fetchers_|
   // before we get theis number. Once we get the total number, start each
   // fetch tasks.
@@ skipping 32 matching lines @@
 void WebUIUserScriptLoader::CreateWebUIURLFetchers(
     extensions::UserScript::FileList* script_files,
     content::BrowserContext* browser_context,
     int render_process_id,
     int render_view_id) {
   for (extensions::UserScript::File& file : *script_files) {
     if (file.GetContent().empty()) {
       // The WebUIUserScriptLoader owns these WebUIURLFetchers. Once the
       // loader is destroyed, all the fetchers will be destroyed. Therefore,
       // we are sure it is safe to use base::Unretained(this) here.
-      scoped_ptr<WebUIURLFetcher> fetcher(new WebUIURLFetcher(
+      std::unique_ptr<WebUIURLFetcher> fetcher(new WebUIURLFetcher(
           browser_context, render_process_id, render_view_id, file.url(),
           base::Bind(&WebUIUserScriptLoader::OnSingleWebUIURLFetchComplete,
                      base::Unretained(this), &file)));
       fetchers_.push_back(std::move(fetcher));
     }
   }
 }
 
 void WebUIUserScriptLoader::OnSingleWebUIURLFetchComplete(
     extensions::UserScript::File* script_file,
@@ skipping 16 matching lines @@
   }
 }
 
 void WebUIUserScriptLoader::OnWebUIURLFetchComplete() {
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&SerializeOnFileThread, base::Passed(&user_scripts_cache_),
                  scripts_loaded_callback_));
   scripts_loaded_callback_.Reset();
 }