Clarifying the parameters ownership of BrowserChildProcessHost::Launch()

content/browser/utility_process_host_impl.cc

 // Copyright (c) 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/utility_process_host_impl.h"
 
 #include <utility>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
@@ skipping 256 matching lines @@
     const base::CommandLine& browser_command_line =
         *base::CommandLine::ForCurrentProcess();
 
     bool has_cmd_prefix = browser_command_line.HasSwitch(
         switches::kUtilityCmdPrefix);
 
     #if defined(OS_ANDROID)
       // readlink("/prof/self/exe") sometimes fails on Android at startup.
       // As a workaround skip calling it here, since the executable name is
       // not needed on Android anyway. See crbug.com/500854.
-      base::CommandLine* cmd_line =
-          new base::CommandLine(base::CommandLine::NO_PROGRAM);
+    std::unique_ptr<base::CommandLine> cmd_line =
+        base::MakeUnique<base::CommandLine>(base::CommandLine::NO_PROGRAM);
     #else
       int child_flags = child_flags_;
 
       // When running under gdb, forking /proc/self/exe ends up forking the gdb
       // executable instead of Chromium. It is almost safe to assume that no
       // updates will happen while a developer is running with
       // |switches::kUtilityCmdPrefix|. See ChildProcessHost::GetChildPath() for
       // a similar case with Valgrind.
       if (has_cmd_prefix)
         child_flags = ChildProcessHost::CHILD_NORMAL;
 
       base::FilePath exe_path = ChildProcessHost::GetChildPath(child_flags);
       if (exe_path.empty()) {
         NOTREACHED() << "Unable to get utility process binary name.";
         return false;
       }
 
-      base::CommandLine* cmd_line = new base::CommandLine(exe_path);
+      std::unique_ptr<base::CommandLine> cmd_line =
+          base::MakeUnique<base::CommandLine>(exe_path);
     #endif
 
     cmd_line->AppendSwitchASCII(switches::kProcessType,
                                 switches::kUtilityProcess);
     std::string locale = GetContentClient()->browser()->GetApplicationLocale();
     cmd_line->AppendSwitchASCII(switches::kLang, locale);
 
 #if defined(OS_WIN)
     cmd_line->AppendArg(switches::kPrefetchArgumentOther);
 #endif  // defined(OS_WIN)
@@ skipping 23 matching lines @@
       cmd_line->AppendSwitchPath(switches::kUtilityProcessAllowedDir,
                                  exposed_dir_);
     }
 
 #if defined(OS_WIN)
     // Let the utility process know if it is intended to be elevated.
     if (run_elevated_)
       cmd_line->AppendSwitch(switches::kUtilityProcessRunningElevated);
 #endif
 
-    process_->Launch(new UtilitySandboxedProcessLauncherDelegate(
+    process_->Launch(base::MakeUnique<UtilitySandboxedProcessLauncherDelegate>(
                          exposed_dir_, run_elevated_, no_sandbox_, env_),
-                     cmd_line, true);
+                     std::move(cmd_line), true);
   }
 
   return true;
 }
 
 bool UtilityProcessHostImpl::OnMessageReceived(const IPC::Message& message) {
   if (!client_.get())
     return true;
 
   client_task_runner_->PostTask(
@@ skipping 40 matching lines @@
     base::WeakPtr<UtilityProcessHostImpl> host,
     int error_code) {
   if (!host)
     return;
 
   host->OnProcessLaunchFailed(error_code);
   delete host.get();
 }
 
 }  // namespace content