Update to Chromium //base at Chromium commit 3e81715e6d3a4324362635aea46ce1f1a163cca1.

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"
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 #endif
 
@@ skipping 438 matching lines @@
     : launcher_delegate_(launcher_delegate),
       total_shards_(1),
       shard_index_(0),
       cycles_(1),
       test_started_count_(0),
       test_finished_count_(0),
       test_success_count_(0),
       test_broken_count_(0),
       retry_count_(0),
       retry_limit_(0),
+      force_run_broken_tests_(false),
       run_result_(true),
       watchdog_timer_(FROM_HERE,
                       TimeDelta::FromSeconds(kOutputTimeoutSeconds),
                       this,
                       &TestLauncher::OnOutputTimeout),
-      parallel_jobs_(parallel_jobs) {
-}
+      parallel_jobs_(parallel_jobs) {}
 
 TestLauncher::~TestLauncher() {
   if (worker_pool_owner_)
     worker_pool_owner_->pool()->Shutdown();
 }
 
 bool TestLauncher::Run() {
   if (!Init())
     return false;
 
@@ skipping 136 matching lines @@
 
   // Do not waste time on timeouts. We include tests with unknown results here
   // because sometimes (e.g. hang in between unit tests) that's how a timeout
   // gets reported.
   if (result.status == TestResult::TEST_TIMEOUT ||
       result.status == TestResult::TEST_UNKNOWN) {
     test_broken_count_++;
   }
   size_t broken_threshold =
       std::max(static_cast<size_t>(20), test_started_count_ / 10);
-  if (test_broken_count_ >= broken_threshold) {
+  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();
 
     exit(1);
   }
 
   if (test_finished_count_ != test_started_count_)
     return;
 
   if (tests_to_retry_.empty() || retry_count_ >= retry_limit_) {
     OnTestIterationFinished();
     return;
   }
 
-  if (tests_to_retry_.size() >= broken_threshold) {
+  if (!force_run_broken_tests_ && tests_to_retry_.size() >= broken_threshold) {
     fprintf(stdout,
             "Too many failing tests (%" PRIuS "), skipping retries.\n",
             tests_to_retry_.size());
     fflush(stdout);
 
     results_tracker_.AddGlobalTag("BROKEN_TEST_SKIPPED_RETRIES");
     results_tracker_.AddGlobalTag(kUnreliableResultsTag);
 
     OnTestIterationFinished();
     return;
@@ skipping 91 matching lines @@
       return false;
     }
 
     retry_limit_ = retry_limit;
   } else if (!command_line->HasSwitch(kGTestFilterFlag) || BotModeEnabled()) {
     // Retry failures 3 times by default if we are running all of the tests or
     // in bot mode.
     retry_limit_ = 3;
   }
 
+  if (command_line->HasSwitch(switches::kTestLauncherForceRunBrokenTests))
+    force_run_broken_tests_ = true;
+
   if (command_line->HasSwitch(switches::kTestLauncherJobs)) {
     int jobs = -1;
     if (!StringToInt(command_line->GetSwitchValueASCII(
                          switches::kTestLauncherJobs), &jobs) ||
         jobs < 0) {
       LOG(ERROR) << "Invalid value for " << switches::kTestLauncherJobs;
       return false;
     }
 
     parallel_jobs_ = jobs;
@@ skipping 311 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