Rewrite layout_browsertests to use content_shell --dump-render-tree to execute layout tests

content/test/layout_browsertest.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/test/layout_browsertest.h"
 
+#include <sstream>
+
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
+#include "base/run_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/shell/shell.h"
 #include "content/shell/shell_switches.h"
+#include "content/shell/webkit_test_runner_host.h"
 #include "content/test/content_browser_test_utils.h"
 #include "content/test/layout_test_http_server.h"
 #include "net/base/net_util.h"
 
 #if defined(OS_WIN)
 static const char kPlatformName[] = "chromium-win";
 #elif defined(OS_MACOSX)
 static const char kPlatformName[] = "chromium-mac";
 #elif defined(OS_LINUX)
 static const char kPlatformName[] = "chromium-linux";
 #elif defined(OS_OPENBSD)
 static const char kPlatformName[] = "chromium-openbsd";
 #else
 #error No known OS defined
 #endif
 
 namespace {
 
-size_t FindInsertPosition(const std::string& html) {
-  size_t tag_start = html.find("<html");
-  if (tag_start == std::string::npos)
-    return 0;
-  size_t tag_end = html.find(">", tag_start);
-  if (tag_end == std::string::npos)
-    return 0;
-  return tag_end + 1;
-}
-
 bool ReadExpectedResult(const FilePath& result_dir_path,
                         const std::string test_case_file_name,
                         std::string* expected_result_value) {
   FilePath expected_result_path(result_dir_path);
   expected_result_path = expected_result_path.AppendASCII(test_case_file_name);
   expected_result_path = expected_result_path.InsertBeforeExtension(
       FILE_PATH_LITERAL("-expected"));
   expected_result_path =
       expected_result_path.ReplaceExtension(FILE_PATH_LITERAL("txt"));
   return file_util::ReadFileToString(
       expected_result_path, expected_result_value);
 }
 
-void ScrapeResultFromBrowser(content::Shell* window, std::string* actual_text) {
-  ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
-      window->web_contents()->GetRenderViewHost(),
-      L"",
-      L"window.domAutomationController.send(document.body.innerText);",
-      actual_text));
-}
-
-static const std::string preamble =
-      "\n<script>\n"
-      "function TestRunner() {\n"
-      "  this.wait_until_done_ = false;\n"
-      "  this.dumpAsText = function () {};\n"
-      "  this.waitUntilDone = function () {\n"
-      "    this.wait_until_done_ = true;\n"
-      "  }\n"
-      "  this.notifyDone = function () {\n"
-      "    document.title = 'done';\n"
-      "  }\n"
-      "  this.overridePreference = function () {}\n"
-      "  this.OnEvent = function () {\n"
-      "    if (!testRunner.wait_until_done_)\n"
-      "      testRunner.notifyDone();\n"
-      "  }\n"
-      "  this.workerThreadCount = 0; \n"
-      "}\n"
-      "window.testRunner = new TestRunner();\n"
-      "window.addEventListener('load', testRunner.OnEvent, false);\n"
-      "</script>";
-
-}
+}  // namespace
 
 InProcessBrowserLayoutTest::InProcessBrowserLayoutTest(
     const FilePath& test_parent_dir, const FilePath& test_case_dir)
     : test_parent_dir_(test_parent_dir), test_case_dir_(test_case_dir),
       port_(-2) {
 }
 
 InProcessBrowserLayoutTest::InProcessBrowserLayoutTest(
     const FilePath& test_parent_dir, const FilePath& test_case_dir, int port)
     : test_parent_dir_(test_parent_dir), test_case_dir_(test_case_dir),
       port_(port) {
 }
 
 InProcessBrowserLayoutTest::~InProcessBrowserLayoutTest() {
   if (test_http_server_.get())
     CHECK(test_http_server_->Stop());
 }
 
 void InProcessBrowserLayoutTest::SetUpInProcessBrowserTestFixture() {
-  ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
   FilePath src_dir;
   ASSERT_TRUE(PathService::Get(content::DIR_LAYOUT_TESTS, &src_dir));
-  our_original_layout_test_dir_ =
-      src_dir.Append(test_parent_dir_).Append(test_case_dir_);
-  ASSERT_TRUE(file_util::DirectoryExists(our_original_layout_test_dir_));
-  our_layout_test_temp_dir_ = scoped_temp_dir_.path()
-      .AppendASCII("LayoutTests").Append(test_parent_dir_);
-  ASSERT_TRUE(file_util::CreateDirectory(
-      our_layout_test_temp_dir_.Append(test_case_dir_)));
-  file_util::CopyDirectory(
-      our_original_layout_test_dir_.AppendASCII("resources"),
-      our_layout_test_temp_dir_.Append(test_case_dir_).AppendASCII("resources"),
-      true /*recursive*/);
+  FilePath absolute_parent_dir = src_dir.Append(test_parent_dir_);
+  ASSERT_TRUE(file_util::DirectoryExists(absolute_parent_dir));
+  layout_test_dir_ = absolute_parent_dir.Append(test_case_dir_);
+  ASSERT_TRUE(file_util::DirectoryExists(layout_test_dir_));
 
   // Gets the file path to rebased expected result directory for the current
   // platform.
   //   $LayoutTestRoot/platform/chromium_***/...
   rebase_result_dir_ = src_dir.AppendASCII("platform");
   rebase_result_dir_ = rebase_result_dir_.AppendASCII(kPlatformName);
   rebase_result_dir_ = rebase_result_dir_.Append(test_parent_dir_);
   rebase_result_dir_ = rebase_result_dir_.Append(test_case_dir_);
 
   // Generic chromium expected results. Not OS-specific. For example,
@@ skipping 13 matching lines @@
                                    Append(test_parent_dir_).
                                    Append(test_case_dir_);
 #endif
 
   if (port_ != -2) {
     // Layout tests expect that the server points at the
     // LayoutTests\http\tests directory.
     if (port_ == -1)
       port_ = base::RandInt(1024, 65535);
     test_http_server_.reset(new LayoutTestHttpServer(
-        our_layout_test_temp_dir_, port_));
+        absolute_parent_dir, port_));
     ASSERT_TRUE(test_http_server_->Start());
   }
 }
 
