Allow writing browser_tests that involve a restart. The way to do this:

content/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 <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 281 matching lines @@
 
   // Make it possible for selected tests to request a longer timeout.
   // Generally tests should really avoid doing too much, and splitting
   // a test instead of using SLOW prefix is strongly preferred.
   if (test_name.find("SLOW_") != std::string::npos)
     timeout *= kSlowTestTimeoutMultiplier;
 
   return timeout;
 }
 
-// Runs test specified by |test_name| in a child process,
-// and returns the exit code.
-int RunTest(TestLauncherDelegate* launcher_delegate,
-            const std::string& test_name,
-            base::TimeDelta default_timeout,
-            bool* was_timeout) {
-  if (was_timeout)
-    *was_timeout = false;
+int RunTestInternal(const testing::TestCase* test_case,
+                    const std::string& test_name,
+                    CommandLine* command_line,
+                    base::TimeDelta default_timeout,
+                    bool* was_timeout) {
+  std::string pre_test_name = test_name;

[sky, 2012/08/02 15:21:55]

move 307/308 inside if (test_case)

[jam, 2012/08/05 21:44:02]

Done.

+  ReplaceFirstSubstringAfterOffset(&pre_test_name, 0, ".", ".PRE_");
 
-#if defined(OS_MACOSX)
-  // Some of the below method calls will leak objects if there is no
-  // autorelease pool in place.
-  base::mac::ScopedNSAutoreleasePool pool;
-#endif
+  if (test_case) {
+    for (int i = 0; i < test_case->total_test_count(); ++i) {
+      const testing::TestInfo* test_info = test_case->GetTestInfo(i);
+      std::string test_name = test_info->test_case_name();

[sky, 2012/08/02 15:21:55]

nit: use a different name here so you aren't shadowing the test_name parameter.

+      test_name.append(".");
+      test_name.append(test_info->name());
+      if (test_name == pre_test_name) {
+        int exit_code = RunTestInternal(test_case, pre_test_name, command_line,
+                                        default_timeout, was_timeout);
+        if (exit_code != 0)
+          return exit_code;
+      }
+    }
+  }
 
-  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
-  CommandLine new_cmd_line(cmd_line->GetProgram());
-  CommandLine::SwitchMap switches = cmd_line->GetSwitches();
-
-  // Strip out gtest_output flag because otherwise we would overwrite results
-  // of the previous test. We will generate the final output file later
-  // in RunTests().
-  switches.erase(kGTestOutputFlag);
-
-  // Strip out gtest_repeat flag because we can only run one test in the child
-  // process (restarting the browser in the same process is illegal after it
-  // has been shut down and will actually crash).
-  switches.erase(kGTestRepeatFlag);
-
-  for (CommandLine::SwitchMap::const_iterator iter = switches.begin();
-       iter != switches.end(); ++iter) {
-    new_cmd_line.AppendSwitchNative((*iter).first, (*iter).second);
-  }
+  CommandLine new_cmd_line(*command_line);
 
   // 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);
 
-  // Do not let the child ignore failures.  We need to propagate the
-  // failure status back to the parent.
-  new_cmd_line.AppendSwitch(base::TestSuite::kStrictFailureHandling);
-
-  if (!launcher_delegate->AdjustChildProcessCommandLine(&new_cmd_line))
-    return -1;
-
   const char* browser_wrapper = getenv("BROWSER_WRAPPER");
   if (browser_wrapper) {
 #if defined(OS_WIN)
     new_cmd_line.PrependWrapper(ASCIIToWide(browser_wrapper));
 #elif defined(OS_POSIX)
     new_cmd_line.PrependWrapper(browser_wrapper);
 #endif
     VLOG(1) << "BROWSER_WRAPPER was set, prefixing command_line with "
             << browser_wrapper;
   }
@@ skipping 36 matching lines @@
     // cleaned up using JobObjects.
     base::KillProcessGroup(process_handle);
   }
 #endif
 
   base::CloseProcessHandle(process_handle);
 
   return exit_code;
 }
 
