GTTF: Unify parallel test launching.

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"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/test/gtest_xml_util.h"
-#include "base/test/launcher/parallel_test_launcher.h"
 #include "base/test/launcher/test_launcher.h"
 #include "base/test/test_switches.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_checker.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
@@ skipping 41 matching lines @@
   new_cmd_line.AppendSwitchPath(switches::kTestLauncherOutput, output_file);
   new_cmd_line.AppendSwitchASCII(kGTestFilterFlag, JoinString(test_names, ":"));
   new_cmd_line.AppendSwitch(kSingleProcessTestsFlag);
   new_cmd_line.AppendSwitch(kBraveNewTestLauncherFlag);
 
   return new_cmd_line;
 }
 
 class UnitTestLauncherDelegate : public TestLauncherDelegate {
  public:
-  UnitTestLauncherDelegate(size_t jobs, size_t batch_limit)
-      : parallel_launcher_(jobs),
-        batch_limit_(batch_limit) {
+  explicit UnitTestLauncherDelegate(size_t batch_limit)
+      : batch_limit_(batch_limit) {
   }
 
   virtual ~UnitTestLauncherDelegate() {
     DCHECK(thread_checker_.CalledOnValidThread());
   }
 
  private:
   struct GTestCallbackState {
     TestLauncher* test_launcher;
     std::vector<std::string> test_names;
@@ skipping 71 matching lines @@
     std::vector<std::string> current_test_names;
     current_test_names.push_back(test_name);
     CommandLine cmd_line(
         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;
 
-    parallel_launcher_.LaunchChildGTestProcess(
+    test_launcher->LaunchChildGTestProcess(
         cmd_line,
         std::string(),
         TestTimeouts::test_launcher_timeout(),
         Bind(&UnitTestLauncherDelegate::SerialGTestCallback,
              Unretained(this),
              callback_state,
              new_test_names));
   }
 
   void RunBatch(TestLauncher* test_launcher,
@@ skipping 21 matching lines @@
     // 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;
 
-    parallel_launcher_.LaunchChildGTestProcess(
+    test_launcher->LaunchChildGTestProcess(
         cmd_line,
         std::string(),
         timeout,
         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) {
     DCHECK(thread_checker_.CalledOnValidThread());
     std::vector<std::string> tests_to_relaunch_after_interruption;
-    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_after_interruption);
+    ProcessTestResults(callback_state.test_launcher,
+                       callback_state.test_names,
+                       callback_state.output_file,
+                       output,
+                       exit_code,
+                       was_timeout,
+                       &tests_to_relaunch_after_interruption);
 
     RunBatch(callback_state.test_launcher,
              tests_to_relaunch_after_interruption);
 
-    if (called_any_callbacks)
-      parallel_launcher_.ResetOutputWatchdog();
-
     // 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) {
     DCHECK(thread_checker_.CalledOnValidThread());
     std::vector<std::string> tests_to_relaunch_after_interruption;
     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_after_interruption);
 
     // There is only one test, there cannot be other tests to relaunch
     // due to a crash.
     DCHECK(tests_to_relaunch_after_interruption.empty());
 
-    if (called_any_callbacks) {
-      parallel_launcher_.ResetOutputWatchdog();
-    } else {
-      // There is only one test, we should have called back with its result.
-      NOTREACHED();
-    }
+    // 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));
@@ skipping 92 matching lines @@
         test_launcher->OnTestFinished(test_result);
         called_any_callback = true;
       }
     }
 
     return called_any_callback;
   }
 
   ThreadChecker thread_checker_;
 
-  ParallelTestLauncher parallel_launcher_;
-
   // Maximum number of tests to run in a single batch.
   size_t batch_limit_;
 };
 
 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);
@@ skipping 38 matching lines @@
   fprintf(stdout,
           "Starting tests (using %d parallel jobs)...\n"
           "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", jobs);
   fflush(stdout);
 
   MessageLoopForIO message_loop;
 
-  base::UnitTestLauncherDelegate delegate(jobs, batch_limit);
-  base::TestLauncher launcher(&delegate);
+  base::UnitTestLauncherDelegate delegate(batch_limit);
+  base::TestLauncher launcher(&delegate, jobs);
   bool success = launcher.Run(argc, argv);
 
   fprintf(stdout,
           "Tests took %" PRId64 " seconds.\n",
           (base::TimeTicks::Now() - start_time).InSeconds());
   fflush(stdout);
 
   return (success ? 0 : 1);
 }
 
 }  // namespace base