Update from https://crrev.com/314320

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 103 matching lines @@
                                    JoinString(test_names, ":"));
     new_cmd_line.AppendSwitch(kSingleProcessTestsFlag);
 
     return new_cmd_line;
   }
 
   std::string GetWrapperForChildGTestProcess() override {
     return std::string();
   }
 
+  void RelaunchTests(TestLauncher* test_launcher,
+                     const std::vector<std::string>& test_names,
+                     int launch_flags) override {
+    // Relaunch requested tests in parallel, but only use single
+    // test per batch for more precise results (crashes, etc).
+    for (const std::string& test_name : test_names) {
+      std::vector<std::string> batch;
+      batch.push_back(test_name);
+      RunUnitTestsBatch(test_launcher, this, batch, launch_flags);
+    }
+  }
+
   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) {
@@ skipping 75 matching lines @@
 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(run_test_suite, SysInfo::NumberOfProcessors(),
-                                 true, Bind(&InitGoogleTestChar, &argc, argv));
-}
-
-int LaunchUnitTestsSerially(int argc,
-                            char** argv,
-                            const RunTestSuiteCallback& run_test_suite) {
-  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)
-
-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());
-  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]);
-
-    // 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();
-}
-
-size_t UnitTestLauncherDelegate::RetryTests(
-    TestLauncher* test_launcher,
-    const std::vector<std::string>& test_names) {
-  MessageLoop::current()->PostTask(
-      FROM_HERE, Bind(&UnitTestLauncherDelegate::RunSerially, Unretained(this),
-                      test_launcher, test_names));
-  return test_names.size();
-}
-
-void UnitTestLauncherDelegate::RunSerially(
-    TestLauncher* test_launcher,
-    const std::vector<std::string>& test_names) {
-  if (test_names.empty())
-    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(platform_delegate_->CreateTemporaryFile(&output_file));
-
-  std::vector<std::string> current_test_names;
-  current_test_names.push_back(test_name);
-  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,
-      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(platform_delegate_->CreateTemporaryFile(&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,
-      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,
-    const std::string& output) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  std::vector<std::string> tests_to_relaunch;
-  ProcessTestResults(callback_state.test_launcher, callback_state.test_names,
-                     callback_state.output_file, output, exit_code, was_timeout,
-                     &tests_to_relaunch);
-
-  // Relaunch requested tests in parallel, but only use single
-  // test per batch for more precise results (crashes, test passes
-  // but non-zero exit codes etc).
-  for (size_t i = 0; i < tests_to_relaunch.size(); i++) {
-    std::vector<std::string> batch;
-    batch.push_back(tests_to_relaunch[i]);
-    RunBatch(callback_state.test_launcher, batch);
-  }
-
-  // The temporary file's directory is also temporary.
-  DeleteFile(callback_state.output_file.DirName(), true);
-}
-
-void UnitTestLauncherDelegate::SerialGTestCallback(
-    const GTestCallbackState& callback_state,
-    const std::vector<std::string>& test_names,
-    int exit_code,
-    const TimeDelta& elapsed_time,
-    bool was_timeout,
-    const std::string& output) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  std::vector<std::string> tests_to_relaunch;
-  bool called_any_callbacks =
-      ProcessTestResults(callback_state.test_launcher,
-                         callback_state.test_names, callback_state.output_file,
-                         output, exit_code, was_timeout, &tests_to_relaunch);
-
-  // There is only one test, there cannot be other tests to relaunch
-  // due to a crash.
-  DCHECK(tests_to_relaunch.empty());
-
-  // There is only one test, we should have called back with its result.
-  DCHECK(called_any_callbacks);
-
-  // The temporary file's directory is also temporary.
-  DeleteFile(callback_state.output_file.DirName(), true);
-
-  MessageLoop::current()->PostTask(
-      FROM_HERE, Bind(&UnitTestLauncherDelegate::RunSerially, Unretained(this),
-                      callback_state.test_launcher, test_names));
-}
-
-// static
-bool UnitTestLauncherDelegate::ProcessTestResults(
+// Interprets test results and reports to the test launcher. Returns true
+// on success.
+bool ProcessTestResults(
     TestLauncher* test_launcher,
     const std::vector<std::string>& test_names,
     const base::FilePath& output_file,
     const std::string& output,
     int exit_code,
     bool was_timeout,
     std::vector<std::string>* tests_to_relaunch) {
   std::vector<TestResult> test_results;
   bool crashed = false;
   bool have_test_results =
@@ skipping 63 matching lines @@
     for (size_t i = 0; i < final_results.size(); i++) {
       if (final_results[i].status != TestResult::TEST_SUCCESS) {
         has_non_success_test = true;
         break;
       }
     }
 
     if (!has_non_success_test && exit_code != 0) {
       // This is a bit surprising case: all tests are marked as successful,
       // but the exit code was not zero. This can happen e.g. under memory
-      // tools that report leaks this way.
-
-      if (final_results.size() == 1) {
-        // Easy case. One test only so we know the non-zero exit code
-        // was caused by that one test.
-        final_results[0].status = TestResult::TEST_FAILURE_ON_EXIT;
-      } else {
-        // Harder case. Discard the results and request relaunching all
-        // tests without batching. This will trigger above branch on
-        // relaunch leading to more precise results.
-        LOG(WARNING) << "Not sure which test caused non-zero exit code, "
-                     << "relaunching all of them without batching.";
-
-        for (size_t i = 0; i < final_results.size(); i++)
-          tests_to_relaunch->push_back(final_results[i].full_name);
-
-        return false;
-      }
+      // tools that report leaks this way. Mark all tests as a failure on exit,
+      // and for more precise info they'd need to be retried serially.
+      for (size_t i = 0; i < final_results.size(); i++)
+        final_results[i].status = TestResult::TEST_FAILURE_ON_EXIT;
     }
 
     for (size_t i = 0; i < final_results.size(); i++) {
       // Fix the output snippet after possible changes to the test result.
       final_results[i].output_snippet =
           GetTestOutputSnippet(final_results[i], output);
       test_launcher->OnTestFinished(final_results[i]);
       called_any_callback = true;
     }
   } else {
@@ skipping 13 matching lines @@
       test_result.full_name = test_names[i];
       test_result.status = TestResult::TEST_UNKNOWN;
       test_launcher->OnTestFinished(test_result);
       called_any_callback = true;
     }
   }
 
   return called_any_callback;
 }
 
