Save an early test summary in case the test launcher crashes or gets killed

base/test/launcher/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/test_launcher.h"
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 518 matching lines @@
   watchdog_timer_.Reset();
 
   ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&TestLauncher::RunTestIteration, Unretained(this)));
 
   RunLoop().Run();
 
   if (requested_cycles != 1)
     results_tracker_.PrintSummaryOfAllIterations();
 
-  MaybeSaveSummaryAsJSON();
+  MaybeSaveSummaryAsJSON(std::vector<std::string>());
 
   return run_result_;
 }
 
 void TestLauncher::LaunchChildGTestProcess(
     const CommandLine& command_line,
     const std::string& wrapper,
     TimeDelta timeout,
     const LaunchOptions& options,
     const GTestProcessCompletedCallback& completed_callback,
@@ skipping 99 matching lines @@
       std::max(static_cast<size_t>(20), test_found_count_ / 10);
   if (!force_run_broken_tests_ && test_broken_count_ >= broken_threshold) {
     fprintf(stdout, "Too many badly broken tests (%" PRIuS "), exiting now.\n",
             test_broken_count_);
     fflush(stdout);
 
 #if defined(OS_POSIX)
     KillSpawnedTestProcesses();
 #endif  // defined(OS_POSIX)
 
-    results_tracker_.AddGlobalTag("BROKEN_TEST_EARLY_EXIT");
-    results_tracker_.AddGlobalTag(kUnreliableResultsTag);
-    MaybeSaveSummaryAsJSON();
+    MaybeSaveSummaryAsJSON({"BROKEN_TEST_EARLY_EXIT", kUnreliableResultsTag});
 
     exit(1);
   }
 
   if (test_finished_count_ != test_started_count_)
     return;
 
   if (tests_to_retry_.empty() || retry_count_ >= retry_limit_) {
     OnTestIterationFinished();
     return;
@@ skipping 310 matching lines @@
     }
     if (excluded)
       continue;
 
     if (Hash(test_name) % total_shards_ != static_cast<uint32_t>(shard_index_))
       continue;
 
     test_names.push_back(test_name);
   }
 
+  // Save an early test summary in case the launcher crashes or gets killed.
+  MaybeSaveSummaryAsJSON({"EARLY_SUMMARY", kUnreliableResultsTag});
+
   test_started_count_ = launcher_delegate_->RunTests(this, test_names);
 
   if (test_started_count_ == 0) {
     fprintf(stdout, "0 tests run\n");
     fflush(stdout);
 
     // No tests have actually been started, so kick off the next iteration.
     ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, Bind(&TestLauncher::RunTestIteration, Unretained(this)));
   }
@@ skipping 17 matching lines @@
   test_success_count_ = 0;
   test_broken_count_ = 0;
   retry_count_ = 0;
   tests_to_retry_.clear();
   results_tracker_.OnTestIterationStarting();
 
   ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&TestLauncher::RunTests, Unretained(this)));
 }
 
-void TestLauncher::MaybeSaveSummaryAsJSON() {
+void TestLauncher::MaybeSaveSummaryAsJSON(
+    const std::vector<std::string>& additional_tags) {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kTestLauncherSummaryOutput)) {
     FilePath summary_path(command_line->GetSwitchValuePath(
                               switches::kTestLauncherSummaryOutput));
-    if (!results_tracker_.SaveSummaryAsJSON(summary_path)) {
+    if (!results_tracker_.SaveSummaryAsJSON(summary_path, additional_tags)) {
       LOG(ERROR) << "Failed to save test launcher output summary.";
     }
   }
   if (command_line->HasSwitch(switches::kTestLauncherTrace)) {
     FilePath trace_path(
         command_line->GetSwitchValuePath(switches::kTestLauncherTrace));
     if (!g_tracer.Get().Dump(trace_path)) {
       LOG(ERROR) << "Failed to save test launcher trace.";
     }
   }
@@ skipping 95 matching lines @@
   }
 
   std::string snippet(full_output.substr(run_pos));
   if (end_pos != std::string::npos)
     snippet = full_output.substr(run_pos, end_pos - run_pos);
 
   return snippet;
 }
 
 }  // namespace base