Support disabling unit test batching. Use it for angle_end2end_tests

base/test/launcher/unit_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/unit_test_launcher.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 140 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DefaultUnitTestPlatformDelegate);
 };
 
 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 (!StringToInt(switch_value, result) || *result < 1) {
+  if (!StringToInt(switch_value, result) || *result < 0) {
     LOG(ERROR) << "Invalid value for " << switch_name << ": " << switch_value;
     return false;
   }
 
   return true;
 }
 
 int LaunchUnitTestsInternal(const RunTestSuiteCallback& run_test_suite,
                             int default_jobs,
+                            int default_batch_limit,
                             bool use_job_objects,
                             const Closure& gtest_init) {
 #if defined(OS_ANDROID)
   // We can't easily fork on Android, just run the test suite directly.
   return run_test_suite.Run();
 #else
   bool force_single_process = false;
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kTestLauncherDebugLauncher)) {
     fprintf(stdout, "Forcing test launcher debugging mode.\n");
@@ skipping 22 matching lines @@
   if (CommandLine::ForCurrentProcess()->HasSwitch(kHelpFlag)) {
     PrintUsage();
     return 0;
   }
 
   base::TimeTicks start_time(base::TimeTicks::Now());
 
   gtest_init.Run();
   TestTimeouts::Initialize();
 
-  int batch_limit = kDefaultTestBatchLimit;
+  int batch_limit = default_batch_limit;
   if (!GetSwitchValueAsInt(switches::kTestLauncherBatchLimit, &batch_limit))
     return 1;
 
   fprintf(stdout,
           "IMPORTANT DEBUGGING NOTE: batches of tests are run inside their\n"
           "own process. For debugging a test inside a debugger, use the\n"
           "--gtest_filter=<your_test_name> flag along with\n"
           "--single-process-tests.\n");
   fflush(stdout);
 
@@ skipping 204 matching lines @@
                       callback_state.platform_delegate, test_names,
                       callback_state.launch_flags));
 }
 
 }  // namespace
 
 int LaunchUnitTests(int argc,
                     char** argv,
                     const RunTestSuiteCallback& run_test_suite) {
   CommandLine::Init(argc, argv);
-  return LaunchUnitTestsInternal(run_test_suite, SysInfo::NumberOfProcessors(),
-                                 true, Bind(&InitGoogleTestChar, &argc, argv));
+  return LaunchUnitTestsInternal(
+      run_test_suite,
+      SysInfo::NumberOfProcessors(),
+      kDefaultTestBatchLimit,
+      true,
+      Bind(&InitGoogleTestChar, &argc, argv));
 }
 
 int LaunchUnitTestsSerially(int argc,
                             char** argv,
                             const RunTestSuiteCallback& run_test_suite) {
   CommandLine::Init(argc, argv);
-  return LaunchUnitTestsInternal(run_test_suite, 1, true,
-                                 Bind(&InitGoogleTestChar, &argc, argv));
+  return LaunchUnitTestsInternal(
+      run_test_suite,
+      1,
+      kDefaultTestBatchLimit,
+      true,
+      Bind(&InitGoogleTestChar, &argc, argv));
+}
+
+int LaunchUnitTestsWithOptions(
+    int argc,
+    char** argv,
+    int default_jobs,
+    int default_batch_limit,
+    bool use_job_objects,
+    const RunTestSuiteCallback& run_test_suite) {
+  CommandLine::Init(argc, argv);
+  return LaunchUnitTestsInternal(
+      run_test_suite,
+      default_jobs,
+      default_batch_limit,
+      use_job_objects,
+      Bind(&InitGoogleTestChar, &argc, argv));
 }
 
 #if defined(OS_WIN)
 int LaunchUnitTests(int argc,
                     wchar_t** argv,
                     bool use_job_objects,
                     const RunTestSuiteCallback& run_test_suite) {
   // Windows CommandLine::Init ignores argv anyway.
   CommandLine::Init(argc, NULL);
-  return LaunchUnitTestsInternal(run_test_suite, SysInfo::NumberOfProcessors(),
-                                 use_job_objects,
-                                 Bind(&InitGoogleTestWChar, &argc, argv));
+  return LaunchUnitTestsInternal(
+      run_test_suite,
+      SysInfo::NumberOfProcessors(),
+      kDefaultTestBatchLimit,
+      use_job_objects,
+      Bind(&InitGoogleTestWChar, &argc, argv));
 }
 #endif  // defined(OS_WIN)
 
 void RunUnitTestsSerially(
     TestLauncher* test_launcher,
     UnitTestPlatformDelegate* platform_delegate,
     const std::vector<std::string>& test_names,
     int launch_flags) {
   if (test_names.empty())
     return;
@@ skipping 122 matching lines @@
     TestLauncher* test_launcher,
     const std::vector<std::string>& test_names) {
   ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       Bind(&RunUnitTestsSerially, test_launcher, platform_delegate_, test_names,
            use_job_objects_ ? TestLauncher::USE_JOB_OBJECTS : 0));
   return test_names.size();
 }
 
 }  // namespace base