Convert //sandbox to use std::unique_ptr

sandbox/mac/bootstrap_sandbox.h

 // 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.
 
 #ifndef SANDBOX_MAC_BOOTSTRAP_SANDBOX_H_
 #define SANDBOX_MAC_BOOTSTRAP_SANDBOX_H_
 
 #include <mach/mach.h>
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <string>
 
 #include "base/mac/dispatch_source_mach.h"
 #include "base/mac/scoped_mach_port.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/process/process_handle.h"
 #include "base/synchronization/lock.h"
 #include "sandbox/mac/policy.h"
 #include "sandbox/sandbox_export.h"
 
 namespace sandbox {
 
 class LaunchdInterceptionServer;
 class PreExecDelegate;
 
@@ skipping 14 matching lines @@
 // being enforced, it should use NewClient() to create a PreExecDelegate for
 // a sandbox policy ID and set it to the base::LaunchOptions.pre_exec_delegate.
 //
 // When a child process exits, the parent should call InvalidateClient() to
 // clean up any mappings in this class.
 //
 // All methods of this class may be called from any thread.
 class SANDBOX_EXPORT BootstrapSandbox {
  public:
   // Creates a new sandbox manager. Returns NULL on failure.
-  static scoped_ptr<BootstrapSandbox> Create();
+  static std::unique_ptr<BootstrapSandbox> Create();
 
   // For use in newly created child processes. Checks in with the bootstrap
   // sandbox manager running in the parent process. |sandbox_server_port| is
   // the Mach send right to the sandbox |check_in_server_| (in the child).
   // |sandbox_token| is the assigned token. On return, |bootstrap_port| is set
   // to a new Mach send right to be used in the child as the task's bootstrap
   // port.
   static bool ClientCheckIn(mach_port_t sandbox_server_port,
                             uint64_t sandbox_token,
                             mach_port_t* bootstrap_port);
 
   ~BootstrapSandbox();
 
   // Registers a bootstrap policy associated it with an identifier. The
   // |sandbox_policy_id| must be greater than 0.
   void RegisterSandboxPolicy(int sandbox_policy_id,
                              const BootstrapSandboxPolicy& policy);
 
   // Creates a new PreExecDelegate to pass to base::LaunchOptions. This will
   // enforce the policy with |sandbox_policy_id| on the new process.
-  scoped_ptr<PreExecDelegate> NewClient(int sandbox_policy_id);
+  std::unique_ptr<PreExecDelegate> NewClient(int sandbox_policy_id);
 
   // If a client did not launch properly, the sandbox provided to the
   // PreExecDelegate should be invalidated using this method.
   void RevokeToken(uint64_t token);
 
   // Called in the parent when a process has died. It cleans up the references
   // to the process.
   void InvalidateClient(base::ProcessHandle handle);
 
   // Looks up the policy for a given process ID. If no policy is associated
@@ skipping 28 matching lines @@
   // The association between process ID and sandbox policy ID.
   std::map<base::ProcessHandle, int> sandboxed_processes_;
 
   // The association between a new process' sandbox token and its policy ID.
   // The entry is removed after the process checks in, and the mapping moves
   // to |sandboxed_processes_|.
   std::map<uint64_t, int> awaiting_processes_;
 
   // A Mach IPC message server that is used to intercept and filter bootstrap
   // requests.
-  scoped_ptr<LaunchdInterceptionServer> launchd_server_;
+  std::unique_ptr<LaunchdInterceptionServer> launchd_server_;
 
   // The port and dispatch source for receiving client check in messages sent
   // via ClientCheckIn().
   base::mac::ScopedMachReceiveRight check_in_port_;
-  scoped_ptr<base::DispatchSourceMach> check_in_server_;
+  std::unique_ptr<base::DispatchSourceMach> check_in_server_;
 };
 
 }  // namespace sandbox
 
 #endif  // SANDBOX_MAC_BOOTSTRAP_SANDBOX_H_