Componentize URLFixerUpper.

components/url_fixer/url_fixer_unittest.cc

 // Copyright (c) 2011 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 <stdlib.h>
 
+#include "base/base_paths.h"
 #include "base/basictypes.h"
 #include "base/file_util.h"
+#include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/common/chrome_paths.h"
-#include "chrome/common/net/url_fixer_upper.h"
+#include "components/url_fixer/url_fixer.h"
 #include "net/base/filename_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/url_parse.h"
 
 namespace url {
 
 std::ostream& operator<<(std::ostream& os, const Component& part) {
   return os << "(begin=" << part.begin << ", len=" << part.len << ")";
 }
@@ skipping 161 matching lines @@
     url::Component(), // username
     url::Component(), // password
     url::Component(), // host
     url::Component(), // port
     url::Component(), // path
     url::Component(), // query
     url::Component(), // ref
   },
 };
 
-typedef testing::Test URLFixerUpperTest;
+typedef testing::Test URLFixerTest;
 
-TEST(URLFixerUpperTest, SegmentURL) {
+TEST(URLFixerTest, SegmentURL) {
   std::string result;
   url::Parsed parts;
 
   for (size_t i = 0; i < arraysize(segment_cases); ++i) {
     SegmentCase value = segment_cases[i];
-    result = URLFixerUpper::SegmentURL(value.input, &parts);
+    result = url_fixer::SegmentURL(value.input, &parts);
     EXPECT_EQ(value.result, result);
     EXPECT_EQ(value.scheme, parts.scheme);
     EXPECT_EQ(value.username, parts.username);
     EXPECT_EQ(value.password, parts.password);
     EXPECT_EQ(value.host, parts.host);
     EXPECT_EQ(value.port, parts.port);
     EXPECT_EQ(value.path, parts.path);
     EXPECT_EQ(value.query, parts.query);
     EXPECT_EQ(value.ref, parts.ref);
   }
@@ skipping 89 matching lines @@
   {"whatsup;//fool", "whatsup://fool"},
   // Semicolon left as-is in URL itself.
   {"http://host/port?query;moar", "http://host/port?query;moar"},
   // Fewer slashes than expected.
   {"http;www.google.com/", "http://www.google.com/"},
   {"http;/www.google.com/", "http://www.google.com/"},
   // Semicolon at start.
   {";http://www.google.com/", "http://%3Bhttp//www.google.com/"},
 };
 
-TEST(URLFixerUpperTest, FixupURL) {
+TEST(URLFixerTest, FixupURL) {
   for (size_t i = 0; i < arraysize(fixup_cases); ++i) {
     FixupCase value = fixup_cases[i];
     EXPECT_EQ(value.output,
-        URLFixerUpper::FixupURL(value.input, "").possibly_invalid_spec())
+              url_fixer::FixupURL(value.input, "").possibly_invalid_spec())
         << "input: " << value.input;
   }
 
   // Check the TLD-appending functionality.
   FixupCase tld_cases[] = {
     {"google", "http://www.google.com/"},
     {"google.", "http://www.google.com/"},
     {"google..", "http://www.google.com/"},
     {".google", "http://www.google.com/"},
     {"www.google", "http://www.google.com/"},
     {"google.com", "http://google.com/"},
     {"http://google", "http://www.google.com/"},
     {"..google..", "http://www.google.com/"},
     {"http://www.google", "http://www.google.com/"},
     {"9999999999999999", "http://www.9999999999999999.com/"},
     {"google/foo", "http://www.google.com/foo"},
     {"google.com/foo", "http://google.com/foo"},
     {"google/?foo=.com", "http://www.google.com/?foo=.com"},
     {"www.google/?foo=www.", "http://www.google.com/?foo=www."},
     {"google.com/?foo=.com", "http://google.com/?foo=.com"},
     {"http://www.google.com", "http://www.google.com/"},
     {"google:123", "http://www.google.com:123/"},
     {"http://google:123", "http://www.google.com:123/"},
   };
   for (size_t i = 0; i < arraysize(tld_cases); ++i) {
     FixupCase value = tld_cases[i];
     EXPECT_EQ(value.output,
-        URLFixerUpper::FixupURL(value.input, "com").possibly_invalid_spec());
+              url_fixer::FixupURL(value.input, "com").possibly_invalid_spec());
   }
 }
 
 // Test different types of file inputs to URIFixerUpper::FixupURL. This
 // doesn't go into the nice array of fixups above since the file input
 // has to exist.
