Convert installer_util_unittests, sbox_integration_tests, sbox_validation_tests, sbox_unittests to …

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 25 matching lines @@
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_MACOSX)
 #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,
+                                      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";
 
 namespace {
 
@@ skipping 146 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,
     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, timeout, &was_timeout);
+      command_line, options, use_job_objects, 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 61 matching lines @@
     // --test-launcher-jobs flag.
     parallel_jobs_ = 1;
   }
 }
 
 TestLauncher::~TestLauncher() {
   if (worker_pool_owner_)
     worker_pool_owner_->pool()->Shutdown();
 }
 
-bool TestLauncher::Run(int argc, char** argv) {
+bool TestLauncher::Run() {
   if (!Init())
     return false;
 
   // Value of |cycles_| changes after each iteration. Keep track of the
   // original value.
   int requested_cycles = cycles_;
 
 #if defined(OS_POSIX)
   CHECK_EQ(0, pipe(g_shutdown_pipe));
 
@@ skipping 31 matching lines @@
 
   MaybeSaveSummaryAsJSON();
 
   return run_result_;
 }
 
 void TestLauncher::LaunchChildGTestProcess(
     const CommandLine& command_line,
     const std::string& wrapper,
     base::TimeDelta timeout,
+    bool use_job_objects,
     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,
            redirect_stdio,
            MessageLoopProxy::current(),
            Bind(&TestLauncher::OnLaunchTestProcessFinished,
                 Unretained(this),
                 callback)));
 }
 
 void TestLauncher::OnTestFinished(const TestResult& result) {
   ++test_finished_count_;
 
@@ skipping 513 matching lines @@
       end_pos = newline_pos + 1;
   }
 
   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;
 }
 
-int LaunchChildGTestProcess(const CommandLine& command_line,
-                            const std::string& wrapper,
-                            base::TimeDelta timeout,
-                            bool* was_timeout) {
-  LaunchOptions options;
-
-#if defined(OS_POSIX)
-  // On POSIX, we launch the test in a new process group with pgid equal to
-  // its pid. Any child processes that the test may create will inherit the
-  // same pgid. This way, if the test is abruptly terminated, we can clean up
-  // any orphaned child processes it may have left behind.
-  options.new_process_group = true;
-#endif
-
-  return LaunchChildTestProcessWithOptions(
-      PrepareCommandLineForGTest(command_line, wrapper),
-      options,
-      timeout,
-      was_timeout);
-}
-
 CommandLine PrepareCommandLineForGTest(const CommandLine& command_line,
                                        const std::string& wrapper) {
   CommandLine new_command_line(command_line.GetProgram());
   CommandLine::SwitchMap switches = command_line.GetSwitches();
 
   // Strip out gtest_repeat flag - this is handled by the launcher process.
   switches.erase(kGTestRepeatFlag);
 
   // Don't try to write the final XML report in child processes.
   switches.erase(kGTestOutputFlag);
 
   for (CommandLine::SwitchMap::const_iterator iter = switches.begin();
        iter != switches.end(); ++iter) {
     new_command_line.AppendSwitchNative((*iter).first, (*iter).second);
   }
 
   // Prepend wrapper after last CommandLine quasi-copy operation. CommandLine
   // does not really support removing switches well, and trying to do that
   // on a CommandLine with a wrapper is known to break.
   // TODO(phajdan.jr): Give it a try to support CommandLine removing switches.
 #if defined(OS_WIN)
   new_command_line.PrependWrapper(ASCIIToWide(wrapper));
 #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,
                                       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(CreateJobObject(NULL, NULL));
-  if (!job_handle.IsValid()) {
-    LOG(ERROR) << "Could not create JobObject.";
-    return -1;
+  win::ScopedHandle job_handle;
+  if (use_job_objects) {
+    job_handle.Set(CreateJobObject(NULL, NULL));
+    if (!job_handle.IsValid()) {
+      LOG(ERROR) << "Could not create JobObject.";
+      return -1;
+    }
+
+    // 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)) {
+      LOG(ERROR) << "Could not SetJobObjectLimitFlags.";
+      return -1;
+    }
+
+    new_options.job_handle = job_handle.Get();
   }
-
-  // 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)) {
-    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
   // are started with PR_SET_NO_NEW_PRIVS. Do not set that here, since this
   // new child will be privileged and trusted.
   new_options.allow_new_privs = true;
 #endif
 
   base::ProcessHandle process_handle;
@@ skipping 39 matching lines @@
 
     g_live_processes.Get().erase(process_handle);
   }
 
   base::CloseProcessHandle(process_handle);
 
   return exit_code;
 }
 
 }  // namespace base