+// Runs test specified by |test_name| in a child process,
+// and returns the exit code.
+int RunTest(TestLauncherDelegate* launcher_delegate,
+            const testing::TestCase* test_case,
+            const std::string& test_name,
+            base::TimeDelta default_timeout,
+            bool* was_timeout) {
+  if (was_timeout)
+    *was_timeout = false;
+
+#if defined(OS_MACOSX)
+  // Some of the below method calls will leak objects if there is no
+  // autorelease pool in place.
+  base::mac::ScopedNSAutoreleasePool pool;
+#endif
+
+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+  CommandLine new_cmd_line(cmd_line->GetProgram());
+  CommandLine::SwitchMap switches = cmd_line->GetSwitches();
+
+  // Strip out gtest_output flag because otherwise we would overwrite results
+  // of the previous test. We will generate the final output file later
+  // in RunTests().
+  switches.erase(kGTestOutputFlag);
+
+  // Strip out gtest_repeat flag because we can only run one test in the child
+  // process (restarting the browser in the same process is illegal after it
+  // has been shut down and will actually crash).
+  switches.erase(kGTestRepeatFlag);
+
+  for (CommandLine::SwitchMap::const_iterator iter = switches.begin();
+       iter != switches.end(); ++iter) {
+    new_cmd_line.AppendSwitchNative((*iter).first, (*iter).second);
+  }
+
+  // Do not let the child ignore failures.  We need to propagate the
+  // failure status back to the parent.
+  new_cmd_line.AppendSwitch(base::TestSuite::kStrictFailureHandling);
+
+  if (!launcher_delegate->AdjustChildProcessCommandLine(&new_cmd_line))
+    return -1;
+
+  return RunTestInternal(
+      test_case, test_name, &new_cmd_line, default_timeout, was_timeout);
+}
+
 bool RunTests(TestLauncherDelegate* launcher_delegate,
               bool should_shard,
               int total_shards,
               int shard_index) {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   DCHECK(!command_line->HasSwitch(kGTestListTestsFlag));
 
   testing::UnitTest* const unit_test = testing::UnitTest::GetInstance();
 
@@ skipping 32 matching lines @@
         continue;
 
       // Skip disabled tests.
       if (test_name.find("DISABLED") != std::string::npos &&
           !command_line->HasSwitch(kGTestRunDisabledTestsFlag)) {
         printer.OnTestEnd(test_info->name(), test_case->name(),
                           false, false, false, 0);
         continue;
       }
 
+      if (StartsWithASCII(test_info->name(), "PRE_", true))
+        continue;
+
       // Skip the test that doesn't match the filter string (if given).
       if ((!positive_filter.empty() &&
            !MatchesFilter(test_name, positive_filter)) ||
           MatchesFilter(test_name, negative_filter)) {
         printer.OnTestEnd(test_info->name(), test_case->name(),
                           false, false, false, 0);
         continue;
       }
 
       // Decide if this test should be run.
       bool should_run = true;
       if (should_shard) {
         should_run = ShouldRunTestOnShard(total_shards, shard_index,
                                           num_runnable_tests);
       }
       num_runnable_tests += 1;
       // If sharding is enabled and the test should not be run, skip it.
       if (!should_run) {
         continue;
       }
 
       base::Time start_time = base::Time::Now();
       ++test_run_count;
       bool was_timeout = false;
       int exit_code = RunTest(launcher_delegate,
+                              test_case,
                               test_name,
                               TestTimeouts::action_max_timeout(),
                               &was_timeout);
       if (exit_code == 0) {
         // Test passed.
         printer.OnTestEnd(test_info->name(), test_case->name(), true, false,
                           false,
                           (base::Time::Now() - start_time).InMillisecondsF());
       } else {
         failed_tests.push_back(test_name);
@@ skipping 142 matching lines @@
     // from disk may be slow on a busy bot, and can easily exceed the default
     // timeout causing flaky test failures. Use an empty test that only starts
     // and closes a browser with a long timeout to avoid those problems.
     // NOTE: We don't do this when specifying a filter because this slows down
     // the common case of running one test locally, and also on trybots when
     // sharding as this one test runs ~200 times and wastes a few minutes.
     bool warmup = command_line->HasSwitch(kWarmupFlag);
     bool has_filter = command_line->HasSwitch(kGTestFilterFlag);
     if (warmup || (!should_shard && !has_filter)) {
       exit_code = RunTest(launcher_delegate,
+                          NULL,
                           empty_test,
                           TestTimeouts::large_test_timeout(),
                           NULL);
       if (exit_code != 0 || warmup)
         return exit_code;
     }
   }
 
   int cycles = 1;
   if (command_line->HasSwitch(kGTestRepeatFlag)) {
@@ skipping 15 matching lines @@
       cycles--;
   }
   return exit_code;
 }
 
 TestLauncherDelegate* GetCurrentTestLauncherDelegate() {
   return g_launcher_delegate;
 }
 
 }  // namespace test_launcher