Content Shell: Introduce LayoutTestBrowserMain.

content/shell/browser/layout_test/layout_test_browser_main.cc

-// Copyright 2013 The Chromium Authors. All rights reserved.
+// Copyright 2014 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/shell/browser/shell_browser_main.h"
 
 #include <iostream>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 48 matching lines @@
 #if defined(OS_ANDROID)
   if (content::GetTestUrlForAndroid(path_or_url, &test_url))
     return test_url;
 #endif
 
   test_url = GURL(path_or_url);
   if (!(test_url.is_valid() && test_url.has_scheme())) {
     // We're outside of the message loop here, and this is a test.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
 #if defined(OS_WIN)
-    std::wstring wide_path_or_url =
+    base::FilePath::StringType wide_path_or_url =
         base::SysNativeMBToWide(path_or_url);
     base::FilePath local_file(wide_path_or_url);
 #else
     base::FilePath local_file(path_or_url);
 #endif
     if (!base::PathExists(local_file)) {
       local_file = content::GetWebKitRootDirFilePath()
-          .Append(FILE_PATH_LITERAL("LayoutTests")).Append(local_file);
+                       .Append(FILE_PATH_LITERAL("LayoutTests"))
+                       .Append(local_file);
     }
     test_url = net::FilePathToFileURL(base::MakeAbsoluteFilePath(local_file));
   }
   base::FilePath local_path;
   if (current_working_directory) {
     // We're outside of the message loop here, and this is a test.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     if (net::FileURLToFilePath(test_url, &local_path))
       *current_working_directory = local_path.DirName();
     else
@@ skipping 21 matching lines @@
                 bool* ran_at_least_once,
                 const scoped_ptr<content::BrowserMainRunner>& main_runner) {
   if (test_string.empty())
     return true;
   if (test_string == "QUIT")
     return false;
 
   bool enable_pixel_dumps;
   std::string pixel_hash;
   base::FilePath cwd;
-  GURL test_url = GetURLForLayoutTest(
-      test_string, &cwd, &enable_pixel_dumps, &pixel_hash);
+  GURL test_url =
+      GetURLForLayoutTest(test_string, &cwd, &enable_pixel_dumps, &pixel_hash);
   if (!content::WebKitTestController::Get()->PrepareForLayoutTest(
           test_url, cwd, enable_pixel_dumps, pixel_hash)) {
     return false;
   }
 
   *ran_at_least_once = true;
 #if defined(OS_ANDROID)
   // The message loop on Android is provided by the system, and does not
   // offer a blocking Run() method. For layout tests, use a nested loop
   // together with a base::RunLoop so it can block until a QuitClosure.
@@ skipping 10 matching lines @@
   // There will be left-over tasks in the queue for Android because the
   // main window is being destroyed. Run them before starting the next test.
   base::MessageLoop::current()->RunUntilIdle();
 #endif
   return true;
 }
 
 }  // namespace
 
 // Main routine for running as the Browser process.
-int ShellBrowserMain(
+int LayoutTestBrowserMain(
     const content::MainFunctionParams& parameters,
     const scoped_ptr<content::BrowserMainRunner>& main_runner) {
-  bool layout_test_mode =
-      CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree);
   base::ScopedTempDir browser_context_path_for_layout_tests;
 
-  if (layout_test_mode) {
-    CHECK(browser_context_path_for_layout_tests.CreateUniqueTempDir());
-    CHECK(!browser_context_path_for_layout_tests.path().MaybeAsASCII().empty());
-    CommandLine::ForCurrentProcess()->AppendSwitchASCII(
-        switches::kContentShellDataPath,
-        browser_context_path_for_layout_tests.path().MaybeAsASCII());
+  CHECK(browser_context_path_for_layout_tests.CreateUniqueTempDir());
+  CHECK(!browser_context_path_for_layout_tests.path().MaybeAsASCII().empty());
+  CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      switches::kContentShellDataPath,
+      browser_context_path_for_layout_tests.path().MaybeAsASCII());
 
 #if defined(OS_ANDROID)
-    content::EnsureInitializeForAndroidLayoutTests();
+  content::EnsureInitializeForAndroidLayoutTests();
 #endif
-  }
 
   int exit_code = main_runner->Initialize(parameters);
   DCHECK_LT(exit_code, 0)
-      << "BrowserMainRunner::Initialize failed in ShellBrowserMain";
+      << "BrowserMainRunner::Initialize failed in LayoutTestBrowserMain";
 
   if (exit_code >= 0)
     return exit_code;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
-        switches::kCheckLayoutTestSysDeps)) {
+          switches::kCheckLayoutTestSysDeps)) {
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
     main_runner->Run();
     content::Shell::CloseAllWindows();
     main_runner->Shutdown();
     return 0;
   }
 
-  if (layout_test_mode) {
-    content::WebKitTestController test_controller;
-    {
-      // We're outside of the message loop here, and this is a test.
-      base::ThreadRestrictions::ScopedAllowIO allow_io;
-      base::FilePath temp_path;
-      base::GetTempDir(&temp_path);
-      test_controller.SetTempPath(temp_path);
-    }
-    std::string test_string;
-    CommandLine::StringVector args =
-        CommandLine::ForCurrentProcess()->GetArgs();
-    size_t command_line_position = 0;
-    bool ran_at_least_once = false;
+  content::WebKitTestController test_controller;
+  {
+    // We're outside of the message loop here, and this is a test.
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    base::FilePath temp_path;
+    base::GetTempDir(&temp_path);
+    test_controller.SetTempPath(temp_path);
+  }
+  std::string test_string;
+  CommandLine::StringVector args = CommandLine::ForCurrentProcess()->GetArgs();
+  size_t command_line_position = 0;
+  bool ran_at_least_once = false;
 
-    std::cout << "#READY\n";
-    std::cout.flush();
+  std::cout << "#READY\n";
+  std::cout.flush();
 
-    while (GetNextTest(args, &command_line_position, &test_string)) {
-      if (!RunOneTest(test_string, &ran_at_least_once, main_runner))
-        break;
-    }
-    if (!ran_at_least_once) {
-      base::MessageLoop::current()->PostTask(FROM_HERE,
-                                             base::MessageLoop::QuitClosure());
-      main_runner->Run();
-    }
+  while (GetNextTest(args, &command_line_position, &test_string)) {
+    if (!RunOneTest(test_string, &ran_at_least_once, main_runner))
+      break;
+  }
+  if (!ran_at_least_once) {
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::MessageLoop::QuitClosure());
+    main_runner->Run();
+  }
 
 #if defined(OS_ANDROID)
-    // Android should only execute Shutdown() here when running layout tests.
-    main_runner->Shutdown();
-#endif
-
-    exit_code = 0;
-  }
-
-#if !defined(OS_ANDROID)
-  if (!layout_test_mode)
-    exit_code = main_runner->Run();
-
+  // Android should only execute Shutdown() here when running layout tests.
   main_runner->Shutdown();
 #endif
 
+  exit_code = 0;
+
+#if !defined(OS_ANDROID)
+  main_runner->Shutdown();
+#endif
+
   return exit_code;
 }