GTTF: Flip test launcher defaults (developer mode is now default)

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"
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 #endif
 
@@ skipping 160 matching lines @@
 bool UnsetEnvironmentVariableIfExists(const std::string& name) {
   scoped_ptr<Environment> env(Environment::Create());
   std::string str_val;
 
   if (!env->GetVar(name.c_str(), &str_val))
     return true;
 
   return env->UnSetVar(name.c_str());
 }
 
+// Returns true if bot mode has been requested, i.e. defaults optimized
+// for continuous integration bots. This way developers don't have to remember
+// special command-line flags.
+bool BotModeEnabled() {
+  scoped_ptr<Environment> env(Environment::Create());
+  return CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kTestLauncherBotMode) ||
+      env->HasVar("CHROMIUM_TEST_LAUNCHER_BOT_MODE");
+}
+
 // For a basic pattern matching for gtest_filter options.  (Copied from
 // gtest.cc, see the comment below and http://crbug.com/44497)
 bool PatternMatchesString(const char* pattern, const char* str) {
   switch (*pattern) {
     case '\0':
     case ':':  // Either ':' or '\0' marks the end of the pattern.
       return *str == '\0';
     case '?':  // Matches any single character.
       return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
     case '*':  // Matches any string (possibly empty) of characters.
@@ skipping 33 matching lines @@
     int exit_code,
     const TimeDelta& elapsed_time,
     bool was_timeout,
     const std::string& output) {
   callback.Run(exit_code, elapsed_time, was_timeout, output);
 }
 
 void DoLaunchChildTestProcess(
     const CommandLine& command_line,
     base::TimeDelta timeout,
+    bool redirect_stdio,
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const TestLauncher::LaunchChildGTestProcessCallback& callback) {
   TimeTicks start_time = TimeTicks::Now();
 
   // Redirect child process output to a file.
   base::FilePath output_file;
   CHECK(file_util::CreateTemporaryFile(&output_file));
 
   LaunchOptions options;
 #if defined(OS_WIN)
   win::ScopedHandle handle;
 
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kTestLauncherDeveloperMode)) {
+  if (redirect_stdio) {
     // Make the file handle inheritable by the child.
     SECURITY_ATTRIBUTES sa_attr;
     sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
     sa_attr.lpSecurityDescriptor = NULL;
     sa_attr.bInheritHandle = TRUE;
 
     handle.Set(CreateFile(output_file.value().c_str(),
                           GENERIC_WRITE,
                           FILE_SHARE_READ | FILE_SHARE_DELETE,
                           &sa_attr,
                           OPEN_EXISTING,
                           FILE_ATTRIBUTE_TEMPORARY,
                           NULL));
     CHECK(handle.IsValid());
     options.inherit_handles = true;
     options.stdin_handle = INVALID_HANDLE_VALUE;
     options.stdout_handle = handle.Get();
     options.stderr_handle = handle.Get();
   }
 #elif defined(OS_POSIX)
   options.new_process_group = true;
 
   base::FileHandleMappingVector fds_mapping;
   file_util::ScopedFD output_file_fd_closer;
 
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kTestLauncherDeveloperMode)) {
+  if (redirect_stdio) {
     int output_file_fd = open(output_file.value().c_str(), O_RDWR);
     CHECK_GE(output_file_fd, 0);
 
     output_file_fd_closer.reset(&output_file_fd);
 
     fds_mapping.push_back(std::make_pair(output_file_fd, STDOUT_FILENO));
     fds_mapping.push_back(std::make_pair(output_file_fd, STDERR_FILENO));
     options.fds_to_remap = &fds_mapping;
   }
 #endif
 
   bool was_timeout = false;
   int exit_code = LaunchChildTestProcessWithOptions(
       command_line, options, timeout, &was_timeout);
 
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kTestLauncherDeveloperMode)) {
+  if (redirect_stdio) {
 #if defined(OS_WIN)
   FlushFileBuffers(handle.Get());
   handle.Close();
 #elif defined(OS_POSIX)
   output_file_fd_closer.reset();
 #endif
   }
 
   std::string output_file_contents;
   CHECK(base::ReadFileToString(output_file, &output_file_contents));
@@ skipping 31 matching lines @@
                            size_t parallel_jobs)
     : 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_(3),
