Disallow breakaway from job for unit tests

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"
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 #endif
 
@@ skipping 30 matching lines @@
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
 namespace base {
 
 // Launches a child process using |command_line|. If the child process is still
 // running after |timeout|, it is terminated and |*was_timeout| is set to true.
 // Returns exit code of the process.
 int LaunchChildTestProcessWithOptions(const CommandLine& command_line,
                                       const LaunchOptions& options,
-                                      bool use_job_objects,
+                                      int flags,
                                       base::TimeDelta timeout,
                                       bool* was_timeout);
 
 // See https://groups.google.com/a/chromium.org/d/msg/chromium-dev/nkdTP7sstSc/uT3FaE_sgkAJ .
 using ::operator<<;
 
 // The environment variable name for the total number of test shards.
 const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
 // The environment variable name for the test shard index.
 const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
@@ skipping 154 matching lines @@
     int exit_code,
     const TimeDelta& elapsed_time,
     bool was_timeout,
     const std::string& output) {
   callback.Run(exit_code, elapsed_time, was_timeout, output);
 }
 
 void DoLaunchChildTestProcess(
     const CommandLine& command_line,
     base::TimeDelta timeout,
-    bool use_job_objects,
+    int flags,
     bool redirect_stdio,
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const TestLauncher::LaunchChildGTestProcessCallback& callback) {
   TimeTicks start_time = TimeTicks::Now();
 
   // Redirect child process output to a file.
   base::FilePath output_file;
   CHECK(base::CreateTemporaryFile(&output_file));
 
   LaunchOptions options;
@@ skipping 31 matching lines @@
     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;
   }
 #endif
 
   bool was_timeout = false;
   int exit_code = LaunchChildTestProcessWithOptions(
-      command_line, options, use_job_objects, timeout, &was_timeout);
+      command_line, options, flags, timeout, &was_timeout);
 
   if (redirect_stdio) {
 #if defined(OS_WIN)
     FlushFileBuffers(handle.Get());
     handle.Close();
 #elif defined(OS_POSIX)
     output_file_fd.reset();
 #endif
   }
 
@@ skipping 113 matching lines @@
 
   MaybeSaveSummaryAsJSON();
 
   return run_result_;
 }
 
 void TestLauncher::LaunchChildGTestProcess(
     const CommandLine& command_line,
     const std::string& wrapper,
     base::TimeDelta timeout,
-    bool use_job_objects,
+    int flags,
     const LaunchChildGTestProcessCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Record the exact command line used to launch the child.
   CommandLine new_command_line(
       PrepareCommandLineForGTest(command_line, wrapper));
 
   // When running in parallel mode we need to redirect stdio to avoid mixed-up
   // output. We also always redirect on the bots to get the test output into
   // JSON summary.
   bool redirect_stdio = (parallel_jobs_ > 1) || BotModeEnabled();
 
   worker_pool_owner_->pool()->PostWorkerTask(
       FROM_HERE,
       Bind(&DoLaunchChildTestProcess,
            new_command_line,
            timeout,
-           use_job_objects,
+           flags,
            redirect_stdio,
            MessageLoopProxy::current(),
            Bind(&TestLauncher::OnLaunchTestProcessFinished,
                 Unretained(this),
                 callback)));
 }
 
 void TestLauncher::OnTestFinished(const TestResult& result) {
   ++test_finished_count_;
 
@@ skipping 556 matching lines @@
 #elif defined(OS_POSIX)
   new_command_line.PrependWrapper(wrapper);
 #endif
 
   return new_command_line;
 }
 
 // TODO(phajdan.jr): Move to anonymous namespace.
 int LaunchChildTestProcessWithOptions(const CommandLine& command_line,
                                       const LaunchOptions& options,
-                                      bool use_job_objects,
+                                      int flags,
                                       base::TimeDelta timeout,
                                       bool* was_timeout) {
 #if defined(OS_POSIX)
   // Make sure an option we rely on is present - see LaunchChildGTestProcess.
   DCHECK(options.new_process_group);
 #endif
 
   LaunchOptions new_options(options);
 
 #if defined(OS_WIN)
   DCHECK(!new_options.job_handle);
 
   win::ScopedHandle job_handle;
-  if (use_job_objects) {
+  if (flags & TestLauncher::USE_JOB_OBJECTS) {
     job_handle.Set(CreateJobObject(NULL, NULL));
     if (!job_handle.IsValid()) {
       LOG(ERROR) << "Could not create JobObject.";
       return -1;
     }
 
+    DWORD job_flags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+
     // Allow break-away from job since sandbox and few other places rely on it
     // on Windows versions prior to Windows 8 (which supports nested jobs).
     // TODO(phajdan.jr): Do not allow break-away on Windows 8.
-    if (!SetJobObjectLimitFlags(job_handle.Get(),
-                                JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE |
-                                JOB_OBJECT_LIMIT_BREAKAWAY_OK)) {
+    if (flags & TestLauncher::ALLOW_BREAKAWAY_FROM_JOB)
+      job_flags |= JOB_OBJECT_LIMIT_BREAKAWAY_OK;
+
+    if (!SetJobObjectLimitFlags(job_handle.Get(), job_flags)) {
       LOG(ERROR) << "Could not SetJobObjectLimitFlags.";
       return -1;
     }
 
     new_options.job_handle = job_handle.Get();
   }
 #endif  // defined(OS_WIN)
 
 #if defined(OS_LINUX)
   // To prevent accidental privilege sharing to an untrusted child, processes
@@ skipping 45 matching lines @@
 
     g_live_processes.Get().erase(process_handle);
   }
 
   base::CloseProcessHandle(process_handle);
 
   return exit_code;
 }
 
 }  // namespace base