test_runner: Add TestInfoExtractor to get the list of test-urls.

components/test_runner/test_info_extractor.cc

Index: components/test_runner/test_info_extractor.cc
diff --git a/components/test_runner/test_info_extractor.cc b/components/test_runner/test_info_extractor.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2c7ecbcaad8596eb67e6af0e9408ae8796c47375
--- /dev/null
+++ b/components/test_runner/test_info_extractor.cc
@@ -0,0 +1,148 @@
+// Copyright 2015 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 "components/test_runner/test_info_extractor.h"
+
+#include <iostream>
+
+#include "base/base_paths.h"
+#include "base/files/file_util.h"
+#include "base/path_service.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/threading/thread_restrictions.h"
+#include "net/base/filename_util.h"
+
+namespace test_runner {
+
+namespace {
+
+#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.
+bool GetTestUrlForAndroid(std::string& path_or_url, GURL* url) {
+  // 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/";

[Ryan Sleevi, 2015/09/10 17:48:03]

BUG: I don't know if this is something Blink is already doing, but hardcoding
the URL like this is something we strongly discourage in //net.

For example, as written, this could potentially prevent test concurrency and
potentially cause issues with port forwarding. When we hardcoded URLs, we had
all sorts of issues.

Is there a better way to do this? Either IPC or via the command-line to indicate
where the test harness should talk to for running the tests?

This also suggests there may be platform test divergences - using a file:// URL
on one platform, but an http:// URL on another, which may lead to any number of
surprising things (especially as we move towards requiring secure contexts)

[sadrul, 2015/09/10 18:09:08]

This is something we have been doing for a while on android
(https://chromiumcodereview.appspot.com/17265005). I have filed a bug to address
the concerns (http://crbug.com/530257)

+
+  if (path_or_url.find(kAndroidLayoutTestPath) == std::string::npos)
+    return false;
+
+  std::string test_location(kAndroidLayoutTestBase);
+  test_location.append(path_or_url.substr(strlen(kAndroidLayoutTestPath)));
+
+  *url = GURL(test_location);
+  return true;
+}
+#endif  // defined(OS_ANDROID)
+
+scoped_ptr<TestInfo> GetTestInfoFromLayoutTestName(
+    const std::string& test_name) {
+  // 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::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('\'');
+  std::string expected_pixel_hash;
+  if (separator_position != std::string::npos) {
+    expected_pixel_hash = pixel_switch.substr(separator_position + 1);
+    pixel_switch.erase(separator_position);
+  }
+  const bool enable_pixel_dumping =
+      (pixel_switch == "--pixel-test" || pixel_switch == "-p");
+
+  GURL test_url;
+#if defined(OS_ANDROID)
+  if (GetTestUrlForAndroid(path_or_url, &test_url)) {
+    return make_scoped_ptr(new TestInfo(test_url, enable_pixel_dumping,
+                                        expected_pixel_hash, base::FilePath()));
+  }
+#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)
+    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)) {
+      base::FilePath base_path;
+      PathService::Get(base::DIR_SOURCE_ROOT, &base_path);
+      local_file = base_path.Append(FILE_PATH_LITERAL("third_party"))
+                       .Append(FILE_PATH_LITERAL("WebKit"))
+                       .Append(FILE_PATH_LITERAL("LayoutTests"))
+                       .Append(local_file);
+    }
+    test_url = net::FilePathToFileURL(base::MakeAbsoluteFilePath(local_file));
+  }
+  base::FilePath local_path;
+  base::FilePath 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
+    base::GetCurrentDirectory(&current_working_directory);
+  return make_scoped_ptr(new TestInfo(test_url, enable_pixel_dumping,
+                                      expected_pixel_hash,
+                                      current_working_directory));
+}
+
+}  // namespace
+
+TestInfo::TestInfo(const GURL& url,
+                   bool enable_pixel_dumping,
+                   const std::string& expected_pixel_hash,
+                   const base::FilePath& current_working_directory)
+    : url(url),
+      enable_pixel_dumping(enable_pixel_dumping),
+      expected_pixel_hash(expected_pixel_hash),
+      current_working_directory(current_working_directory) {}
+TestInfo::~TestInfo() {}
+
+TestInfoExtractor::TestInfoExtractor(
+    const base::CommandLine::StringVector& cmd_args)
+    : cmdline_args_(cmd_args), cmdline_position_(0) {}
+
+TestInfoExtractor::~TestInfoExtractor() {}
+
+scoped_ptr<TestInfo> TestInfoExtractor::GetNextTest() {
+  if (cmdline_position_ >= cmdline_args_.size())
+    return nullptr;
+
+  std::string test_string;
+  if (cmdline_args_[cmdline_position_] == FILE_PATH_LITERAL("-")) {
+    do {
+      bool success = !!std::getline(std::cin, test_string, '\n');
+      if (!success)
+        return nullptr;
+    } while (test_string.empty());
+  } else {
+#if defined(OS_WIN)
+    test_string = base::WideToUTF8(cmdline_args_[cmdline_position_++]);
+#else
+    test_string = cmdline_args_[cmdline_position_++];
+#endif
+  }
+
+  DCHECK(!test_string.empty());
+  if (test_string == "QUIT")
+    return nullptr;
+  return GetTestInfoFromLayoutTestName(test_string);
+}
+
+}  // namespace test_runner