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

content/browser/child_process_launcher.cc

 // Copyright 2012 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 "content/browser/child_process_launcher.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/i18n/icu_util.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/process/launch.h"
 #include "base/process/process.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_descriptors.h"
 #include "content/public/common/content_switches.h"
@@ skipping 85 matching lines @@
 void LaunchOnLauncherThread(const NotifyCallback& callback,
                             BrowserThread::ID client_thread_id,
                             int child_process_id,
                             SandboxedProcessLauncherDelegate* delegate,
 #if defined(OS_ANDROID)
                             base::ScopedFD ipcfd,
 #endif
                             mojo::edk::ScopedPlatformHandle client_handle,
                             base::CommandLine* cmd_line) {
   DCHECK_CURRENTLY_ON(BrowserThread::PROCESS_LAUNCHER);
-  scoped_ptr<SandboxedProcessLauncherDelegate> delegate_deleter(delegate);
+  std::unique_ptr<SandboxedProcessLauncherDelegate> delegate_deleter(delegate);
 #if !defined(OS_ANDROID)
   ZygoteHandle zygote = nullptr;
 #endif
 #if defined(OS_WIN)
   bool launch_elevated = delegate->ShouldLaunchElevated();
 #elif defined(OS_MACOSX)
   base::EnvironmentMap env = delegate->GetEnvironment();
   base::ScopedFD ipcfd = delegate->TakeIpcFd();
 #elif defined(OS_POSIX) && !defined(OS_ANDROID)
   base::EnvironmentMap env = delegate->GetEnvironment();
   base::ScopedFD ipcfd = delegate->TakeIpcFd();
 #endif
-  scoped_ptr<base::CommandLine> cmd_line_deleter(cmd_line);
+  std::unique_ptr<base::CommandLine> cmd_line_deleter(cmd_line);
   base::TimeTicks begin_launch_time = base::TimeTicks::Now();
 
   base::Process process;
 #if defined(OS_WIN)
   if (launch_elevated) {
     // TODO(rockot): We may want to support Mojo IPC to elevated processes as
     // well, but this isn't currently feasible without sharing a pipe path on
     // the command line as elevated process launch goes through ShellExecuteEx.
     base::LaunchOptions options;
     options.start_hidden = true;
     process = base::LaunchElevatedProcess(*cmd_line, options);
   } else {
     base::HandlesToInheritVector handles;
     handles.push_back(client_handle.get().handle);
     cmd_line->AppendSwitchASCII(
         mojo::edk::PlatformChannelPair::kMojoPlatformChannelHandleSwitch,
         base::UintToString(base::win::HandleToUint32(handles[0])));
     process = StartSandboxedProcess(delegate, cmd_line, handles);
   }
 #elif defined(OS_POSIX)
   std::string process_type =
       cmd_line->GetSwitchValueASCII(switches::kProcessType);
-  scoped_ptr<FileDescriptorInfo> files_to_register(
+  std::unique_ptr<FileDescriptorInfo> files_to_register(
       FileDescriptorInfoImpl::Create());
 
   base::ScopedFD mojo_fd(client_handle.release().handle);
   DCHECK(mojo_fd.is_valid());
 
 #if defined(OS_ANDROID)
   if (ipcfd.get() != -1)
     files_to_register->Share(kPrimaryIPCChannel, ipcfd.get());
   files_to_register->Share(kMojoIPCChannel, mojo_fd.get());
 #else
@@ skipping 130 matching lines @@
     // port to the parent prior to the parent leaving LaunchProcess, the
     // order in which the record in MachBroker is updated is correct.
     MachBroker* broker = MachBroker::GetInstance();
     broker->GetLock().Acquire();
 
     // Make sure the MachBroker is running, and inform it to expect a
     // check-in from the new process.
     broker->EnsureRunning();
 
     const SandboxType sandbox_type = delegate->GetSandboxType();
-    scoped_ptr<sandbox::PreExecDelegate> pre_exec_delegate;
+    std::unique_ptr<sandbox::PreExecDelegate> pre_exec_delegate;
     if (BootstrapSandboxManager::ShouldEnable()) {
       BootstrapSandboxManager* sandbox_manager =
           BootstrapSandboxManager::GetInstance();
       if (sandbox_manager->EnabledForSandbox(sandbox_type)) {
         pre_exec_delegate = sandbox_manager->sandbox()->NewClient(sandbox_type);
       }
     }
     options.pre_exec_delegate = pre_exec_delegate.get();
 #endif  // defined(OS_MACOSX)
 
@@ skipping 269 matching lines @@
 }
 
 ChildProcessLauncher::Client* ChildProcessLauncher::ReplaceClientForTest(
     Client* client) {
   Client* ret = client_;
   client_ = client;
   return ret;
 }
 
 }  // namespace content