Revert of Revert of Convert installer_util_unittests, sbox_integration_tests, sbox_validation_tests, sbox_unittests to …

base/test/launcher/unit_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/unit_test_launcher.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 84 matching lines @@
 
   new_cmd_line.AppendSwitchPath(switches::kTestLauncherOutput, output_file);
   new_cmd_line.AppendSwitchASCII(kGTestFilterFlag, JoinString(test_names, ":"));
   new_cmd_line.AppendSwitch(kSingleProcessTestsFlag);
 
   return new_cmd_line;
 }
 
 class UnitTestLauncherDelegate : public TestLauncherDelegate {
  public:
-  explicit UnitTestLauncherDelegate(size_t batch_limit)
-      : batch_limit_(batch_limit) {
+  explicit UnitTestLauncherDelegate(size_t batch_limit, bool use_job_objects)
+      : batch_limit_(batch_limit),
+        use_job_objects_(use_job_objects) {
   }
 
   virtual ~UnitTestLauncherDelegate() {
     DCHECK(thread_checker_.CalledOnValidThread());
   }
 
  private:
   struct GTestCallbackState {
     TestLauncher* test_launcher;
     std::vector<std::string> test_names;
@@ skipping 62 matching lines @@
 
     GTestCallbackState callback_state;
     callback_state.test_launcher = test_launcher;
     callback_state.test_names = current_test_names;
     callback_state.output_file = output_file;
 
     test_launcher->LaunchChildGTestProcess(
         cmd_line,
         std::string(),
         TestTimeouts::test_launcher_timeout(),
+        use_job_objects_,
         Bind(&UnitTestLauncherDelegate::SerialGTestCallback,
              Unretained(this),
              callback_state,
              new_test_names));
   }
 
   void RunBatch(TestLauncher* test_launcher,
                 const std::vector<std::string>& test_names) {
     DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 21 matching lines @@
 
     GTestCallbackState callback_state;
     callback_state.test_launcher = test_launcher;
     callback_state.test_names = test_names;
     callback_state.output_file = output_file;
 
     test_launcher->LaunchChildGTestProcess(
         cmd_line,
         std::string(),
         timeout,
+        use_job_objects_,
         Bind(&UnitTestLauncherDelegate::GTestCallback,
              Unretained(this),
              callback_state));
   }
 
   void GTestCallback(const GTestCallbackState& callback_state,
                      int exit_code,
                      const TimeDelta& elapsed_time,
                      bool was_timeout,
                      const std::string& output) {
@@ skipping 189 matching lines @@
       }
     }
 
     return called_any_callback;
   }
 
   ThreadChecker thread_checker_;
 
   // Maximum number of tests to run in a single batch.
   size_t batch_limit_;
+
+  // Determines whether we use job objects on Windows.
+  bool use_job_objects_;
 };
 
 bool GetSwitchValueAsInt(const std::string& switch_name, int* result) {
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switch_name))
     return true;
 
   std::string switch_value =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switch_name);
   if (!StringToInt(switch_value, result) || *result < 1) {
     LOG(ERROR) << "Invalid value for " << switch_name << ": " << switch_value;
     return false;
   }
 
   return true;
 }
 
-int LaunchUnitTestsInternal(int argc,
-                            char** argv,
-                            const RunTestSuiteCallback& run_test_suite,
-                            int default_jobs) {
-  CommandLine::Init(argc, argv);
-
+int LaunchUnitTestsInternal(const RunTestSuiteCallback& run_test_suite,
+                            int default_jobs,
+                            bool use_job_objects,
+                            const Closure& gtest_init) {
 #if defined(OS_ANDROID)
   // We can't easily fork on Android, just run the test suite directly.
   return run_test_suite.Run();
 #else
   bool force_single_process = false;
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kTestLauncherDebugLauncher)) {
     fprintf(stdout, "Forcing test launcher debugging mode.\n");
     fflush(stdout);
   } else {
@@ skipping 24 matching lines @@
   }
 #endif
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(kHelpFlag)) {
     PrintUsage();
     return 0;
   }
 
   base::TimeTicks start_time(base::TimeTicks::Now());
 
-  testing::InitGoogleTest(&argc, argv);
+  gtest_init.Run();
   TestTimeouts::Initialize();
 
   int batch_limit = kDefaultTestBatchLimit;
   if (!GetSwitchValueAsInt(switches::kTestLauncherBatchLimit, &batch_limit))
     return 1;
 
   fprintf(stdout,
           "IMPORTANT DEBUGGING NOTE: batches of tests are run inside their\n"
           "own process. For debugging a test inside a debugger, use the\n"
           "--gtest_filter=<your_test_name> flag along with\n"
           "--single-process-tests.\n");
   fflush(stdout);
 
   MessageLoopForIO message_loop;
 
-  UnitTestLauncherDelegate delegate(batch_limit);
+  UnitTestLauncherDelegate delegate(batch_limit, use_job_objects);
   base::TestLauncher launcher(&delegate, default_jobs);
-  bool success = launcher.Run(argc, argv);
+  bool success = launcher.Run();
 
   fprintf(stdout,
           "Tests took %" PRId64 " seconds.\n",
           (base::TimeTicks::Now() - start_time).InSeconds());
   fflush(stdout);
 
   return (success ? 0 : 1);
 }
 
+void InitGoogleTestChar(int* argc, char** argv) {
+  testing::InitGoogleTest(argc, argv);
+}
+
+#if defined(OS_WIN)
+void InitGoogleTestWChar(int* argc, wchar_t** argv) {
+  testing::InitGoogleTest(argc, argv);
+}
+#endif  // defined(OS_WIN)
+
 }  // namespace
 
 int LaunchUnitTests(int argc,
                     char** argv,
                     const RunTestSuiteCallback& run_test_suite) {
+  CommandLine::Init(argc, argv);
   return LaunchUnitTestsInternal(
-      argc, argv, run_test_suite, SysInfo::NumberOfProcessors());
+      run_test_suite,
+      SysInfo::NumberOfProcessors(),
+      true,
+      Bind(&InitGoogleTestChar, &argc, argv));
 }
 
 int LaunchUnitTestsSerially(int argc,
                             char** argv,
                             const RunTestSuiteCallback& run_test_suite) {
-  return LaunchUnitTestsInternal(argc, argv, run_test_suite, 1);
+  CommandLine::Init(argc, argv);
+  return LaunchUnitTestsInternal(
+      run_test_suite,
+      1,
+      true,
+      Bind(&InitGoogleTestChar, &argc, argv));
 }
 
+#if defined(OS_WIN)
+int LaunchUnitTests(int argc,
+                    wchar_t** argv,
+                    bool use_job_objects,
+                    const RunTestSuiteCallback& run_test_suite) {
+  // Windows CommandLine::Init ignores argv anyway.
+  CommandLine::Init(argc, NULL);
+  return LaunchUnitTestsInternal(
+      run_test_suite,
+      SysInfo::NumberOfProcessors(),
+      use_job_objects,
+      Bind(&InitGoogleTestWChar, &argc, argv));
+}
+#endif  // defined(OS_WIN)
+
 }  // namespace base