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

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 "extensions/browser/user_script_loader.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <string>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/version.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/extensions_browser_client.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/extension_messages.h"
 
@@ skipping 246 matching lines @@
               base::Bind(&UserScriptLoader::OnScriptsLoaded,
                          weak_factory_.GetWeakPtr()));
 
   clear_scripts_ = false;
   added_scripts_.clear();
   removed_scripts_.clear();
   user_scripts_.reset();
 }
 
 // static
-scoped_ptr<base::SharedMemory> UserScriptLoader::Serialize(
+std::unique_ptr<base::SharedMemory> UserScriptLoader::Serialize(
     const UserScriptList& scripts) {
   base::Pickle pickle;
   pickle.WriteUInt32(scripts.size());
   for (const UserScript& script : scripts) {
     // TODO(aa): This can be replaced by sending content script metadata to
     // renderers along with other extension data in ExtensionMsg_Loaded.
     // See crbug.com/70516.
     script.Pickle(&pickle);
     // Write scripts as 'data' so that we can read it out in the slave without
     // allocating a new string.
     for (const UserScript::File& script_file : script.js_scripts()) {
       base::StringPiece contents = script_file.GetContent();
       pickle.WriteData(contents.data(), contents.length());
     }
     for (const UserScript::File& script_file : script.css_scripts()) {
       base::StringPiece contents = script_file.GetContent();
       pickle.WriteData(contents.data(), contents.length());
     }
   }
 
   // Create the shared memory object.
   base::SharedMemory shared_memory;
 
   base::SharedMemoryCreateOptions options;
   options.size = pickle.size();
   options.share_read_only = true;
   if (!shared_memory.Create(options))
-    return scoped_ptr<base::SharedMemory>();
+    return std::unique_ptr<base::SharedMemory>();
 
   if (!shared_memory.Map(pickle.size()))
-    return scoped_ptr<base::SharedMemory>();
+    return std::unique_ptr<base::SharedMemory>();
 
   // Copy the pickle to shared memory.
   memcpy(shared_memory.memory(), pickle.data(), pickle.size());
 
   base::SharedMemoryHandle readonly_handle;
   if (!shared_memory.ShareReadOnlyToProcess(base::GetCurrentProcessHandle(),
                                             &readonly_handle))
-    return scoped_ptr<base::SharedMemory>();
+    return std::unique_ptr<base::SharedMemory>();
 
-  return make_scoped_ptr(new base::SharedMemory(readonly_handle,
-                                                /*read_only=*/true));
+  return base::WrapUnique(new base::SharedMemory(readonly_handle,
+                                                 /*read_only=*/true));
 }
 
 void UserScriptLoader::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void UserScriptLoader::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void UserScriptLoader::SetReady(bool ready) {
   bool was_ready = ready_;
   ready_ = ready;
   if (ready_ && !was_ready)
     AttemptLoad();
 }
 
 void UserScriptLoader::OnScriptsLoaded(
-    scoped_ptr<UserScriptList> user_scripts,
-    scoped_ptr<base::SharedMemory> shared_memory) {
+    std::unique_ptr<UserScriptList> user_scripts,
+    std::unique_ptr<base::SharedMemory> shared_memory) {
   user_scripts_.reset(user_scripts.release());
   if (pending_load_) {
     // While we were loading, there were further changes. Don't bother
     // notifying about these scripts and instead just immediately reload.
     pending_load_ = false;
     StartLoad();
     return;
   }
 
   if (shared_memory.get() == NULL) {
@@ skipping 48 matching lines @@
   if (!shared_memory->ShareToProcess(handle, &handle_for_process))
     return;  // This can legitimately fail if the renderer asserts at startup.
 
   if (base::SharedMemory::IsHandleValid(handle_for_process)) {
     process->Send(new ExtensionMsg_UpdateUserScripts(
         handle_for_process, host_id(), changed_hosts, whitelisted_only));
   }
 }
 
 }  // namespace extensions