Improve process launch handle sharing API.

base/process/process_util_unittest.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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 466 matching lines @@
 TEST_F(ProcessUtilTest, InheritSpecifiedHandles) {
   // Manually create the event, so that it can be inheritable.
   SECURITY_ATTRIBUTES security_attributes = {};
   security_attributes.nLength = static_cast<DWORD>(sizeof(security_attributes));
   security_attributes.lpSecurityDescriptor = NULL;
   security_attributes.bInheritHandle = true;
 
   // Takes ownership of the event handle.
   base::WaitableEvent event(base::win::ScopedHandle(
       CreateEvent(&security_attributes, true, false, NULL)));
-  base::HandlesToInheritVector handles_to_inherit;
-  handles_to_inherit.push_back(event.handle());
   base::LaunchOptions options;
-  options.handles_to_inherit = &handles_to_inherit;
+  options.handles_to_inherit.push_back(event.handle());
 
   base::CommandLine cmd_line = MakeCmdLine("TriggerEventChildProcess");
   cmd_line.AppendSwitchASCII(
       kEventToTriggerHandleSwitch,
       base::Uint64ToString(reinterpret_cast<uint64_t>(event.handle())));
 
   // This functionality actually requires Vista or later. Make sure that it
   // fails properly on XP.
   if (base::win::GetVersion() < base::win::VERSION_VISTA) {
     EXPECT_FALSE(base::LaunchProcess(cmd_line, options).IsValid());
@@ skipping 123 matching lines @@
   DPCHECK(ret == 0);
 
   return 0;
 }
 
 int ProcessUtilTest::CountOpenFDsInChild() {
   int fds[2];
   if (pipe(fds) < 0)
     NOTREACHED();
 
-  base::FileHandleMappingVector fd_mapping_vec;
-  fd_mapping_vec.push_back(std::pair<int, int>(fds[1], kChildPipe));
   base::LaunchOptions options;
-  options.fds_to_remap = &fd_mapping_vec;
+  options.fds_to_remap.push_back(std::pair<int, int>(fds[1], kChildPipe));
   base::SpawnChildResult spawn_child =
       SpawnChildWithOptions("ProcessUtilsLeakFDChildProcess", options);
   CHECK(spawn_child.process.IsValid());
   int ret = IGNORE_EINTR(close(fds[1]));
   DPCHECK(ret == 0);
 
   // Read number of open files in client process from pipe;
   int num_open_files = -1;
   ssize_t bytes_read =
       HANDLE_EINTR(read(fds[0], &num_open_files, sizeof(num_open_files)));
@@ skipping 43 matching lines @@
   ret = IGNORE_EINTR(close(dev_null));
   DPCHECK(ret == 0);
 }
 
 namespace {
 
 std::string TestLaunchProcess(const std::vector<std::string>& args,
                               const base::EnvironmentMap& env_changes,
                               const bool clear_environ,
                               const int clone_flags) {
-  base::FileHandleMappingVector fds_to_remap;
-
   int fds[2];
   PCHECK(pipe(fds) == 0);
 
-  fds_to_remap.push_back(std::make_pair(fds[1], 1));
   base::LaunchOptions options;
   options.wait = true;
   options.environ = env_changes;
   options.clear_environ = clear_environ;
-  options.fds_to_remap = &fds_to_remap;
+  options.fds_to_remap.push_back(std::make_pair(fds[1], 1));
 #if defined(OS_LINUX)
   options.clone_flags = clone_flags;
 #else
   CHECK_EQ(0, clone_flags);
 #endif  // defined(OS_LINUX)
   EXPECT_TRUE(base::LaunchProcess(args, options).IsValid());
   PCHECK(IGNORE_EINTR(close(fds[1])) == 0);
 
   char buf[512];
   const ssize_t n = HANDLE_EINTR(read(fds[0], buf, sizeof(buf)));
@@ skipping 223 matching lines @@
   int fd_;
   DISALLOW_COPY_AND_ASSIGN(ReadFromPipeDelegate);
 };
 
 TEST_F(ProcessUtilTest, PreExecHook) {
   int pipe_fds[2];
   ASSERT_EQ(0, pipe(pipe_fds));
 
   base::ScopedFD read_fd(pipe_fds[0]);
   base::ScopedFD write_fd(pipe_fds[1]);
-  base::FileHandleMappingVector fds_to_remap;
-  fds_to_remap.push_back(std::make_pair(read_fd.get(), read_fd.get()));
 
   ReadFromPipeDelegate read_from_pipe_delegate(read_fd.get());
   base::LaunchOptions options;
-  options.fds_to_remap = &fds_to_remap;
+  options.fds_to_remap.push_back(std::make_pair(read_fd.get(), read_fd.get()));
   options.pre_exec_delegate = &read_from_pipe_delegate;
   base::SpawnChildResult spawn_child =
       SpawnChildWithOptions("SimpleChildProcess", options);
   ASSERT_TRUE(spawn_child.process.IsValid());
 
   read_fd.reset();
   ASSERT_EQ(1, HANDLE_EINTR(write(write_fd.get(), &kPipeValue, 1)));
 
   int exit_code = 42;
   EXPECT_TRUE(spawn_child.process.WaitForExit(&exit_code));
@@ skipping 68 matching lines @@
 
   base::SpawnChildResult spawn_child =
       SpawnChildWithOptions("SimpleChildProcess", options);
   ASSERT_TRUE(spawn_child.process.IsValid());
 
   int exit_code = kSuccess;
   EXPECT_TRUE(spawn_child.process.WaitForExit(&exit_code));
   EXPECT_NE(kSuccess, exit_code);
 }
 #endif  // defined(OS_LINUX)