Add (not yet working) content_browsertests target.

content/test/out_of_proc_test_runner.cc

 // Copyright (c) 2011 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 <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process_util.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/test/test_suite.h"
 #include "base/test/test_timeouts.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/common/chrome_switches.h"
-#include "chrome/test/base/chrome_test_suite.h"
-#include "chrome/test/base/in_process_browser_test.h"
-#include "chrome/test/base/test_launcher_utils.h"
+#include "content/test/browser_test.h"

[sky, 2011/09/27 15:31:52]

Are these classes landing separately?

+#include "content/test/browser_test_suite.h"
 #include "net/base/escape.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include "base/base_switches.h"
-#include "chrome/common/chrome_constants.h"
 #include "content/common/sandbox_policy.h"
 #include "sandbox/src/dep.h"
 #include "sandbox/src/sandbox_factory.h"
 #include "sandbox/src/sandbox_types.h"
 #endif  // defined(OS_WIN)
 
+#if defined(BROWSER_TESTS_USE_CHROME)
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/chrome_constants.h"
+
 #if defined(OS_MACOSX)
 #include "chrome/browser/chrome_browser_application_mac.h"
 #endif  // defined(OS_MACOSX)
 
+#endif  // defined(BROWSER_TESTS_USE_CHROME)
+
 #if defined(OS_WIN)
 // The entry point signature of chrome.dll.
 typedef int (*DLL_MAIN)(HINSTANCE, sandbox::SandboxInterfaceInfo*, wchar_t*);
 #endif  // defined(OS_WIN)
 
 namespace {
 
 const char kGTestFilterFlag[] = "gtest_filter";
 const char kGTestHelpFlag[]   = "gtest_help";
 const char kGTestListTestsFlag[] = "gtest_list_tests";
@@ skipping 242 matching lines @@
     // Returns if no more pattern can be found.
     if (cur_pattern == NULL) {
       return false;
     }
 
     // Skips the pattern separater (the ':' character).
     cur_pattern++;
   }
 }
 
+namespace {
+
+// A multiplier for slow tests. We generally avoid multiplying
+// test timeouts by any constants. Here it is used as last resort
+// to implement the SLOW_ test prefix.
+static const int kSlowTestTimeoutMultiplier = 5;
+
+}  // namespace
+
+int GetTestTerminationTimeout(const std::string& test_name,
+                              int default_timeout_ms) {
+  int timeout_ms = default_timeout_ms;
+
+  // 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_ms *= kSlowTestTimeoutMultiplier;
+
+  return timeout_ms;
+}
+
 // Runs test specified by |test_name| in a child process,
 // and returns the exit code.
 int RunTest(const std::string& test_name, int default_timeout_ms) {
   // Some of the below method calls will leak objects if there is no
   // autorelease pool in place.
   base::mac::ScopedNSAutoreleasePool pool;
 
   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);
 
+#if defined(BROWSER_TESTS_USE_CHROME)
   // Strip out user-data-dir if present.  We will add it back in again later.
   switches.erase(switches::kUserDataDir);
+#endif  // defined(BROWSER_TESTS_USE_CHROME)
 
   for (CommandLine::SwitchMap::const_iterator iter = switches.begin();
        iter != switches.end(); ++iter) {
     new_cmd_line.AppendSwitchNative((*iter).first, (*iter).second);
   }
 
   // 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(kChildProcessFlag);
 
   // 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 defined(BROWSER_TESTS_USE_CHROME)
   // Create a new user data dir and pass it to the child.
   ScopedTempDir temp_dir;
   if (!temp_dir.CreateUniqueTempDir() || !temp_dir.IsValid()) {
     LOG(ERROR) << "Error creating temp profile directory";
     return false;
   }
   new_cmd_line.AppendSwitchPath(switches::kUserDataDir, temp_dir.path());
 
   // file:// access for ChromeOS.
   new_cmd_line.AppendSwitch(switches::kAllowFileAccess);
+#endif  // defined(BROWSER_TESTS_USE_CHROME)
 
   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;
   }
 
   base::ProcessHandle process_handle;
   base::LaunchOptions options;
 
 #if defined(OS_POSIX)
   // On POSIX, we launch the test in a new process group with pgid equal to
   // its pid. Any child processes that the test may create will inherit the
   // same pgid. This way, if the test is abruptly terminated, we can clean up
   // any orphaned child processes it may have left behind.
   options.new_process_group = true;
 #endif
 
   if (!base::LaunchProcess(new_cmd_line, options, &process_handle))
     return false;
 
-  int timeout_ms =
-      test_launcher_utils::GetTestTerminationTimeout(test_name,
-                                                     default_timeout_ms);
+  int timeout_ms = GetTestTerminationTimeout(test_name,
+                                             default_timeout_ms);
 
   int exit_code = 0;
   if (!base::WaitForExitCodeWithTimeout(process_handle, &exit_code,
                                         timeout_ms)) {
     LOG(ERROR) << "Test timeout (" << timeout_ms
                << " ms) exceeded for " << test_name;
 
     exit_code = -1;  // Set a non-zero exit code to signal a failure.
 
     // Ensure that the process terminates.
@@ skipping 175 matching lines @@
       if (broker_services) {
         sandbox::InitBrokerServices(broker_services);
         // Precreate the desktop and window station used by the renderers.
         sandbox::TargetPolicy* policy = broker_services->CreatePolicy();
         sandbox::ResultCode result = policy->CreateAlternateDesktop(true);
         CHECK(sandbox::SBOX_ERROR_FAILED_TO_SWITCH_BACK_WINSTATION != result);
         policy->Release();
       }
     }
 #endif
-    return ChromeTestSuite(argc, argv).Run();
+    return BrowserTestSuite(argc, argv).Run();
   }
 
-#if defined(OS_WIN)
+#if defined(OS_WIN) && defined(BROWSER_TESTS_USE_CHROME)
   if (command_line->HasSwitch(switches::kProcessType)) {
     // This is a child process, call ChromeMain.
     FilePath chrome_path(command_line->GetProgram().DirName());
     chrome_path = chrome_path.Append(chrome::kBrowserResourcesDll);
     HMODULE dll = LoadLibrary(chrome_path.value().c_str());
     DLL_MAIN entry_point =
         reinterpret_cast<DLL_MAIN>(::GetProcAddress(dll, "ChromeMain"));
     if (!entry_point)
       return -1;
 
     // Initialize the sandbox services.
     sandbox::SandboxInterfaceInfo sandbox_info = {0};
     sandbox_info.target_services = sandbox::SandboxFactory::GetTargetServices();
     return entry_point(GetModuleHandle(NULL), &sandbox_info, GetCommandLineW());
   }
-#endif
+#endif  // defined(OS_WIN) && defined(BROWSER_TESTS_USE_CHROME)
 
   int32 total_shards;
   int32 shard_index;
   bool should_shard = ShouldShard(&total_shards, &shard_index);
 
   fprintf(stdout,
       "Starting tests...\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"
@@ skipping 22 matching lines @@
       exit_code = 1;
       break;
     }
 
     // Special value "-1" means "repeat indefinitely".
     if (cycles != -1)
       cycles--;
   }
   return exit_code;
 }