+      retry_limit_(0),
       run_result_(true),
       watchdog_timer_(FROM_HERE,
                       TimeDelta::FromSeconds(kOutputTimeoutSeconds),
                       this,
-                      &TestLauncher::OnOutputTimeout) {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kTestLauncherDeveloperMode)) {
-    parallel_jobs = 1;
-    retry_limit_ = 0;
+                      &TestLauncher::OnOutputTimeout),
+      parallel_jobs_(parallel_jobs) {
+  if (BotModeEnabled()) {
     fprintf(stdout,
-            "Forcing serial test execution in developer mode.\n"
-            "Disabling test retries in developer mode.\n");
+            "Enabling defaults optimized for continuous integration bots.\n");
     fflush(stdout);
+
+    // Enable test retries by default for bots. This can be still overridden
+    // from command line using --test-launcher-retry-limit flag.
+    retry_limit_ = 3;
+  } else {
+    // Default to serial test execution if not running on a bot. This makes it
+    // possible to disable stdio redirection and can still be overridden with
+    // --test-launcher-jobs flag.
+    parallel_jobs_ = 1;
   }
-  worker_pool_owner_.reset(
-      new SequencedWorkerPoolOwner(parallel_jobs, "test_launcher"));
 }
 
 TestLauncher::~TestLauncher() {
-  worker_pool_owner_->pool()->Shutdown();
+  if (worker_pool_owner_)
+    worker_pool_owner_->pool()->Shutdown();
 }
 
 bool TestLauncher::Run(int argc, char** argv) {
   if (!Init())
     return false;
 
 #if defined(OS_POSIX)
   CHECK_EQ(0, pipe(g_shutdown_pipe));
 
   struct sigaction action;
@@ skipping 37 matching lines @@
     const CommandLine& command_line,
     const std::string& wrapper,
     base::TimeDelta timeout,
     const LaunchChildGTestProcessCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Record the exact command line used to launch the child.
   CommandLine new_command_line(
       PrepareCommandLineForGTest(command_line, wrapper));
 
+  // When running in parallel mode we need to redirect stdio to avoid mixed-up
+  // output. We also always redirect on the bots to get the test output into
+  // JSON summary.
+  bool redirect_stdio = (parallel_jobs_ > 1) || BotModeEnabled();
+
   worker_pool_owner_->pool()->PostWorkerTask(
       FROM_HERE,
       Bind(&DoLaunchChildTestProcess,
            new_command_line,
            timeout,
+           redirect_stdio,
            MessageLoopProxy::current(),
            Bind(&TestLauncher::OnLaunchTestProcessFinished,
                 Unretained(this),
                 callback)));
 }
 
 void TestLauncher::OnTestFinished(const TestResult& result) {
   ++test_finished_count_;
 
   bool print_snippet = false;
@@ skipping 210 matching lines @@
     if (!StringToInt(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
                          switches::kTestLauncherRetryLimit), &retry_limit) ||
         retry_limit < 0) {
       LOG(ERROR) << "Invalid value for " << switches::kTestLauncherRetryLimit;
       return false;
     }
 
     retry_limit_ = retry_limit;
   }
 
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kTestLauncherJobs)) {
+    int jobs = -1;
+    if (!StringToInt(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+                         switches::kTestLauncherJobs), &jobs) ||
+        jobs < 0) {
+      LOG(ERROR) << "Invalid value for " << switches::kTestLauncherJobs;
+      return false;
+    }
+
+    parallel_jobs_ = jobs;
+  }
+  fprintf(stdout, "Using %" PRIuS " parallel jobs.\n", parallel_jobs_);
+  fflush(stdout);
+  worker_pool_owner_.reset(
+      new SequencedWorkerPoolOwner(parallel_jobs_, "test_launcher"));
+
   // Split --gtest_filter at '-', if there is one, to separate into
   // positive filter and negative filter portions.
   std::string filter = command_line->GetSwitchValueASCII(kGTestFilterFlag);
   positive_test_filter_ = filter;
   size_t dash_pos = filter.find('-');
   if (dash_pos != std::string::npos) {
     // Everything up to the dash.
     positive_test_filter_ = filter.substr(0, dash_pos);
 
     // Everything after the dash.
@@ skipping 285 matching lines @@
 
     g_live_processes.Get().erase(process_handle);
   }
 
   base::CloseProcessHandle(process_handle);
 
   return exit_code;
 }
 
 }  // namespace base