+void InProcessBrowserLayoutTest::SetUpCommandLine(CommandLine* command_line) {
+  command_line->AppendSwitch(switches::kDumpRenderTree);
+}
+
+void InProcessBrowserLayoutTest::SetUpOnMainThread() {
+  test_controller_.reset(new content::WebKitTestController);
+}
+
 void InProcessBrowserLayoutTest::RunLayoutTest(
     const std::string& test_case_file_name) {
-  FilePath file_path;
-  WriteModifiedFile(test_case_file_name, &file_path);
-  GURL url = net::FilePathToFileURL(file_path);
+  GURL url = net::FilePathToFileURL(
+      layout_test_dir_.AppendASCII(test_case_file_name));
   RunLayoutTestInternal(test_case_file_name, url);
 }
 
 void InProcessBrowserLayoutTest::RunHttpLayoutTest(
     const std::string& test_case_file_name) {
   DCHECK(test_http_server_.get());
-  FilePath file_path;
-  WriteModifiedFile(test_case_file_name, &file_path);
-
   GURL url(StringPrintf(
       "http://127.0.0.1:%d/%s/%s", port_, test_case_dir_.MaybeAsASCII().c_str(),
       test_case_file_name.c_str()));
   RunLayoutTestInternal(test_case_file_name, url);
 }
 
 void InProcessBrowserLayoutTest::RunLayoutTestInternal(
     const std::string& test_case_file_name, const GURL& url) {
+  std::stringstream result;
+  scoped_ptr<content::WebKitTestResultPrinter> printer(
+      new content::WebKitTestResultPrinter(&result, NULL));
+  printer->set_capture_text_only(true);
+  test_controller_->set_printer(printer.release());
+
   LOG(INFO) << "Navigating to URL " << url << " and blocking.";
-  const string16 expected_title = ASCIIToUTF16("done");
-  content::TitleWatcher title_watcher(shell()->web_contents(), expected_title);
-  content::NavigateToURL(shell(), url);
-  LOG(INFO) << "Navigation completed, now waiting for title.";
-  string16 final_title = title_watcher.WaitAndGetTitle();
-  EXPECT_EQ(expected_title, final_title);
+  ASSERT_TRUE(test_controller_->PrepareForLayoutTest(url, false, ""));
+  base::RunLoop run_loop;
+  run_loop.Run();
+  LOG(INFO) << "Navigation completed.";
+  ASSERT_TRUE(test_controller_->ResetAfterLayoutTest());
 
-  std::string actual_text;
-  ScrapeResultFromBrowser(shell(), &actual_text);
-  ReplaceSubstringsAfterOffset(&actual_text, 0, "\r", "");

[dgrogan, 2012/09/25 18:04:31]

Looks like we now need this on the expected_text

-  TrimString(actual_text, "\n", &actual_text);
+  std::string actual_text = result.str();;
 
   std::string expected_text;
   // Reads the expected result. First try to read from rebase directory.
   // If failed, read from original directory.
   if (!ReadExpectedResult(rebase_result_dir_,
                           test_case_file_name,
                           &expected_text) &&
       !ReadExpectedResult(rebase_result_chromium_dir_,
                           test_case_file_name,
                           &expected_text)) {
     if (rebase_result_win_dir_.empty() ||
         !ReadExpectedResult(rebase_result_win_dir_,
                             test_case_file_name,
                             &expected_text))
-      ReadExpectedResult(our_original_layout_test_dir_,
+      ReadExpectedResult(layout_test_dir_,
                          test_case_file_name,
                          &expected_text);
   }
   ASSERT_TRUE(!expected_text.empty());
-  ReplaceSubstringsAfterOffset(&expected_text, 0, "\r", "");
-  TrimString(expected_text, "\n", &expected_text);
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kOutputLayoutTestDifferences)) {
     EXPECT_EQ(expected_text, actual_text) <<
         SaveResults(expected_text, actual_text);
   } else {
     EXPECT_EQ(expected_text, actual_text);
   }
 }
 
