GTTF: Unify parallel test launching.

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 <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/test/launcher/parallel_test_launcher.h"
 #include "base/test/launcher/test_launcher.h"
 #include "base/test/test_suite.h"
 #include "base/test/test_switches.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
 #include "content/public/app/content_main.h"
 #include "content/public/app/content_main_delegate.h"
 #include "content/public/app/startup_helper_win.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/sandbox_init.h"
@@ skipping 45 matching lines @@
       "  --help\n"
       "    Shows this message.\n"
       "  --gtest_help\n"
       "    Shows the gtest help message.\n");
 }
 
 // Implementation of base::TestLauncherDelegate. This is also a test launcher,
 // wrapping a lower-level test launcher with content-specific code.
 class WrapperTestLauncherDelegate : public base::TestLauncherDelegate {
  public:
-  WrapperTestLauncherDelegate(content::TestLauncherDelegate* launcher_delegate,
-                              size_t jobs)
-      : launcher_delegate_(launcher_delegate),
-        parallel_launcher_(jobs) {
+  explicit WrapperTestLauncherDelegate(
+      content::TestLauncherDelegate* launcher_delegate)
+      : launcher_delegate_(launcher_delegate) {
     CHECK(temp_dir_.CreateUniqueTempDir());
   }
 
   // base::TestLauncherDelegate:
   virtual void OnTestIterationStarting() OVERRIDE;
   virtual std::string GetTestNameForFiltering(
       const testing::TestCase* test_case,
       const testing::TestInfo* test_info) OVERRIDE;
   virtual bool ShouldRunTest(const testing::TestCase* test_case,
                              const testing::TestInfo* test_info) OVERRIDE;
@@ skipping 17 matching lines @@
   void GTestCallback(
       base::TestLauncher* test_launcher,
       const std::string& test_name,
       int exit_code,
       const base::TimeDelta& elapsed_time,
       bool was_timeout,
       const std::string& output);
 
   content::TestLauncherDelegate* launcher_delegate_;
 
-  base::ParallelTestLauncher parallel_launcher_;
-
   // Store dependent test name (map is indexed by full test name).
   typedef std::map<std::string, std::string> DependentTestMap;
   DependentTestMap dependent_test_map_;
   DependentTestMap reverse_dependent_test_map_;
 
   // Store unique data directory prefix for test names (without PRE_ prefixes).
   // PRE_ tests and tests that depend on them must share the same
   // data directory. Using test name as directory name leads to too long
   // names (exceeding UNIX_PATH_MAX, which creates a problem with
   // process_singleton_linux). Create a randomly-named temporary directory
@@ skipping 181 matching lines @@
   }
 
   // Always enable disabled tests.  This method is not called with disabled
   // tests unless this flag was specified to the browser test executable.
   new_cmd_line.AppendSwitch("gtest_also_run_disabled_tests");
   new_cmd_line.AppendSwitchASCII("gtest_filter", test_name);
   new_cmd_line.AppendSwitch(kSingleProcessTestsFlag);
 
   char* browser_wrapper = getenv("BROWSER_WRAPPER");
 
-  parallel_launcher_.LaunchChildGTestProcess(
+  test_launcher->LaunchChildGTestProcess(
       new_cmd_line,
       browser_wrapper ? browser_wrapper : std::string(),
       TestTimeouts::action_max_timeout(),
       base::Bind(&WrapperTestLauncherDelegate::GTestCallback,
                  base::Unretained(this),
                  test_launcher,
                  test_name));
 }
 
 void WrapperTestLauncherDelegate::RunDependentTest(
@@ skipping 49 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);
-  parallel_launcher_.ResetOutputWatchdog();
 }
 
 bool GetSwitchValueAsInt(const std::string& switch_name, int* result) {
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switch_name))
     return true;
 
   std::string switch_value =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switch_name);
   if (!base::StringToInt(switch_value, result) || *result < 1) {
     LOG(ERROR) << "Invalid value for " << switch_name << ": " << switch_value;
@@ skipping 93 matching lines @@
       "Starting tests (using %d parallel jobs)...\n"
       "IMPORTANT DEBUGGING NOTE: each test is run inside its own process.\n"
       "For debugging a test inside a debugger, use the\n"
       "--gtest_filter=<your_test_name> flag along with either\n"
       "--single_process (to run the test in one launcher/browser process) or\n"
       "--single-process (to do the above, and also run Chrome in single-"
           "process mode).\n", jobs);
 
   base::MessageLoopForIO message_loop;
 
-  WrapperTestLauncherDelegate delegate(launcher_delegate, jobs);
-  base::TestLauncher launcher(&delegate);
+  WrapperTestLauncherDelegate delegate(launcher_delegate);
+  base::TestLauncher launcher(&delegate, jobs);
   bool success = launcher.Run(argc, argv);
   return (success ? 0 : 1);
 }
 
 TestLauncherDelegate* GetCurrentTestLauncherDelegate() {
   return g_launcher_delegate;
 }
 
 }  // namespace content