Roll Chrome into Mojo.

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 67 matching lines @@
           "    auto means to print it when the test failed.\n"
           "\n"
           "  --test-launcher-total-shards=N\n"
           "    Sets the total number of shards to N.\n"
           "\n"
           "  --test-launcher-shard-index=N\n"
           "    Sets the shard index to run to N (from 0 to TOTAL - 1).\n");
   fflush(stdout);
 }
 
-// Returns command line for child GTest process based on the command line
-// of current process. |test_names| is a vector of test full names
-// (e.g. "A.B"), |output_file| is path to the GTest XML output file.
-CommandLine GetCommandLineForChildGTestProcess(
-    const std::vector<std::string>& test_names,
-    const base::FilePath& output_file) {
-  CommandLine new_cmd_line(*CommandLine::ForCurrentProcess());
+class DefaultUnitTestPlatformDelegate : public UnitTestPlatformDelegate {
+ public:
+  DefaultUnitTestPlatformDelegate() {
+  }
 
-  new_cmd_line.AppendSwitchPath(switches::kTestLauncherOutput, output_file);
-  new_cmd_line.AppendSwitchASCII(kGTestFilterFlag, JoinString(test_names, ":"));
-  new_cmd_line.AppendSwitch(kSingleProcessTestsFlag);
+ private:
+  // UnitTestPlatformDelegate:
+  bool GetTests(std::vector<SplitTestName>* output) override {
+    *output = GetCompiledInTests();
+    return true;
+  }
 
-  return new_cmd_line;
-}
+  bool CreateTemporaryFile(base::FilePath* path) override {
+    if (!CreateNewTempDirectory(FilePath::StringType(), path))
+      return false;
+    *path = path->AppendASCII("test_results.xml");
+    return true;
+  }
+
+  CommandLine GetCommandLineForChildGTestProcess(
+      const std::vector<std::string>& test_names,
+      const base::FilePath& output_file) override {
+    CommandLine new_cmd_line(*CommandLine::ForCurrentProcess());
+
+    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;
+  }
+
+  std::string GetWrapperForChildGTestProcess() override {
+    return std::string();
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(DefaultUnitTestPlatformDelegate);
+};
 
 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;
@@ skipping 50 matching lines @@
 
   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, use_job_objects);
+  DefaultUnitTestPlatformDelegate platform_delegate;
+  UnitTestLauncherDelegate delegate(
+      &platform_delegate, batch_limit, use_job_objects);
   base::TestLauncher launcher(&delegate, default_jobs);
   bool success = launcher.Run();
 
   fprintf(stdout, "Tests took %" PRId64 " seconds.\n",
           (base::TimeTicks::Now() - start_time).InSeconds());
   fflush(stdout);
 
   return (success ? 0 : 1);
 }
 
@@ skipping 31 matching lines @@
                     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)
 
-UnitTestLauncherDelegate::UnitTestLauncherDelegate(size_t batch_limit,
-                                                   bool use_job_objects)
-    : batch_limit_(batch_limit), use_job_objects_(use_job_objects) {
+UnitTestLauncherDelegate::UnitTestLauncherDelegate(
+    UnitTestPlatformDelegate* platform_delegate,
+    size_t batch_limit,
+    bool use_job_objects)
+    : platform_delegate_(platform_delegate),
+      batch_limit_(batch_limit),
+      use_job_objects_(use_job_objects) {
 }
 
 UnitTestLauncherDelegate::~UnitTestLauncherDelegate() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 UnitTestLauncherDelegate::GTestCallbackState::GTestCallbackState() {
 }
 
 UnitTestLauncherDelegate::GTestCallbackState::~GTestCallbackState() {
 }
 
 bool UnitTestLauncherDelegate::GetTests(std::vector<SplitTestName>* output) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  *output = GetCompiledInTests();
-  return true;
+  return platform_delegate_->GetTests(output);
 }
 
 bool UnitTestLauncherDelegate::ShouldRunTest(const std::string& test_case_name,
                                              const std::string& test_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // There is no additional logic to disable specific tests.
   return true;
 }
 
 size_t UnitTestLauncherDelegate::RunTests(
     TestLauncher* test_launcher,
     const std::vector<std::string>& test_names) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::vector<std::string> batch;
   for (size_t i = 0; i < test_names.size(); i++) {
     batch.push_back(test_names[i]);
 
-    if (batch.size() >= batch_limit_) {
+    // Use 0 to indicate unlimited batch size.
+    if (batch.size() >= batch_limit_ && batch_limit_ != 0) {
       RunBatch(test_launcher, batch);
       batch.clear();
     }
   }
 
   RunBatch(test_launcher, batch);
 
   return test_names.size();
 }
 
