GTTF: Support running browser tests in parallel

base/test/parallel_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/parallel_test_launcher.h"
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ skipping 27 matching lines @@
 // the purpose of this timeout, which is 1) to avoid buildbot "no output for
 // X seconds" timeout killing the process 2) help communicate status of
 // the test launcher to people looking at the output (no output for a long
 // time is mysterious and gives no info about what is happening) 3) help
 // debugging in case the process hangs anyway.
 const int kOutputTimeoutSeconds = 15;
 
 void RunCallback(
     const ParallelTestLauncher::LaunchChildGTestProcessCallback& callback,
     int exit_code,
+    const TimeDelta& elapsed_time,
     bool was_timeout,
     const std::string& output) {
-  callback.Run(exit_code, was_timeout, output);
+  callback.Run(exit_code, elapsed_time, was_timeout, output);
 }
 
 void DoLaunchChildTestProcess(
     const CommandLine& command_line,
     base::TimeDelta timeout,
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const ParallelTestLauncher::LaunchChildGTestProcessCallback& callback) {
+  TimeTicks start_time = TimeTicks::Now();
+
   // Redirect child process output to a file.
   base::FilePath output_file;
   CHECK(file_util::CreateTemporaryFile(&output_file));
 
   LaunchOptions options;
 #if defined(OS_WIN)
   // Make the file handle inheritable by the child.
   SECURITY_ATTRIBUTES sa_attr;
   sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
   sa_attr.lpSecurityDescriptor = NULL;
@@ skipping 41 matching lines @@
 
   CHECK(base::DeleteFile(output_file, false));
 
   // Run target callback on the thread it was originating from, not on
   // a worker pool thread.
   message_loop_proxy->PostTask(
       FROM_HERE,
       Bind(&RunCallback,
            callback,
            exit_code,
+           TimeTicks::Now() - start_time,
            was_timeout,
            output_file_contents));
 }
 
 }  // namespace
 
 ParallelTestLauncher::ParallelTestLauncher(size_t jobs)
     : timer_(FROM_HERE,
              TimeDelta::FromSeconds(kOutputTimeoutSeconds),
              this,
@@ skipping 11 matching lines @@
   worker_pool_owner_->pool()->Shutdown();
 }
 
 void ParallelTestLauncher::LaunchChildGTestProcess(
     const CommandLine& command_line,
     const std::string& wrapper,
     base::TimeDelta timeout,
     const LaunchChildGTestProcessCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  LaunchSequencedChildGTestProcess(
+      worker_pool_owner_->pool()->GetSequenceToken(),
+      command_line,
+      wrapper,
+      timeout,
+      callback);
+}
+
+void ParallelTestLauncher::LaunchNamedSequencedChildGTestProcess(
+    const std::string& token_name,
+    const CommandLine& command_line,
+    const std::string& wrapper,
+    base::TimeDelta timeout,
+    const LaunchChildGTestProcessCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  LaunchSequencedChildGTestProcess(
+      worker_pool_owner_->pool()->GetNamedSequenceToken(token_name),
+      command_line,
+      wrapper,
+      timeout,
+      callback);
+}
+
+void ParallelTestLauncher::ResetOutputWatchdog() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  timer_.Reset();
+}
+
+void ParallelTestLauncher::LaunchSequencedChildGTestProcess(
+    SequencedWorkerPool::SequenceToken sequence_token,
+    const CommandLine& command_line,
+    const std::string& wrapper,
+    base::TimeDelta timeout,
+    const LaunchChildGTestProcessCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   // Record the exact command line used to launch the child.
   CommandLine new_command_line(
       PrepareCommandLineForGTest(command_line, wrapper));
   launch_sequence_number_++;
   running_processes_map_.insert(
       std::make_pair(launch_sequence_number_, new_command_line));
 
-  worker_pool_owner_->pool()->PostWorkerTask(
+  worker_pool_owner_->pool()->PostSequencedWorkerTask(
+      sequence_token,
       FROM_HERE,
       Bind(&DoLaunchChildTestProcess,
            new_command_line,
            timeout,
            MessageLoopProxy::current(),
            Bind(&ParallelTestLauncher::OnLaunchTestProcessFinished,
                 Unretained(this),
                 launch_sequence_number_,
                 callback)));
 }
 
-void ParallelTestLauncher::ResetOutputWatchdog() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  timer_.Reset();
-}
-
 void ParallelTestLauncher::OnLaunchTestProcessFinished(
     size_t sequence_number,
     const LaunchChildGTestProcessCallback& callback,
     int exit_code,
+    const TimeDelta& elapsed_time,
     bool was_timeout,
     const std::string& output) {
   DCHECK(thread_checker_.CalledOnValidThread());
   running_processes_map_.erase(sequence_number);
-  callback.Run(exit_code, was_timeout, output);
+  callback.Run(exit_code, elapsed_time, was_timeout, output);
 }
 
 void ParallelTestLauncher::OnOutputTimeout() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   fprintf(stdout, "Still waiting for the following processes to finish:\n");
 
   for (RunningProcessesMap::const_iterator i = running_processes_map_.begin();
        i != running_processes_map_.end();
        ++i) {
 #if defined(OS_WIN)
     fwprintf(stdout, L"\t%s\n", i->second.GetCommandLineString().c_str());
 #else
     fprintf(stdout, "\t%s\n", i->second.GetCommandLineString().c_str());
 #endif
   }
 
   fflush(stdout);
 
   // Arm the timer again - otherwise it would fire only once.
   timer_.Reset();
 }
 
 }  // namespace base