GTTF: Unify parallel test launching.

base/test/launcher/test_launcher.h

 // 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.
 
 #ifndef BASE_TEST_LAUNCHER_TEST_LAUNCHER_H_
 #define BASE_TEST_LAUNCHER_TEST_LAUNCHER_H_
 
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/test/launcher/test_result.h"
 #include "base/test/launcher/test_results_tracker.h"
 #include "base/time/time.h"
+#include "base/timer/timer.h"
 
 class CommandLine;
 
 namespace testing {
 class TestCase;
 class TestInfo;
 }
 
 namespace base {
 
 struct LaunchOptions;
+class SequencedWorkerPoolOwner;
 class TestLauncher;
 
 // Constants for GTest command-line flags.
 extern const char kGTestFilterFlag[];
 extern const char kGTestHelpFlag[];
 extern const char kGTestListTestsFlag[];
 extern const char kGTestRepeatFlag[];
 extern const char kGTestRunDisabledTestsFlag[];
 extern const char kGTestOutputFlag[];
 
@@ skipping 35 matching lines @@
   virtual size_t RetryTests(TestLauncher* test_launcher,
                             const std::vector<std::string>& test_names) = 0;
 
  protected:
   virtual ~TestLauncherDelegate();
 };
 
 // Launches tests using a TestLauncherDelegate.
 class TestLauncher {
  public:
-  explicit TestLauncher(TestLauncherDelegate* launcher_delegate);
+  // Constructor. |parallel_jobs| is the limit of simultaneous parallel test
+  // jobs.
+  TestLauncher(TestLauncherDelegate* launcher_delegate, size_t parallel_jobs);
   ~TestLauncher();
 
   // Runs the launcher. Must be called at most once.
   bool Run(int argc, char** argv) WARN_UNUSED_RESULT;
 
+  // Callback called after a child process finishes. First argument is the exit
+  // code, second one is child process elapsed time, third one is true if
+  // the child process was terminated because of a timeout, and fourth one
+  // contains output of the child (stdout and stderr together).
+  typedef Callback<void(int, const TimeDelta&, bool, const std::string&)>
+      LaunchChildGTestProcessCallback;
+
+  // Launches a child process (assumed to be gtest-based binary) using
+  // |command_line|. If |wrapper| is not empty, it is prepended to the final
+  // command line. If the child process is still running after |timeout|, it
+  // is terminated. After the child process finishes |callback| is called
+  // on the same thread this method was called.
+  void LaunchChildGTestProcess(const CommandLine& command_line,
+                               const std::string& wrapper,
+                               base::TimeDelta timeout,
+                               const LaunchChildGTestProcessCallback& callback);
+
   // Called when a test has finished running.
   void OnTestFinished(const TestResult& result);
 
  private:
   bool Init() WARN_UNUSED_RESULT;
 
   // Runs all tests in current iteration. Uses callbacks to communicate success.
   void RunTests();
 
   void RunTestIteration();
 
-  void OnAllTestsStarted();
-
   // Saves test results summary as JSON if requested from command line.
   void MaybeSaveSummaryAsJSON();
 
+  // Called on a worker thread after a child process finishes.
+  void OnLaunchTestProcessFinished(
+      const LaunchChildGTestProcessCallback& callback,
+      int exit_code,
+      const TimeDelta& elapsed_time,
+      bool was_timeout,
+      const std::string& output);
+
+  // Called by the delay timer when no output was made for a while.
+  void OnOutputTimeout();
+
+  // Make sure we don't accidentally call the wrong methods e.g. on the worker
+  // pool thread. With lots of callbacks used this is non-trivial.
+  // Should be the first member so that it's destroyed last: when destroying
+  // other members, especially the worker pool, we may check the code is running
+  // on the correct thread.
+  ThreadChecker thread_checker_;
+
   TestLauncherDelegate* launcher_delegate_;
 
   // Support for outer sharding, just like gtest does.
   int32 total_shards_;  // Total number of outer shards, at least one.
   int32 shard_index_;   // Index of shard the launcher is to run.
 
   int cycles_;  // Number of remaining test itreations, or -1 for infinite.
 
   // Test filters (empty means no filter). Entries are separated by colons.
   std::string positive_test_filter_;
@@ skipping 19 matching lines @@
   size_t retry_limit_;
 
   // Tests to retry in this iteration.
   std::set<std::string> tests_to_retry_;
 
   // Result to be returned from Run.
   bool run_result_;
 
   TestResultsTracker results_tracker_;
 
+  // Watchdog timer to make sure we do not go without output for too long.
+  DelayTimer<TestLauncher> watchdog_timer_;
+
+  // Worker pool used to launch processes in parallel.
+  scoped_ptr<SequencedWorkerPoolOwner> worker_pool_owner_;
+
   DISALLOW_COPY_AND_ASSIGN(TestLauncher);
 };
 
 // Extract part from |full_output| that applies to |result|.
 std::string GetTestOutputSnippet(const TestResult& result,
                                  const std::string& full_output);
 
 // Launches a child process (assumed to be gtest-based binary)
 // using |command_line|. If |wrapper| is not empty, it is prepended
 // to the final command line. If the child process is still running
@@ skipping 12 matching lines @@
 // 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,
                                       base::TimeDelta timeout,
                                       bool* was_timeout);
 
 }  // namespace base
 
 #endif  // BASE_TEST_LAUNCHER_TEST_LAUNCHER_H_