-TEST(URLFixerUpperTest, FixupFile) {
+TEST(URLFixerTest, FixupFile) {
   // this "original" filename is the one we tweak to get all the variations
   base::FilePath dir;
   base::FilePath original;
-  ASSERT_TRUE(PathService::Get(chrome::DIR_APP, &dir));
+  ASSERT_TRUE(PathService::Get(base::DIR_MODULE, &dir));
   ASSERT_TRUE(MakeTempFile(
       dir,
       base::FilePath(FILE_PATH_LITERAL("url fixer upper existing file.txt")),
       &original));
 
   // reference path
   GURL golden(net::FilePathToFileURL(original));
 
   // c:\foo\bar.txt -> file:///c:/foo/bar.txt (basic)
-  GURL fixedup(URLFixerUpper::FixupURL(original.AsUTF8Unsafe(), std::string()));
+  GURL fixedup(url_fixer::FixupURL(original.AsUTF8Unsafe(), std::string()));
   EXPECT_EQ(golden, fixedup);
 
   // TODO(port): Make some equivalent tests for posix.
 #if defined(OS_WIN)
   // c|/foo\bar.txt -> file:///c:/foo/bar.txt (pipe allowed instead of colon)
   std::string cur(base::WideToUTF8(original.value()));
   EXPECT_EQ(':', cur[1]);
   cur[1] = '|';
-  EXPECT_EQ(golden, URLFixerUpper::FixupURL(cur, std::string()));
+  EXPECT_EQ(golden, url_fixer::FixupURL(cur, std::string()));
 
   FixupCase cases[] = {
     {"c:\\Non-existent%20file.txt", "file:///C:/Non-existent%2520file.txt"},
 
     // \\foo\bar.txt -> file://foo/bar.txt
     // UNC paths, this file won't exist, but since there are no escapes, it
     // should be returned just converted to a file: URL.
     {"\\\\NonexistentHost\\foo\\bar.txt", "file://nonexistenthost/foo/bar.txt"},
     // We do this strictly, like IE8, which only accepts this form using
     // backslashes and not forward ones.  Turning "//foo" into "http" matches
@@ skipping 15 matching lines @@
     //   {"file:///foo:/bar", "file://foo/bar"},
     //   {"file:/\\/server\\folder/file", "file://server/folder/file"},
   };
 #elif defined(OS_POSIX)
 
 #if defined(OS_MACOSX)
 #define HOME "/Users/"
 #else
 #define HOME "/home/"
 #endif
-  URLFixerUpper::home_directory_override = "/foo";
+  url_fixer::home_directory_override = "/foo";
   FixupCase cases[] = {
     // File URLs go through GURL, which tries to escape intelligently.
     {"/A%20non-existent file.txt", "file:///A%2520non-existent%20file.txt"},
     // A plain "/" refers to the root.
     {"/", "file:///"},
 
     // These rely on the above home_directory_override.
     {"~", "file:///foo"},
     {"~/bar", "file:///foo/bar"},
 
     // References to other users' homedirs.
     {"~foo", "file://" HOME "foo"},
     {"~x/blah", "file://" HOME "x/blah"},
   };
 #endif
 
   for (size_t i = 0; i < arraysize(cases); i++) {
     EXPECT_EQ(cases[i].output,
-        URLFixerUpper::FixupURL(cases[i].input, "").possibly_invalid_spec());
+              url_fixer::FixupURL(cases[i].input, "").possibly_invalid_spec());
   }
 
   EXPECT_TRUE(base::DeleteFile(original, false));
 }
 
