Make retries in content (and above) test launcher really serial

content/public/test/test_launcher.cc

 // Copyright (c) 2012 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 "content/public/test/test_launcher.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 112 matching lines @@
   // base::TestLauncherDelegate:
   bool GetTests(std::vector<base::TestIdentifier>* output) override;
   bool ShouldRunTest(const std::string& test_case_name,
                      const std::string& test_name) override;
   size_t RunTests(base::TestLauncher* test_launcher,
                   const std::vector<std::string>& test_names) override;
   size_t RetryTests(base::TestLauncher* test_launcher,
                     const std::vector<std::string>& test_names) override;
 
  private:
-  void DoRunTest(base::TestLauncher* test_launcher,
-                 const std::string& test_name);
+  void DoRunTests(base::TestLauncher* test_launcher,
+                  const std::vector<std::string>& test_names);
 
   // Launches test named |test_name| using parallel launcher,
   // given result of PRE_ test |pre_test_result|.
   void RunDependentTest(base::TestLauncher* test_launcher,
                         const std::string test_name,
                         const base::TestResult& pre_test_result);
 
   // Callback to receive result of a test.
   void GTestCallback(
       base::TestLauncher* test_launcher,
+      const std::vector<std::string>& test_names,
       const std::string& test_name,
       int exit_code,
       const base::TimeDelta& elapsed_time,
       bool was_timeout,
       const std::string& output);
 
   content::TestLauncherDelegate* launcher_delegate_;
 
   // Store dependent test name (map is indexed by full test name).
   typedef std::map<std::string, std::string> DependentTestMap;
@@ skipping 92 matching lines @@
       base::FilePath temp_dir;
       CHECK(base::CreateTemporaryDirInDir(temp_dir_.path(),
                                           FILE_PATH_LITERAL("d"), &temp_dir));
       user_data_dir_map_[full_name] = temp_dir;
     }
 
     // If the test has any dependencies, get to the root and start with that.
     while (ContainsKey(reverse_dependent_test_map_, full_name))
       full_name = GetPreTestName(full_name);
 
-    DoRunTest(test_launcher, full_name);
+    std::vector<std::string> test_list;
+    test_list.push_back(full_name);
+    DoRunTests(test_launcher, test_list);
   }
 
   return test_names.size() + additional_tests_to_run_count;
 }
 
 size_t WrapperTestLauncherDelegate::RetryTests(
     base::TestLauncher* test_launcher,
     const std::vector<std::string>& test_names) {
   // List of tests we can kick off right now, depending on no other tests.
   std::vector<std::string> tests_to_run_now;
@@ skipping 41 matching lines @@
     size_t dot_pos = full_name.find('.');
     CHECK_NE(dot_pos, std::string::npos);
     std::string test_case_name = full_name.substr(0, dot_pos);
     std::string test_name = full_name.substr(dot_pos + 1);
     std::string pre_test_name(
         test_case_name + "." + kPreTestPrefix + test_name);
     if (!ContainsKey(test_names_set, pre_test_name))
       tests_to_run_now.push_back(full_name);
   }
 
-  for (size_t i = 0; i < tests_to_run_now.size(); i++)
-    DoRunTest(test_launcher, tests_to_run_now[i]);
+  DoRunTests(test_launcher, tests_to_run_now);
 
   return test_names_set.size();
 }
 
-void WrapperTestLauncherDelegate::DoRunTest(base::TestLauncher* test_launcher,
-                                            const std::string& test_name) {
+void WrapperTestLauncherDelegate::DoRunTests(
+    base::TestLauncher* test_launcher,
+    const std::vector<std::string>& test_names) {
+  if (test_names.empty())
+    return;
+
+  std::string test_name(test_names.front());
+  std::vector<std::string> test_names_copy(
+      test_names.begin() + 1, test_names.end());
+
   std::string test_name_no_pre(RemoveAnyPrePrefixes(test_name));
 
   base::CommandLine cmd_line(*base::CommandLine::ForCurrentProcess());
   CHECK(launcher_delegate_->AdjustChildProcessCommandLine(
             &cmd_line, user_data_dir_map_[test_name_no_pre]));
 
   base::CommandLine new_cmd_line(cmd_line.GetProgram());
   base::CommandLine::SwitchMap switches = cmd_line.GetSwitches();
 
   // Strip out gtest_output flag because otherwise we would overwrite results
@@ skipping 15 matching lines @@
 
   test_launcher->LaunchChildGTestProcess(
       new_cmd_line,
       browser_wrapper ? browser_wrapper : std::string(),
       TestTimeouts::action_max_timeout(),
       base::TestLauncher::USE_JOB_OBJECTS |
           base::TestLauncher::ALLOW_BREAKAWAY_FROM_JOB,
       base::Bind(&WrapperTestLauncherDelegate::GTestCallback,
                  base::Unretained(this),
                  test_launcher,
+                 test_names_copy,
                  test_name));
 }
 
 void WrapperTestLauncherDelegate::RunDependentTest(
     base::TestLauncher* test_launcher,
     const std::string test_name,
     const base::TestResult& pre_test_result) {
   if (pre_test_result.status == base::TestResult::TEST_SUCCESS) {
     // Only run the dependent test if PRE_ test succeeded.
-    DoRunTest(test_launcher, test_name);
+    std::vector<std::string> test_list;
+    test_list.push_back(test_name);
+    DoRunTests(test_launcher, test_list);
   } else {
     // Otherwise skip the test.
     base::TestResult test_result;
     test_result.full_name = test_name;
     test_result.status = base::TestResult::TEST_SKIPPED;
     test_launcher->OnTestFinished(test_result);
 
     if (ContainsKey(dependent_test_map_, test_name)) {
       RunDependentTest(test_launcher,
                        dependent_test_map_[test_name],
                        test_result);
     }
   }
 }
 
 void WrapperTestLauncherDelegate::GTestCallback(
     base::TestLauncher* test_launcher,
+    const std::vector<std::string>& test_names,
     const std::string& test_name,
     int exit_code,
     const base::TimeDelta& elapsed_time,
     bool was_timeout,
     const std::string& output) {
   base::TestResult result;
   result.full_name = test_name;
 
   // TODO(phajdan.jr): Recognize crashes.
   if (exit_code == 0)
@@ skipping 16 matching lines @@
     if (ContainsKey(user_data_dir_map_, test_name_no_pre)) {
       if (!base::DeleteFile(user_data_dir_map_[test_name_no_pre], true)) {
         LOG(WARNING) << "Failed to delete "
                      << user_data_dir_map_[test_name_no_pre].value();
       }
       user_data_dir_map_.erase(test_name_no_pre);
     }
   }
 
   test_launcher->OnTestFinished(result);
+
+  DoRunTests(test_launcher, test_names);
 }
 
 }  // namespace
 
 const char kHelpFlag[]   = "help";
 
 const char kLaunchAsBrowser[] = "as-browser";
 
 // See kManualTestPrefix above.
 const char kRunManualTestsFlag[] = "run-manual";
@@ skipping 75 matching lines @@
 
 TestLauncherDelegate* GetCurrentTestLauncherDelegate() {
   return g_launcher_delegate;
 }
 
 ContentMainParams* GetContentMainParams() {
   return g_params;
 }
 
 }  // namespace content