Clarifying the parameters ownership of BrowserChildProcessHost::Launch()

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"
@@ skipping 97 matching lines @@
                  base::Passed(base::Process(handle)), launch_result));
   if (BrowserThread::CurrentlyOn(client_thread_id)) {
     callback_on_client_thread.Run();
   } else {
     BrowserThread::PostTask(
         client_thread_id, FROM_HERE, callback_on_client_thread);
   }
 }
 #endif
 
-void LaunchOnLauncherThread(const NotifyCallback& callback,
-                            BrowserThread::ID client_thread_id,
-                            int child_process_id,
-                            SandboxedProcessLauncherDelegate* delegate,
-                            mojo::edk::ScopedPlatformHandle client_handle,
-                            base::CommandLine* cmd_line) {
+void LaunchOnLauncherThread(
+    const NotifyCallback& callback,
+    BrowserThread::ID client_thread_id,
+    int child_process_id,
+    std::unique_ptr<SandboxedProcessLauncherDelegate> delegate,
+    mojo::edk::ScopedPlatformHandle client_handle,
+    std::unique_ptr<base::CommandLine> cmd_line) {
   DCHECK_CURRENTLY_ON(BrowserThread::PROCESS_LAUNCHER);
-  std::unique_ptr<SandboxedProcessLauncherDelegate> delegate_deleter(delegate);
 #if !defined(OS_ANDROID)
   ZygoteHandle zygote = nullptr;
   int launch_result = LAUNCH_RESULT_FAILURE;
 #endif
 #if defined(OS_WIN)
   bool launch_elevated = delegate->ShouldLaunchElevated();
 #elif defined(OS_MACOSX)
   base::EnvironmentMap env = delegate->GetEnvironment();
 #elif defined(OS_POSIX) && !defined(OS_ANDROID)
   base::EnvironmentMap env = delegate->GetEnvironment();
 #endif
-  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) {
     // When establishing a Mojo connection, the pipe path has already been added
     // to the command line.
     base::LaunchOptions options;
     options.start_hidden = true;
     process = base::LaunchElevatedProcess(*cmd_line, options);
   } else {
     base::HandlesToInheritVector handles;
     handles.push_back(client_handle.get().handle);
     base::FieldTrialList::AppendFieldTrialHandleIfNeeded(&handles);
     cmd_line->AppendSwitchASCII(
         mojo::edk::PlatformChannelPair::kMojoPlatformChannelHandleSwitch,
         base::UintToString(base::win::HandleToUint32(handles[0])));
-    launch_result =
-        StartSandboxedProcess(delegate, cmd_line, handles, &process);
+    launch_result = StartSandboxedProcess(
+        delegate.get(), cmd_line.get(), handles, &process);
   }
 #elif defined(OS_POSIX)
   std::string process_type =
       cmd_line->GetSwitchValueASCII(switches::kProcessType);
   std::unique_ptr<FileDescriptorInfo> files_to_register(
       FileDescriptorInfoImpl::Create());
 
   base::ScopedFD mojo_fd(client_handle.release().handle);
   DCHECK(mojo_fd.is_valid());
 
@@ skipping 159 matching lines @@
     if (process.IsValid()) {
       broker->AddPlaceholderForPid(process.Pid(), child_process_id);
     } else {
       if (pre_exec_delegate) {
         BootstrapSandboxManager::GetInstance()->sandbox()->RevokeToken(
             pre_exec_delegate->sandbox_token());
       }
     }
 
     // After updating the broker, release the lock and let the child's
-    // messasge be processed on the broker's thread.
+    // message be processed on the broker's thread.
     broker->GetLock().Release();
 #endif  // defined(OS_MACOSX)
   }
 #endif  // else defined(OS_POSIX)
 #if !defined(OS_ANDROID)
   if (process.IsValid()) {
     launch_result = LAUNCH_RESULT_SUCCESS;
     RecordHistogramsOnLauncherThread(base::TimeTicks::Now() -
                                      begin_launch_time);
   }
