Run ContentMain in a browser_test's browser process. This removes duplication of code in the browse…

content/public/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 <map>
 #include <string>
 #include <vector>
 
@@ skipping 42 matching lines @@
 // that span browser restarts.
 const char kPreTestPrefix[] = "PRE_";
 
 // Manual tests only run when --run-manual is specified. This allows writing
 // tests that don't run automatically but are still in the same test binary.
 // This is useful so that a team that wants to run a few tests doesn't have to
 // add a new binary that must be compiled on all builds.
 const char kManualTestPrefix[] = "MANUAL_";
 
 TestLauncherDelegate* g_launcher_delegate;
+ContentMainParams* g_params;
 
 std::string RemoveAnyPrePrefixes(const std::string& test_name) {
   std::string result(test_name);
   ReplaceSubstringsAfterOffset(&result, 0, kPreTestPrefix, std::string());
   return result;
 }
 
 void PrintUsage() {
   fprintf(stdout,
           "Runs tests using the gtest framework, each batch of tests being\n"
@@ skipping 347 matching lines @@
 
 // See kManualTestPrefix above.
 const char kRunManualTestsFlag[] = "run-manual";
 
 const char kSingleProcessTestsFlag[]   = "single_process";
 
 
 TestLauncherDelegate::~TestLauncherDelegate() {
 }
 
-#if defined(OS_WIN) || defined(OS_LINUX)
-bool ShouldRunContentMain() {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  return command_line->HasSwitch(switches::kProcessType) ||
-         command_line->HasSwitch(kLaunchAsBrowser);
-  return false;
-}
-
-int RunContentMain(int argc, char** argv,
-                   TestLauncherDelegate* launcher_delegate) {
-  scoped_ptr<ContentMainDelegate> chrome_main_delegate(
-      launcher_delegate->CreateContentMainDelegate());
-  ContentMainParams params(chrome_main_delegate.get());
-
-#if defined(OS_WIN)
-  sandbox::SandboxInterfaceInfo sandbox_info = {0};
-  InitializeSandboxInfo(&sandbox_info);
-
-  params.instance = GetModuleHandle(NULL);
-  params.sandbox_info = &sandbox_info;
-#elif defined(OS_LINUX)
-  params.argc = argc;
-  params.argv = const_cast<const char**>(argv);
-#endif  // defined(OS_WIN)
-
-  return ContentMain(params);
-}
-#endif
-
 int LaunchTests(TestLauncherDelegate* launcher_delegate,
                 int default_jobs,
                 int argc,
                 char** argv) {
   DCHECK(!g_launcher_delegate);
   g_launcher_delegate = launcher_delegate;
 
   CommandLine::Init(argc, argv);
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   if (command_line->HasSwitch(kHelpFlag)) {
     PrintUsage();
     return 0;
   }
 
+  scoped_ptr<ContentMainDelegate> chrome_main_delegate(
+      launcher_delegate->CreateContentMainDelegate());
+  ContentMainParams params(chrome_main_delegate.get());
+
+#if defined(OS_WIN)
+  sandbox::SandboxInterfaceInfo sandbox_info = {0};
+  InitializeSandboxInfo(&sandbox_info);
+
+  params.instance = GetModuleHandle(NULL);
+  params.sandbox_info = &sandbox_info;
+#elif !defined(OS_ANDROID)
+  params.argc = argc;
+  params.argv = const_cast<const char**>(argv);
+#endif  // defined(OS_WIN)
+
   if (command_line->HasSwitch(kSingleProcessTestsFlag) ||
       (command_line->HasSwitch(switches::kSingleProcess) &&
        command_line->HasSwitch(base::kGTestFilterFlag)) ||
       command_line->HasSwitch(base::kGTestListTestsFlag) ||
       command_line->HasSwitch(base::kGTestHelpFlag)) {
-#if defined(OS_WIN)
-    if (command_line->HasSwitch(kSingleProcessTestsFlag)) {
-      sandbox::SandboxInterfaceInfo sandbox_info;
-      InitializeSandboxInfo(&sandbox_info);
-      InitializeSandbox(&sandbox_info);
-    }
-#endif
+    g_params = &params;
     return launcher_delegate->RunTestSuite(argc, argv);
   }
 
-#if defined(OS_WIN) || defined(OS_LINUX)
-  if (ShouldRunContentMain())
-    return RunContentMain(argc, argv, launcher_delegate);
+#if !defined(OS_ANDROID)
+  if (command_line->HasSwitch(switches::kProcessType) ||
+      command_line->HasSwitch(kLaunchAsBrowser)) {
+    return ContentMain(params);
+  }
 #endif
 
   base::AtExitManager at_exit;
   testing::InitGoogleTest(&argc, argv);
   TestTimeouts::Initialize();
 
   fprintf(stdout,
       "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"
       "--single_process (to run the test in one launcher/browser process) or\n"
       "--single-process (to do the above, and also run Chrome in single-"
           "process mode).\n");
 
   base::MessageLoopForIO message_loop;
 
   // Allow the |launcher_delegate| to modify |default_jobs|.
   launcher_delegate->AdjustDefaultParallelJobs(&default_jobs);
 
   WrapperTestLauncherDelegate delegate(launcher_delegate);
   base::TestLauncher launcher(&delegate, default_jobs);
   bool success = launcher.Run(argc, argv);
   return (success ? 0 : 1);
 }
 
 TestLauncherDelegate* GetCurrentTestLauncherDelegate() {
   return g_launcher_delegate;
 }
 
+ContentMainParams* GetContentMainParams() {
+  return g_params;
+}
+
 }  // namespace content