Improve process launch handle sharing API.

base/test/launcher/test_launcher.cc

 // Copyright 2013 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/test/launcher/test_launcher.h"
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 372 matching lines @@
     const TestLauncher::GTestProcessCompletedCallback& completed_callback,
     const TestLauncher::GTestProcessLaunchedCallback& launched_callback) {
   TimeTicks start_time = TimeTicks::Now();
 
   // Redirect child process output to a file.
   FilePath output_file;
   CHECK(CreateTemporaryFile(&output_file));
 
   LaunchOptions options;
 #if defined(OS_WIN)
+  options.inherit_mode = test_launch_options.inherit_mode;
+  options.handles_to_inherit = test_launch_options.handles_to_inherit;
+
   win::ScopedHandle handle;
 
   if (redirect_stdio) {
     handle.Set(CreateFile(output_file.value().c_str(), GENERIC_WRITE,
                           FILE_SHARE_READ | FILE_SHARE_DELETE, nullptr,
                           OPEN_EXISTING, FILE_ATTRIBUTE_TEMPORARY, NULL));
     CHECK(handle.IsValid());
-    options.inherit_handles = true;
     options.stdin_handle = INVALID_HANDLE_VALUE;
     options.stdout_handle = handle.Get();
     options.stderr_handle = handle.Get();
-  }
-
-  if (test_launch_options.inherit_handles) {
-    if (!options.inherit_handles) {
-      options.inherit_handles = true;
-      options.stdin_handle = nullptr;
-      options.stdout_handle = nullptr;
-      options.stderr_handle = nullptr;
-    }
-    DCHECK(!options.handles_to_inherit);
-    options.handles_to_inherit = test_launch_options.handles_to_inherit;
+    // See LaunchOptions.stdout_handle comments for why this compares against
+    // FILE_TYPE_CHAR.
+    if (options.inherit_mode == base::LaunchOptions::Inherit::kSpecific &&
+        GetFileType(handle.Get()) != FILE_TYPE_CHAR)
+      options.handles_to_inherit.push_back(handle.Get());
   }
 
 #elif defined(OS_POSIX)
   options.new_process_group = true;
 #if defined(OS_LINUX)
   options.kill_on_parent_death = true;
 #endif  // defined(OS_LINUX)
 
-  FileHandleMappingVector fds_mapping;
   ScopedFD output_file_fd;
 
+  options.fds_to_remap = test_launch_options.fds_to_remap;
   if (redirect_stdio) {
     output_file_fd.reset(open(output_file.value().c_str(), O_RDWR));
     CHECK(output_file_fd.is_valid());
 
-    fds_mapping.push_back(std::make_pair(output_file_fd.get(), STDOUT_FILENO));
-    fds_mapping.push_back(std::make_pair(output_file_fd.get(), STDERR_FILENO));
-    options.fds_to_remap = &fds_mapping;
-  }
-  if (test_launch_options.fds_to_remap) {
-    fds_mapping.insert(fds_mapping.end(),
-                       test_launch_options.fds_to_remap->begin(),
-                       test_launch_options.fds_to_remap->end());
-    options.fds_to_remap = &fds_mapping;
+    options.fds_to_remap.push_back(
+        std::make_pair(output_file_fd.get(), STDOUT_FILENO));
+    options.fds_to_remap.push_back(
+        std::make_pair(output_file_fd.get(), STDERR_FILENO));
   }
 #endif
 
   bool was_timeout = false;
   int exit_code = LaunchChildTestProcessWithOptions(
       command_line, options, test_launch_options.flags, timeout,
       launched_callback, &was_timeout);
 
   if (redirect_stdio) {
 #if defined(OS_WIN)
@@ skipping 26 matching lines @@
 const char kGTestFilterFlag[] = "gtest_filter";
 const char kGTestFlagfileFlag[] = "gtest_flagfile";
 const char kGTestHelpFlag[]   = "gtest_help";
 const char kGTestListTestsFlag[] = "gtest_list_tests";
 const char kGTestRepeatFlag[] = "gtest_repeat";
 const char kGTestRunDisabledTestsFlag[] = "gtest_also_run_disabled_tests";
 const char kGTestOutputFlag[] = "gtest_output";
 
 TestLauncherDelegate::~TestLauncherDelegate() {}
 
+TestLauncher::LaunchOptions::LaunchOptions() = default;
+TestLauncher::LaunchOptions::LaunchOptions(const LaunchOptions& other) =
+    default;
+TestLauncher::LaunchOptions::~LaunchOptions() = default;
+
 TestLauncher::TestLauncher(TestLauncherDelegate* launcher_delegate,
                            size_t parallel_jobs)
     : launcher_delegate_(launcher_delegate),
       total_shards_(1),
       shard_index_(0),
       cycles_(1),
       test_found_count_(0),
       test_started_count_(0),
       test_finished_count_(0),
       test_success_count_(0),
@@ skipping 729 matching lines @@
   }
 
   std::string snippet(full_output.substr(run_pos));
   if (end_pos != std::string::npos)
     snippet = full_output.substr(run_pos, end_pos - run_pos);
 
   return snippet;
 }
 
 }  // namespace base