+// TODO(phajdan.jr): Pass parameters directly with C++11 variadic templates.
+struct GTestCallbackState {
+  TestLauncher* test_launcher;
+  UnitTestPlatformDelegate* platform_delegate;
+  std::vector<std::string> test_names;
+  int launch_flags;
+  FilePath output_file;
+};
+
+void GTestCallback(
+    const GTestCallbackState& callback_state,
+    int exit_code,
+    const TimeDelta& elapsed_time,
+    bool was_timeout,
+    const std::string& output) {
+  std::vector<std::string> tests_to_relaunch;
+  ProcessTestResults(callback_state.test_launcher, callback_state.test_names,
+                     callback_state.output_file, output, exit_code, was_timeout,
+                     &tests_to_relaunch);
+
+  if (!tests_to_relaunch.empty()) {
+    callback_state.platform_delegate->RelaunchTests(
+        callback_state.test_launcher,
+        tests_to_relaunch,
+        callback_state.launch_flags);
+  }
+
+  // The temporary file's directory is also temporary.
+  DeleteFile(callback_state.output_file.DirName(), true);
+}
+
+void SerialGTestCallback(
+    const GTestCallbackState& callback_state,
+    const std::vector<std::string>& test_names,
+    int exit_code,
+    const TimeDelta& elapsed_time,
+    bool was_timeout,
+    const std::string& output) {
+  std::vector<std::string> tests_to_relaunch;
+  bool called_any_callbacks =
+      ProcessTestResults(callback_state.test_launcher,
+                         callback_state.test_names, callback_state.output_file,
+                         output, exit_code, was_timeout, &tests_to_relaunch);
+
+  // There is only one test, there cannot be other tests to relaunch
+  // due to a crash.
+  DCHECK(tests_to_relaunch.empty());
+
+  // There is only one test, we should have called back with its result.
+  DCHECK(called_any_callbacks);
+
+  // The temporary file's directory is also temporary.
+  DeleteFile(callback_state.output_file.DirName(), true);
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      Bind(&RunUnitTestsSerially,
+           callback_state.test_launcher,
+           callback_state.platform_delegate,
+           test_names,
+           callback_state.launch_flags));
+}
+
+}  // namespace
+
+int LaunchUnitTests(int argc,
+                    char** argv,
+                    const RunTestSuiteCallback& run_test_suite) {
+  CommandLine::Init(argc, argv);
+  return LaunchUnitTestsInternal(run_test_suite, SysInfo::NumberOfProcessors(),
+                                 true, Bind(&InitGoogleTestChar, &argc, argv));
+}
+
+int LaunchUnitTestsSerially(int argc,
+                            char** argv,
+                            const RunTestSuiteCallback& run_test_suite) {
+  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)
+
+void RunUnitTestsSerially(
+    TestLauncher* test_launcher,
+    UnitTestPlatformDelegate* platform_delegate,
+    const std::vector<std::string>& test_names,
+    int launch_flags) {
+  if (test_names.empty())
+    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(platform_delegate->CreateTemporaryFile(&output_file));
+
+  std::vector<std::string> current_test_names;
+  current_test_names.push_back(test_name);
+  CommandLine cmd_line(platform_delegate->GetCommandLineForChildGTestProcess(
+      current_test_names, output_file));
+
+  GTestCallbackState callback_state;
+  callback_state.test_launcher = test_launcher;
+  callback_state.platform_delegate = platform_delegate;
+  callback_state.test_names = current_test_names;
+  callback_state.launch_flags = launch_flags;
+  callback_state.output_file = output_file;
+
+  test_launcher->LaunchChildGTestProcess(
+      cmd_line,
+      platform_delegate->GetWrapperForChildGTestProcess(),
+      TestTimeouts::test_launcher_timeout(),
+      launch_flags,
+      Bind(&SerialGTestCallback, callback_state, new_test_names));
+}
+
+void RunUnitTestsBatch(
+    TestLauncher* test_launcher,
+    UnitTestPlatformDelegate* platform_delegate,
+    const std::vector<std::string>& test_names,
+    int launch_flags) {
+  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(platform_delegate->CreateTemporaryFile(&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.platform_delegate = platform_delegate;
+  callback_state.test_names = test_names;
+  callback_state.launch_flags = launch_flags;
+  callback_state.output_file = output_file;
+
+  test_launcher->LaunchChildGTestProcess(
+      cmd_line,
+      platform_delegate->GetWrapperForChildGTestProcess(),
+      timeout,
+      launch_flags,
+      Bind(&GTestCallback, callback_state));
+}
+
+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());
+}
+
+bool UnitTestLauncherDelegate::GetTests(std::vector<SplitTestName>* output) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  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());
+
+  int launch_flags = use_job_objects_ ? TestLauncher::USE_JOB_OBJECTS : 0;
+
+  std::vector<std::string> batch;
+  for (size_t i = 0; i < test_names.size(); i++) {
+    batch.push_back(test_names[i]);
+
+    // Use 0 to indicate unlimited batch size.
+    if (batch.size() >= batch_limit_ && batch_limit_ != 0) {
+      RunUnitTestsBatch(test_launcher, platform_delegate_, batch, launch_flags);
+      batch.clear();
+    }
+  }
+
+  RunUnitTestsBatch(test_launcher, platform_delegate_, batch, launch_flags);
+
+  return test_names.size();
+}
+
+size_t UnitTestLauncherDelegate::RetryTests(
+    TestLauncher* test_launcher,
+    const std::vector<std::string>& test_names) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      Bind(&RunUnitTestsSerially,
+           test_launcher,
+           platform_delegate_,
+           test_names,
+           use_job_objects_ ? TestLauncher::USE_JOB_OBJECTS : 0));
+  return test_names.size();
+}
+
 }  // namespace base