@@ skipping 13 matching lines @@
     return;
 
   std::vector<std::string> new_test_names(test_names);
   std::string test_name(new_test_names.back());
   new_test_names.pop_back();
 
   // Create a dedicated temporary directory to store the xml result data
   // per run to ensure clean state and make it possible to launch multiple
   // processes in parallel.
   base::FilePath output_file;
-  CHECK(CreateNewTempDirectory(FilePath::StringType(), &output_file));
-  output_file = output_file.AppendASCII("test_results.xml");
+  CHECK(platform_delegate_->CreateTemporaryFile(&output_file));
 
   std::vector<std::string> current_test_names;
   current_test_names.push_back(test_name);
-  CommandLine cmd_line(
-      GetCommandLineForChildGTestProcess(current_test_names, output_file));
+  CommandLine cmd_line(platform_delegate_->GetCommandLineForChildGTestProcess(
+      current_test_names, output_file));
 
   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(),
+      cmd_line,
+      platform_delegate_->GetWrapperForChildGTestProcess(),
+      TestTimeouts::test_launcher_timeout(),
       use_job_objects_ ? TestLauncher::USE_JOB_OBJECTS : 0,
       Bind(&UnitTestLauncherDelegate::SerialGTestCallback, Unretained(this),
            callback_state, new_test_names));
 }
 
 void UnitTestLauncherDelegate::RunBatch(
     TestLauncher* test_launcher,
     const std::vector<std::string>& test_names) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (test_names.empty())
     return;
 
   // Create a dedicated temporary directory to store the xml result data
   // per run to ensure clean state and make it possible to launch multiple
   // processes in parallel.
   base::FilePath output_file;
-  CHECK(CreateNewTempDirectory(FilePath::StringType(), &output_file));
-  output_file = output_file.AppendASCII("test_results.xml");
+  CHECK(platform_delegate_->CreateTemporaryFile(&output_file));
 
-  CommandLine cmd_line(
-      GetCommandLineForChildGTestProcess(test_names, output_file));
+  CommandLine cmd_line(platform_delegate_->GetCommandLineForChildGTestProcess(
+      test_names, output_file));
 
   // Adjust the timeout depending on how many tests we're running
   // (note that e.g. the last batch of tests will be smaller).
   // TODO(phajdan.jr): Consider an adaptive timeout, which can change
   // depending on how many tests ran and how many remain.
   // Note: do NOT parse child's stdout to do that, it's known to be
   // unreliable (e.g. buffering issues can mix up the output).
   base::TimeDelta timeout =
       test_names.size() * TestTimeouts::test_launcher_timeout();
 
   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,
+      cmd_line,
+      platform_delegate_->GetWrapperForChildGTestProcess(),
+      timeout,
       use_job_objects_ ? TestLauncher::USE_JOB_OBJECTS : 0,
       Bind(&UnitTestLauncherDelegate::GTestCallback, Unretained(this),
            callback_state));
 }
 
 void UnitTestLauncherDelegate::GTestCallback(
     const GTestCallbackState& callback_state,
     int exit_code,
     const TimeDelta& elapsed_time,
     bool was_timeout,
@@ skipping 176 matching lines @@
       test_result.status = TestResult::TEST_UNKNOWN;
       test_launcher->OnTestFinished(test_result);
       called_any_callback = true;
     }
   }
 
   return called_any_callback;
 }
 
 }  // namespace base