GTTF: Support running browser tests in parallel

base/test/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/unit_test_launcher.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 81 matching lines @@
   struct TestLaunchInfo {
     std::string GetFullName() const {
       return test_case_name + "." + test_name;
     }
 
     std::string test_case_name;
     std::string test_name;
     TestResultCallback callback;
   };
 
+  virtual std::string GetTestNameForFiltering(
+      const testing::TestCase* test_case,
+      const testing::TestInfo* test_info) OVERRIDE {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
+    return std::string(test_case->name()) + "." + test_info->name();
+  }
+
   virtual bool ShouldRunTest(const testing::TestCase* test_case,
                              const testing::TestInfo* test_info) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     // There is no additional logic to disable specific tests.
     return true;
   }
 
   virtual void RunTest(const testing::TestCase* test_case,
                        const testing::TestInfo* test_info,
@@ skipping 48 matching lines @@
         Bind(&UnitTestLauncherDelegate::GTestCallback,
              base::Unretained(this),
              tests_,
              output_file));
     tests_.clear();
   }
 
   void GTestCallback(const std::vector<TestLaunchInfo>& tests,
                      const FilePath& output_file,
                      int exit_code,
+                     const TimeDelta& elapsed_time,
                      bool was_timeout,
                      const std::string& output) {
     DCHECK(thread_checker_.CalledOnValidThread());
     std::vector<TestLaunchInfo> tests_to_relaunch_after_interruption;
     bool called_any_callbacks =
         ProcessTestResults(tests,
                            output_file,
                            output,
                            exit_code,
                            was_timeout,
                            &tests_to_relaunch_after_interruption);
 
     for (size_t i = 0; i < tests_to_relaunch_after_interruption.size(); i++)
       tests_.push_back(tests_to_relaunch_after_interruption[i]);
     RunRemainingTests();
 
     if (called_any_callbacks)
       parallel_launcher_.ResetOutputWatchdog();
 
     // The temporary file's directory is also temporary.
     DeleteFile(output_file.DirName(), true);
   }
 
-  static void MaybePrintTestOutputSnippet(const TestResult& result,
-                                          const std::string& full_output) {
-    if (result.status == TestResult::TEST_SUCCESS)
-      return;
-
-    size_t run_pos = full_output.find(std::string("[ RUN      ] ") +
-                                      result.GetFullName());
-    if (run_pos == std::string::npos)
-      return;
-
-    size_t end_pos = full_output.find(std::string("[  FAILED  ] ") +
-                                      result.GetFullName(),
-                                      run_pos);
-    if (end_pos != std::string::npos) {
-      size_t newline_pos = full_output.find("\n", end_pos);
-      if (newline_pos != std::string::npos)
-        end_pos = newline_pos + 1;
-    }
-
-    std::string snippet(full_output.substr(run_pos));
-    if (end_pos != std::string::npos)
-      snippet = full_output.substr(run_pos, end_pos - run_pos);
-
-    // TODO(phajdan.jr): Indent each line of the snippet so it's more
-    // noticeable.
-    fprintf(stdout, "%s", snippet.c_str());
-    fflush(stdout);
-  }
-
   static bool ProcessTestResults(
       const std::vector<TestLaunchInfo>& tests,
       const base::FilePath& output_file,
       const std::string& output,
       int exit_code,
       bool was_timeout,
       std::vector<TestLaunchInfo>* tests_to_relaunch_after_interruption) {
     std::vector<TestResult> test_results;
     bool crashed = false;
     bool have_test_results =
@@ skipping 16 matching lines @@
           if (test_result.status == TestResult::TEST_CRASH) {
             had_interrupted_test = true;
 
             if (was_timeout) {
               // Fix up the test status: we forcibly kill the child process
               // after the timeout, so from XML results it looks just like
               // a crash.
               test_result.status = TestResult::TEST_TIMEOUT;
             }
           }
-          MaybePrintTestOutputSnippet(test_result, output);
+          PrintTestOutputSnippetOnFailure(test_result, output);
           tests[i].callback.Run(test_result);
           called_any_callback = true;
         } else if (had_interrupted_test) {
           tests_to_relaunch_after_interruption->push_back(tests[i]);
         } else {
           // TODO(phajdan.jr): Explicitly pass the info that the test didn't
           // run for a mysterious reason.
           LOG(ERROR) << "no test result for " << tests[i].GetFullName();
           TestResult test_result;
           test_result.test_case_name = tests[i].test_case_name;
           test_result.test_name = tests[i].test_name;
           test_result.status = TestResult::TEST_UNKNOWN;
-          MaybePrintTestOutputSnippet(test_result, output);
+          PrintTestOutputSnippetOnFailure(test_result, output);
           tests[i].callback.Run(test_result);
           called_any_callback = true;
         }
       }
 
       // TODO(phajdan.jr): Handle the case where processing XML output
       // indicates a crash but none of the test results is marked as crashing.
 
       // TODO(phajdan.jr): Handle the case where the exit code is non-zero
       // but results file indicates that all tests passed (e.g. crash during
@@ skipping 92 matching lines @@
 
   fprintf(stdout,
           "Tests took %" PRId64 " seconds.\n",
           (base::TimeTicks::Now() - start_time).InSeconds());
   fflush(stdout);
 
   return exit_code;
 }
 
 }  // namespace base