Support automatic javascript test registry in gtest when creating WebUI tests.

chrome/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 "chrome/test/out_of_proc_test_runner.h"
+
 #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"
@@ skipping 516 matching lines @@
       "    Specifies a timeout (in milliseconds) after which a running test\n"
       "    will be forcefully terminated.\n"
       "  --help\n"
       "    Shows this message.\n"
       "  --gtest_help\n"
       "    Shows the gtest help message.\n");
 }
 
 }  // namespace
 
+namespace test {
+
+// Note that we cannot use the Singleton or LazyInstance here because the
+// registration happens at linker-initialization, and we cannot rely on
+// AtExitManager being available yet.  The life cycle of
+// |s_test_callback_registry| is from linker init through main (below) calling
+// CallTestCallbacksAndClear.
+typedef std::vector<RegisterTestCallback*> CallbackRegistry;
+CallbackRegistry* s_callback_registry = NULL;
+
+RegisterTestCallback::RegisterTestCallback() {}
+
+RegisterTestCallback::~RegisterTestCallback() {}
+
+void AddRegisterTestCallback(RegisterTestCallback* callback) {
+  if (!s_callback_registry)
+    s_callback_registry = new CallbackRegistry();
+
+  s_callback_registry->push_back(callback);
+}
+
+void CallRegisterTestCallbacksAndClear() {
+  // |s_callback_registry| will only be non-NULL if tests are registered.
+  if (!s_callback_registry)
+    return;
+
+  for (CallbackRegistry::const_iterator it = s_callback_registry->begin();
+      it != s_callback_registry->end(); ++it) {
+    (*it)->RegisterTest();
+    delete *it;
+  }
+  s_callback_registry->clear();
+  delete s_callback_registry;
+  s_callback_registry = NULL;
+}
+
+}  // namespace test
+
 int main(int argc, char** argv) {
 #if defined(OS_MACOSX)
   chrome_browser_application_mac::RegisterBrowserCrApp();
 #endif
 
   CommandLine::Init(argc, argv);
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   if (command_line->HasSwitch(kHelpFlag)) {
     PrintUsage();
     return 0;
   }
 
+  // The exit manager is in charge of calling the dtors of singleton objects.
+  // On Windows, the call to ChromeMain() below will construct one for the
+  // chrome.dll module, but that global is not shared with this module, so if
+  // chrome.dll calls back out to this module and the called code uses a
+  // singleton, we'll need this.  On other platforms, ChromeMain() isn't called
+  // at all below, so we instantiate a TestSuite which contains an exit manager
+  // for any code after this point. Any callbacks for test registry are called
+  // afterwards in case they also need an exit manager.
+  ChromeTestSuite test_suite(argc, argv);
+  test::CallRegisterTestCallbacksAndClear();
+
   // TODO(pkasting): This "single_process vs. single-process" design is terrible
   // UI.  Instead, there should be some sort of signal flag on the command line,
   // with all subsequent arguments passed through to the underlying browser.
   if (command_line->HasSwitch(kChildProcessFlag) ||
       command_line->HasSwitch(kSingleProcessTestsFlag) ||
       command_line->HasSwitch(kSingleProcessTestsAndChromeFlag) ||
       command_line->HasSwitch(kGTestListTestsFlag) ||
       command_line->HasSwitch(kGTestHelpFlag)) {
 
 #if defined(OS_WIN)
     if (command_line->HasSwitch(kChildProcessFlag) ||
         command_line->HasSwitch(kSingleProcessTestsFlag)) {
       // This is the browser process, so setup the sandbox broker.
       sandbox::BrokerServices* broker_services =
           sandbox::SandboxFactory::GetBrokerServices();
       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 test_suite.Run();
   }
 
-  // The exit manager is in charge of calling the dtors of singleton objects.
-  // On Windows, the call to ChromeMain() below will construct one for the
-  // chrome.dll module, but that global is not shared with this module, so if
-  // chrome.dll calls back out to this module and the called code uses a
-  // singleton, we'll need this.  On other platforms, ChromeMain() isn't called
-  // at all below, so this is the lone exit manager for any code after this
-  // point.
-  // NOTE: We can't init this atop main() because ChromeTestSuite, as a subclass
-  // of TestSuite, creates one.  So we wait until after the Run() call above to
-  // create the manager for the code path that _doesn't_ use ChromeTestSuite.
-  base::AtExitManager exit_manager;
-
 #if defined(OS_WIN)
   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;
@@ skipping 38 matching lines @@
       exit_code = 1;
       break;
     }
 
     // Special value "-1" means "repeat indefinitely".
     if (cycles != -1)
       cycles--;
   }
   return exit_code;
 }