@@ skipping 38 matching lines @@
 #endif  // defined(OS_MACOSX)
   }
 #if defined(OS_ANDROID)
   SetChildProcessInForeground(process.Handle(), !background);
 #endif
 }
 
 }  // namespace
 
 ChildProcessLauncher::ChildProcessLauncher(
-    SandboxedProcessLauncherDelegate* delegate,
-    base::CommandLine* cmd_line,
+    std::unique_ptr<SandboxedProcessLauncherDelegate> delegate,
+    std::unique_ptr<base::CommandLine> cmd_line,
     int child_process_id,
     Client* client,
     const std::string& mojo_child_token,
     const mojo::edk::ProcessErrorCallback& process_error_callback,
     bool terminate_on_shutdown)
     : client_(client),
       termination_status_(base::TERMINATION_STATUS_NORMAL_TERMINATION),
       exit_code_(RESULT_CODE_NORMAL_EXIT),
       zygote_(nullptr),
       starting_(true),
       process_error_callback_(process_error_callback),
 #if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) ||  \
     defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \
     defined(UNDEFINED_SANITIZER)
       terminate_child_on_shutdown_(false),
 #else
       terminate_child_on_shutdown_(terminate_on_shutdown),
 #endif
       mojo_child_token_(mojo_child_token),
       weak_factory_(this) {
   DCHECK(CalledOnValidThread());
   CHECK(BrowserThread::GetCurrentThreadIdentifier(&client_thread_id_));
-  Launch(delegate, cmd_line, child_process_id);
+  Launch(std::move(delegate), std::move(cmd_line), child_process_id);
 }
 
 ChildProcessLauncher::~ChildProcessLauncher() {
   DCHECK(CalledOnValidThread());
   if (process_.IsValid() && terminate_child_on_shutdown_) {
     // On Posix, EnsureProcessTerminated can lead to 2 seconds of sleep!  So
     // don't this on the UI/IO threads.
     BrowserThread::PostTask(BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
                             base::Bind(&TerminateOnLauncherThread, zygote_,
                                        base::Passed(&process_)));
   }
 }
 
-void ChildProcessLauncher::Launch(SandboxedProcessLauncherDelegate* delegate,
-                                  base::CommandLine* cmd_line,
-                                  int child_process_id) {
+void ChildProcessLauncher::Launch(
+    std::unique_ptr<SandboxedProcessLauncherDelegate> delegate,
+    std::unique_ptr<base::CommandLine> cmd_line,
+    int child_process_id) {
   DCHECK(CalledOnValidThread());
 
 #if defined(OS_ANDROID)
   // Android only supports renderer, sandboxed utility and gpu.
   std::string process_type =
       cmd_line->GetSwitchValueASCII(switches::kProcessType);
   CHECK(process_type == switches::kGpuProcess ||
         process_type == switches::kRendererProcess ||
 #if BUILDFLAG(ENABLE_PLUGINS)
         process_type == switches::kPpapiPluginProcess ||
 #endif
         process_type == switches::kUtilityProcess)
       << "Unsupported process type: " << process_type;
 
   // Non-sandboxed utility or renderer process are currently not supported.
   DCHECK(process_type == switches::kGpuProcess ||
          !cmd_line->HasSwitch(switches::kNoSandbox));
 
 #endif
   mojo::edk::ScopedPlatformHandle server_handle;
   mojo::edk::ScopedPlatformHandle client_handle;
 #if defined(OS_WIN)
   if (delegate->ShouldLaunchElevated()) {
     mojo::edk::NamedPlatformChannelPair named_pair;
     server_handle = named_pair.PassServerHandle();
-    named_pair.PrepareToPassClientHandleToChildProcess(cmd_line);
+    named_pair.PrepareToPassClientHandleToChildProcess(cmd_line.get());
   } else
 #endif
   {
     mojo::edk::PlatformChannelPair channel_pair;
     server_handle = channel_pair.PassServerHandle();
     client_handle = channel_pair.PassClientHandle();
   }
   NotifyCallback reply_callback(base::Bind(&ChildProcessLauncher::DidLaunch,
                                            weak_factory_.GetWeakPtr(),
                                            terminate_child_on_shutdown_,
                                            base::Passed(&server_handle)));
   BrowserThread::PostTask(
       BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
       base::Bind(&LaunchOnLauncherThread, reply_callback, client_thread_id_,
-                 child_process_id, delegate,
-                 base::Passed(&client_handle), cmd_line));
+                 child_process_id, base::Passed(&delegate),
+                 base::Passed(&client_handle), base::Passed(&cmd_line)));
 }
 
 void ChildProcessLauncher::UpdateTerminationStatus(bool known_dead) {
   DCHECK(CalledOnValidThread());
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
   if (zygote_) {
     termination_status_ = zygote_->GetTerminationStatus(
         process_.Handle(), known_dead, &exit_code_);
   } else if (known_dead) {
     termination_status_ =
@@ skipping 117 matching lines @@
 }
 
 ChildProcessLauncher::Client* ChildProcessLauncher::ReplaceClientForTest(
     Client* client) {
   Client* ret = client_;
   client_ = client;
   return ret;
 }
 
 }  // namespace content