-TEST(URLFixerUpperTest, FixupRelativeFile) {
+TEST(URLFixerTest, FixupRelativeFile) {
   base::FilePath full_path, dir;
   base::FilePath file_part(
       FILE_PATH_LITERAL("url_fixer_upper_existing_file.txt"));
-  ASSERT_TRUE(PathService::Get(chrome::DIR_APP, &dir));
+  ASSERT_TRUE(PathService::Get(base::DIR_MODULE, &dir));
   ASSERT_TRUE(MakeTempFile(dir, file_part, &full_path));
   full_path = base::MakeAbsoluteFilePath(full_path);
   ASSERT_FALSE(full_path.empty());
 
   // make sure we pass through good URLs
   for (size_t i = 0; i < arraysize(fixup_cases); ++i) {
     FixupCase value = fixup_cases[i];
     base::FilePath input = base::FilePath::FromUTF8Unsafe(value.input);
     EXPECT_EQ(value.output,
-        URLFixerUpper::FixupRelativeFile(dir, input).possibly_invalid_spec());
+              url_fixer::FixupRelativeFile(dir, input).possibly_invalid_spec());
   }
 
   // make sure the existing file got fixed-up to a file URL, and that there
   // are no backslashes
-  EXPECT_TRUE(IsMatchingFileURL(URLFixerUpper::FixupRelativeFile(dir,
-      file_part).possibly_invalid_spec(), full_path));
+  EXPECT_TRUE(IsMatchingFileURL(
+      url_fixer::FixupRelativeFile(dir, file_part).possibly_invalid_spec(),
+      full_path));
   EXPECT_TRUE(base::DeleteFile(full_path, false));
 
   // create a filename we know doesn't exist and make sure it doesn't get
   // fixed up to a file URL
   base::FilePath nonexistent_file(
       FILE_PATH_LITERAL("url_fixer_upper_nonexistent_file.txt"));
-  std::string fixedup(URLFixerUpper::FixupRelativeFile(dir,
-      nonexistent_file).possibly_invalid_spec());
+  std::string fixedup(url_fixer::FixupRelativeFile(dir, nonexistent_file)
+                          .possibly_invalid_spec());
   EXPECT_NE(std::string("file:///"), fixedup.substr(0, 8));
   EXPECT_FALSE(IsMatchingFileURL(fixedup, nonexistent_file));
 
   // make a subdir to make sure relative paths with directories work, also
   // test spaces:
   // "app_dir\url fixer-upper dir\url fixer-upper existing file.txt"
   base::FilePath sub_dir(FILE_PATH_LITERAL("url fixer-upper dir"));
   base::FilePath sub_file(
       FILE_PATH_LITERAL("url fixer-upper existing file.txt"));
   base::FilePath new_dir = dir.Append(sub_dir);
   base::CreateDirectory(new_dir);
   ASSERT_TRUE(MakeTempFile(new_dir, sub_file, &full_path));
   full_path = base::MakeAbsoluteFilePath(full_path);
   ASSERT_FALSE(full_path.empty());
 
   // test file in the subdir
   base::FilePath relative_file = sub_dir.Append(sub_file);
-  EXPECT_TRUE(IsMatchingFileURL(URLFixerUpper::FixupRelativeFile(dir,
-      relative_file).possibly_invalid_spec(), full_path));
+  EXPECT_TRUE(IsMatchingFileURL(
+      url_fixer::FixupRelativeFile(dir, relative_file).possibly_invalid_spec(),
+      full_path));
 
   // test file in the subdir with different slashes and escaping.
   base::FilePath::StringType relative_file_str = sub_dir.value() +
       FILE_PATH_LITERAL("/") + sub_file.value();
   ReplaceSubstringsAfterOffset(&relative_file_str, 0,
       FILE_PATH_LITERAL(" "), FILE_PATH_LITERAL("%20"));
-  EXPECT_TRUE(IsMatchingFileURL(URLFixerUpper::FixupRelativeFile(dir,
-      base::FilePath(relative_file_str)).possibly_invalid_spec(), full_path));
+  EXPECT_TRUE(IsMatchingFileURL(
+      url_fixer::FixupRelativeFile(dir, base::FilePath(relative_file_str))
+          .possibly_invalid_spec(),
+      full_path));
 
   // test relative directories and duplicate slashes
   // (should resolve to the same file as above)
   relative_file_str = sub_dir.value() + FILE_PATH_LITERAL("/../") +
       sub_dir.value() + FILE_PATH_LITERAL("///./") + sub_file.value();
-  EXPECT_TRUE(IsMatchingFileURL(URLFixerUpper::FixupRelativeFile(dir,
-      base::FilePath(relative_file_str)).possibly_invalid_spec(), full_path));
+  EXPECT_TRUE(IsMatchingFileURL(
+      url_fixer::FixupRelativeFile(dir, base::FilePath(relative_file_str))
+          .possibly_invalid_spec(),
+      full_path));
 
   // done with the subdir
   EXPECT_TRUE(base::DeleteFile(full_path, false));
   EXPECT_TRUE(base::DeleteFile(new_dir, true));
 
   // Test that an obvious HTTP URL isn't accidentally treated as an absolute
   // file path (on account of system-specific craziness).
   base::FilePath empty_path;
   base::FilePath http_url_path(FILE_PATH_LITERAL("http://../"));
-  EXPECT_TRUE(URLFixerUpper::FixupRelativeFile(
-      empty_path, http_url_path).SchemeIs("http"));
+  EXPECT_TRUE(
+      url_fixer::FixupRelativeFile(empty_path, http_url_path).SchemeIs("http"));
 }