Improve process launch handle sharing API.

content/browser/child_process_launcher_helper_mac.cc

 // Copyright 2017 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 "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/posix/global_descriptors.h"
 #include "content/browser/bootstrap_sandbox_manager_mac.h"
@@ skipping 20 matching lines @@
 mojo::edk::ScopedPlatformHandle
 ChildProcessLauncherHelper::PrepareMojoPipeHandlesOnClientThread() {
   DCHECK_CURRENTLY_ON(client_thread_id_);
   return mojo::edk::ScopedPlatformHandle();
 }
 
 void ChildProcessLauncherHelper::BeforeLaunchOnClientThread() {
   DCHECK_CURRENTLY_ON(client_thread_id_);
 }
 
-std::unique_ptr<FileDescriptorInfo>
+std::unique_ptr<PosixFileDescriptorInfo>
 ChildProcessLauncherHelper::GetFilesToMap() {
   DCHECK_CURRENTLY_ON(BrowserThread::PROCESS_LAUNCHER);
   return CreateDefaultPosixFilesToMap(
       child_process_id(), mojo_client_handle(),
       false /* include_service_required_files */, GetProcessType(),
       command_line());
 }
 
 void ChildProcessLauncherHelper::BeforeLaunchOnLauncherThread(
     const FileMappedForLaunch& files_to_register,
     base::LaunchOptions* options) {
   // Convert FD mapping to FileHandleMappingVector.
-  std::unique_ptr<base::FileHandleMappingVector> fds_to_map =
-      files_to_register.GetMappingWithIDAdjustment(
-          base::GlobalDescriptors::kBaseDescriptor);
+  options->fds_to_remap = files_to_register.GetMappingWithIDAdjustment(
+      base::GlobalDescriptors::kBaseDescriptor);
 
   options->environ = delegate_->GetEnvironment();
 
   if (base::FeatureList::IsEnabled(features::kMacV2Sandbox) &&
       GetProcessType() == switches::kRendererProcess) {
     seatbelt_exec_client_ = base::MakeUnique<sandbox::SeatbeltExecClient>();
     base::StringPiece renderer_sb = GetContentClient()->GetDataResource(
         IDR_RENDERER_SANDBOX_V2_PROFILE, ui::SCALE_FACTOR_NONE);
     std::string profile = renderer_sb.as_string();
 
     seatbelt_exec_client_->SetProfile(profile);
 
     SetupRendererSandboxParameters(seatbelt_exec_client_.get());
 
     int pipe = seatbelt_exec_client_->SendProfileAndGetFD();
 
     base::FilePath helper_executable;
     CHECK(PathService::Get(content::CHILD_PROCESS_EXE, &helper_executable));
 
-    fds_to_map->push_back(std::make_pair(pipe, pipe));
+    options->fds_to_remap.push_back(std::make_pair(pipe, pipe));
 
     // Update the command line to enable the V2 sandbox and pass the
     // communication FD to the helper executable.
     command_line_->AppendSwitch(switches::kEnableV2Sandbox);
     command_line_->AppendArg("--fd_mapping=" + std::to_string(pipe));
   }
 
-  // fds_to_remap will de deleted in AfterLaunchOnLauncherThread() below.
-  options->fds_to_remap = fds_to_map.release();
-
   // Hold the MachBroker lock for the duration of LaunchProcess. The child will
   // send its task port to the parent almost immediately after startup. The Mach
   // message will be delivered to the parent, but updating the record of the
   // launch will wait until after the placeholder PID is inserted below. This
   // ensures that while the child process may send its 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();
 
@@ skipping 11 matching lines @@
     }
   }
   // options now owns the pre_exec_delegate which will be delete on
   // AfterLaunchOnLauncherThread below.
   options->pre_exec_delegate = pre_exec_delegate.release();
 }
 
 ChildProcessLauncherHelper::Process
 ChildProcessLauncherHelper::LaunchProcessOnLauncherThread(
     const base::LaunchOptions& options,
-    std::unique_ptr<FileDescriptorInfo> files_to_register,
+    std::unique_ptr<PosixFileDescriptorInfo> files_to_register,
     bool* is_synchronous_launch,
     int* launch_result) {
   *is_synchronous_launch = true;
   ChildProcessLauncherHelper::Process process;
   process.process = base::LaunchProcess(*command_line(), options);
   *launch_result = process.process.IsValid() ? LAUNCH_RESULT_SUCCESS
                                              : LAUNCH_RESULT_FAILURE;
   return process;
 }
 
 void ChildProcessLauncherHelper::AfterLaunchOnLauncherThread(
     const ChildProcessLauncherHelper::Process& process,
     const base::LaunchOptions& options) {
-  delete options.fds_to_remap;
-
   std::unique_ptr<sandbox::PreExecDelegate> pre_exec_delegate =
     base::WrapUnique(static_cast<sandbox::PreExecDelegate*>(
         options.pre_exec_delegate));
 
   MachBroker* broker = MachBroker::GetInstance();
   if (process.process.IsValid()) {
     broker->AddPlaceholderForPid(process.process.Pid(), child_process_id());
   } else {
     if (pre_exec_delegate) {
       BootstrapSandboxManager::GetInstance()->sandbox()->RevokeToken(
@@ skipping 54 matching lines @@
 base::File OpenFileToShare(const base::FilePath& path,
                            base::MemoryMappedFile::Region* region) {
   // Not used yet (until required files are described in the service manifest on
   // Mac).
   NOTREACHED();
   return base::File();
 }
 
 }  //  namespace internal
 }  // namespace content