Convert //sandbox to use std::unique_ptr

sandbox/mac/bootstrap_sandbox.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 "sandbox/mac/bootstrap_sandbox.h"
 
 #include <servers/bootstrap.h>
 #include <stdint.h>
 #include <unistd.h>
 
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/mach_logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "sandbox/mac/launchd_interception_server.h"
 #include "sandbox/mac/pre_exec_delegate.h"
 
 namespace sandbox {
 
 namespace {
 
 struct SandboxCheckInRequest {
@@ skipping 23 matching lines @@
 
  private:
   mach_msg_header_t* message_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedCallMachMsgDestroy);
 };
 
 }  // namespace
 
 // static
-scoped_ptr<BootstrapSandbox> BootstrapSandbox::Create() {
-  scoped_ptr<BootstrapSandbox> null;  // Used for early returns.
-  scoped_ptr<BootstrapSandbox> sandbox(new BootstrapSandbox());
+std::unique_ptr<BootstrapSandbox> BootstrapSandbox::Create() {
+  std::unique_ptr<BootstrapSandbox> null;  // Used for early returns.
+  std::unique_ptr<BootstrapSandbox> sandbox(new BootstrapSandbox());
   sandbox->launchd_server_.reset(new LaunchdInterceptionServer(sandbox.get()));
 
   // Check in with launchd to get the receive right for the server that is
   // published in the bootstrap namespace.
   mach_port_t port = MACH_PORT_NULL;
   kern_return_t kr = bootstrap_check_in(bootstrap_port,
       sandbox->server_bootstrap_name().c_str(), &port);
   if (kr != KERN_SUCCESS) {
     BOOTSTRAP_LOG(ERROR, kr)
         << "Failed to bootstrap_check_in the sandbox server.";
@@ skipping 65 matching lines @@
 
 void BootstrapSandbox::RegisterSandboxPolicy(
     int sandbox_policy_id,
     const BootstrapSandboxPolicy& policy) {
   CHECK(IsPolicyValid(policy));
   base::AutoLock lock(lock_);
   DCHECK(policies_.find(sandbox_policy_id) == policies_.end());
   policies_.insert(std::make_pair(sandbox_policy_id, policy));
 }
 
-scoped_ptr<PreExecDelegate> BootstrapSandbox::NewClient(int sandbox_policy_id) {
+std::unique_ptr<PreExecDelegate> BootstrapSandbox::NewClient(
+    int sandbox_policy_id) {
   base::AutoLock lock(lock_);
 
   DCHECK(policies_.find(sandbox_policy_id) != policies_.end());
 
   uint64_t token;
   while (true) {
     token = base::RandUint64();
     if (awaiting_processes_.find(token) == awaiting_processes_.end())
       break;
   }
 
   awaiting_processes_[token] = sandbox_policy_id;
-  return make_scoped_ptr(new PreExecDelegate(server_bootstrap_name_, token));
+  return base::WrapUnique(new PreExecDelegate(server_bootstrap_name_, token));
 }
 
 void BootstrapSandbox::RevokeToken(uint64_t token) {
   base::AutoLock lock(lock_);
   const auto& it = awaiting_processes_.find(token);
   if (it != awaiting_processes_.end())
     awaiting_processes_.erase(it);
 }
 
 void BootstrapSandbox::InvalidateClient(base::ProcessHandle handle) {
@@ skipping 82 matching lines @@
   } else {
     {
       base::AutoLock lock(lock_);
       sandboxed_processes_.erase(client_pid);
     }
     MACH_LOG(ERROR, kr) << "HandleChildCheckIn mach_msg MACH_SEND_MSG";
   }
 }
 
 }  // namespace sandbox