content_shell: Create the FIFOs needed for running Android layout tests

content/shell/shell_browser_main.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/shell/shell_browser_main.h"
 
 #include <iostream>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/public/browser/browser_main_runner.h"
 #include "content/shell/common/shell_switches.h"
 #include "content/shell/common/webkit_test_helpers.h"
 #include "content/shell/shell.h"
 #include "content/shell/webkit_test_controller.h"
 #include "net/base/net_util.h"
 #include "webkit/support/webkit_support.h"
 
 #if defined(OS_ANDROID)
-#include "base/android/jni_android.h"
 #include "base/run_loop.h"
-#include "content/public/test/nested_message_pump_android.h"
+#include "content/shell/shell_layout_tests_android.h"
 #endif
 
 namespace {
 
-#if defined(OS_ANDROID)
-// Path to search for when translating a layout test path to an URL.
-const char kAndroidLayoutTestPath[] =
-    "/data/local/tmp/third_party/WebKit/LayoutTests/";
-
-// The base URL from which layout tests are being served on Android.
-const char kAndroidLayoutTestBase[] = "http://127.0.0.1:8000/all-tests/";
-
-base::MessagePump* CreateMessagePumpForUI() {
-  return new content::NestedMessagePumpAndroid();
-}
-
-#endif
-
 GURL GetURLForLayoutTest(const std::string& test_name,
                          base::FilePath* current_working_directory,
                          bool* enable_pixel_dumping,
                          std::string* expected_pixel_hash) {
   // A test name is formated like file:///path/to/test'--pixel-test'pixelhash
   std::string path_or_url = test_name;
   std::string pixel_switch;
   std::string pixel_hash;
   std::string::size_type separator_position = path_or_url.find('\'');
   if (separator_position != std::string::npos) {
     pixel_switch = path_or_url.substr(separator_position + 1);
     path_or_url.erase(separator_position);
   }
   separator_position = pixel_switch.find('\'');
   if (separator_position != std::string::npos) {
     pixel_hash = pixel_switch.substr(separator_position + 1);
     pixel_switch.erase(separator_position);
   }
   if (enable_pixel_dumping) {
     *enable_pixel_dumping =
         (pixel_switch == "--pixel-test" || pixel_switch == "-p");
   }
   if (expected_pixel_hash)
     *expected_pixel_hash = pixel_hash;
 
+  GURL test_url;
 #if defined(OS_ANDROID)
-  // On Android, all passed tests will be paths to a local temporary directory.
-  // However, because we can't transfer all test files to the device, translate
-  // those paths to a local, forwarded URL so the host can serve them.
-  if (path_or_url.find(kAndroidLayoutTestPath) != std::string::npos) {
-    std::string test_location(kAndroidLayoutTestBase);
-    test_location.append(path_or_url.substr(strlen(kAndroidLayoutTestPath)));
-
-    return GURL(test_location);
-  }
+  if (content::GetTestUrlForAndroid(path_or_url, &test_url))
+    return test_url;
 #endif
 
-  GURL test_url(path_or_url);
+  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::SysNativeMBToWide(path_or_url);
     base::FilePath local_file(wide_path_or_url);
 #else
     base::FilePath local_file(path_or_url);
 #endif
@@ skipping 26 matching lines @@
   *test = WideToUTF8(args[(*position)++]);
 #else
   *test = args[(*position)++];
 #endif
   return true;
 }
 
 }  // namespace
 
 // Main routine for running as the Browser process.
-int ShellBrowserMain(const content::MainFunctionParams& parameters,
-                     scoped_ptr<content::BrowserMainRunner>& main_runner) {
+int ShellBrowserMain(
+    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());
 
 #if defined(OS_ANDROID)
-    // TODO(beverloo): Create the FIFOs required for Android layout tests.
-
-    JNIEnv* env = base::android::AttachCurrentThread();
-    content::NestedMessagePumpAndroid::RegisterJni(env);
-
-    const bool success = base::MessageLoop::InitMessagePumpForUIFactory(
-        &CreateMessagePumpForUI);
-    CHECK(success) << "Unable to initialize the message pump for Android.";
+    content::EnsureInitializeForAndroidLayoutTests();
 #endif
   }
 
   int exit_code = main_runner->Initialize(parameters);
-  DCHECK(exit_code < 0)
+  DCHECK_LT(exit_code, 0)
       << "BrowserMainRunner::Initialize failed in ShellBrowserMain";
 
   if (exit_code >= 0)
     return exit_code;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kCheckLayoutTestSysDeps)) {
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
     main_runner->Run();
@@ skipping 62 matching lines @@
 
 #if !defined(OS_ANDROID)
   if (!layout_test_mode)
     exit_code = main_runner->Run();
 
   main_runner->Shutdown();
 #endif
 
   return exit_code;
 }