-void InProcessBrowserLayoutTest::AddResourceForLayoutTest(
-    const FilePath& parent_dir,
-    const FilePath& resource_name) {
-  FilePath source;
-  ASSERT_TRUE(PathService::Get(content::DIR_LAYOUT_TESTS, &source));
-  source = source.Append(parent_dir);
-  source = source.Append(resource_name);
-
-  ASSERT_TRUE(file_util::PathExists(source));
-
-  FilePath dest_parent_dir = scoped_temp_dir_.path().
-      AppendASCII("LayoutTests").Append(parent_dir);
-  ASSERT_TRUE(file_util::CreateDirectory(dest_parent_dir));
-  FilePath dest = dest_parent_dir.Append(resource_name);
-
-  if (file_util::DirectoryExists(source)) {
-    ASSERT_TRUE(file_util::CreateDirectory(dest.DirName()));
-    ASSERT_TRUE(file_util::CopyDirectory(source, dest, true));
-  } else {
-    ASSERT_TRUE(file_util::CopyFile(source, dest));
-  }
-}
-
-void InProcessBrowserLayoutTest::WriteModifiedFile(
-    const std::string& test_case_file_name, FilePath* test_path) {
-  FilePath path_to_single_test =
-      our_original_layout_test_dir_.AppendASCII(test_case_file_name);
-  std::string test_html;
-  ASSERT_TRUE(file_util::ReadFileToString(path_to_single_test, &test_html));
-
-  size_t insertion_position = FindInsertPosition(test_html);
-  test_html.insert(insertion_position, preamble);
-  *test_path = our_layout_test_temp_dir_.Append(test_case_dir_);
-  *test_path = test_path->AppendASCII(test_case_file_name);
-  ASSERT_TRUE(file_util::WriteFile(*test_path,
-                                   &test_html.at(0),
-                                   static_cast<int>(test_html.size())));
-}
-
 std::string InProcessBrowserLayoutTest::SaveResults(const std::string& expected,
                                                     const std::string& actual) {
   FilePath cwd;
   EXPECT_TRUE(file_util::CreateNewTempDirectory(FILE_PATH_LITERAL(""), &cwd));
   FilePath expected_filename = cwd.Append(FILE_PATH_LITERAL("expected.txt"));
   FilePath actual_filename = cwd.Append(FILE_PATH_LITERAL("actual.txt"));
   EXPECT_NE(-1, file_util::WriteFile(expected_filename,
                                      expected.c_str(),
                                      expected.size()));
   EXPECT_NE(-1, file_util::WriteFile(actual_filename,
                                      actual.c_str(),
                                      actual.size()));
   return StringPrintf("Wrote %"PRFilePath" %"PRFilePath,
                       expected_filename.value().c_str(),
                       actual_filename.value().c_str());
 }