GTTF: Support running browser tests in parallel

base/test/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/test_launcher.h"
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 #endif
 
@@ skipping 465 matching lines @@
       std::string test_name = test_info->test_case_name();
       test_name.append(".");
       test_name.append(test_info->name());
 
       // Skip disabled tests.
       if (test_name.find("DISABLED") != std::string::npos &&
           !command_line->HasSwitch(kGTestRunDisabledTestsFlag)) {
         continue;
       }
 
+      std::string filtering_test_name =
+          launcher_delegate->GetTestNameForFiltering(test_case, test_info);
+
       // Skip the test that doesn't match the filter string (if given).
       if ((!positive_filter.empty() &&
-           !MatchesFilter(test_name, positive_filter)) ||
-          MatchesFilter(test_name, negative_filter)) {
+           !MatchesFilter(filtering_test_name, positive_filter)) ||
+          MatchesFilter(filtering_test_name, negative_filter)) {
         continue;
       }
 
       if (!launcher_delegate->ShouldRunTest(test_case, test_info))
         continue;
 
       bool should_run = ShouldRunTestOnShard(total_shards, shard_index,
                                              num_runnable_tests);
       num_runnable_tests++;
       if (!should_run)
@@ skipping 62 matching lines @@
 const char kGTestOutputFlag[] = "gtest_output";
 
 const char kHelpFlag[]   = "help";
 
 TestResult::TestResult() : status(TEST_UNKNOWN) {
 }
 
 TestLauncherDelegate::~TestLauncherDelegate() {
 }
 
+void PrintTestOutputSnippetOnFailure(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);
+}
+
 int LaunchChildGTestProcess(const CommandLine& command_line,
                             const std::string& wrapper,
                             base::TimeDelta timeout,
                             bool* was_timeout) {
   LaunchOptions options;
 
 #if defined(OS_POSIX)
   // On POSIX, we launch the test in a new process group with pgid equal to
   // its pid. Any child processes that the test may create will inherit the
   // same pgid. This way, if the test is abruptly terminated, we can clean up
@@ skipping 164 matching lines @@
            cycles,
            &exit_code,
            true));
 
   MessageLoop::current()->Run();
 
   return exit_code;
 }
 
 }  // namespace base