Clean up URL test string conversions.

url/gurl_unittest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include "base/macros.h"
+#include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/url_canon.h"
 #include "url/url_test_utils.h"
 
 namespace url {
 
-using test_utils::WStringToUTF16;
-using test_utils::ConvertUTF8ToUTF16;
-
 namespace {
 
 template<typename CHAR>
 void SetupReplacement(
     void (Replacements<CHAR>::*func)(const CHAR*, const Component&),
     Replacements<CHAR>* replacements,
     const CHAR* str) {
   if (str) {
     Component comp;
     if (str[0])
@@ skipping 32 matching lines @@
   EXPECT_EQ("file:///Z:/foo.txt", TypesTestCase("Z|foo.txt"));
   EXPECT_EQ("file://server/foo.txt", TypesTestCase("\\\\server\\foo.txt"));
   EXPECT_EQ("file://server/foo.txt", TypesTestCase("//server/foo.txt"));
 #endif
 }
 
 // Test the basic creation and querying of components in a GURL. We assume that
 // the parser is already tested and works, so we are mostly interested if the
 // object does the right thing with the results.
 TEST(GURLTest, Components) {
-  GURL empty_url(WStringToUTF16(L""));
+  GURL empty_url(base::UTF8ToUTF16(""));
   EXPECT_TRUE(empty_url.is_empty());
   EXPECT_FALSE(empty_url.is_valid());
 
-  GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref"));
+  GURL url(base::UTF8ToUTF16("http://user:pass@google.com:99/foo;bar?q=a#ref"));
   EXPECT_FALSE(url.is_empty());
   EXPECT_TRUE(url.is_valid());
   EXPECT_TRUE(url.SchemeIs("http"));
   EXPECT_FALSE(url.SchemeIsFile());
 
   // This is the narrow version of the URL, which should match the wide input.
   EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url.spec());
 
   EXPECT_EQ("http", url.scheme());
   EXPECT_EQ("user", url.username());
@@ skipping 24 matching lines @@
   EXPECT_EQ("", url.password());
   EXPECT_EQ("", url.host());
   EXPECT_EQ("", url.port());
   EXPECT_EQ(PORT_UNSPECIFIED, url.IntPort());
   EXPECT_EQ("", url.path());
   EXPECT_EQ("", url.query());
   EXPECT_EQ("", url.ref());
 }
 
 TEST(GURLTest, Copy) {
-  GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref"));
+  GURL url(base::UTF8ToUTF16(
+      "http://user:pass@google.com:99/foo;bar?q=a#ref"));
 
   GURL url2(url);
   EXPECT_TRUE(url2.is_valid());
 
   EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url2.spec());
   EXPECT_EQ("http", url2.scheme());
   EXPECT_EQ("user", url2.username());
   EXPECT_EQ("pass", url2.password());
   EXPECT_EQ("google.com", url2.host());
   EXPECT_EQ("99", url2.port());
@@ skipping 12 matching lines @@
   EXPECT_EQ("", invalid2.password());
   EXPECT_EQ("", invalid2.host());
   EXPECT_EQ("", invalid2.port());
   EXPECT_EQ(PORT_UNSPECIFIED, invalid2.IntPort());
   EXPECT_EQ("", invalid2.path());
   EXPECT_EQ("", invalid2.query());
   EXPECT_EQ("", invalid2.ref());
 }
 
 TEST(GURLTest, Assign) {
-  GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref"));
+  GURL url(base::UTF8ToUTF16(
+      "http://user:pass@google.com:99/foo;bar?q=a#ref"));
 
   GURL url2;
   url2 = url;
   EXPECT_TRUE(url2.is_valid());
 
   EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url2.spec());
   EXPECT_EQ("http", url2.scheme());
   EXPECT_EQ("user", url2.username());
   EXPECT_EQ("pass", url2.password());
   EXPECT_EQ("google.com", url2.host());
@@ skipping 21 matching lines @@
 }
 
 // This is a regression test for http://crbug.com/309975.
 TEST(GURLTest, SelfAssign) {
   GURL a("filesystem:http://example.com/temporary/");
   // This should not crash.
   a = a;
 }
 
 TEST(GURLTest, CopyFileSystem) {
-  GURL url(WStringToUTF16(L"filesystem:https://user:pass@google.com:99/t/foo;bar?q=a#ref"));
+  GURL url(base::UTF8ToUTF16(
+      "filesystem:https://user:pass@google.com:99/t/foo;bar?q=a#ref"));
 
   GURL url2(url);
   EXPECT_TRUE(url2.is_valid());
 
   EXPECT_EQ("filesystem:https://user:pass@google.com:99/t/foo;bar?q=a#ref", url2.spec());
   EXPECT_EQ("filesystem", url2.scheme());
   EXPECT_EQ("", url2.username());
   EXPECT_EQ("", url2.password());
   EXPECT_EQ("", url2.host());
   EXPECT_EQ("", url2.port());
@@ skipping 101 matching lines @@
 
   for (size_t i = 0; i < arraysize(resolve_cases); i++) {
     // 8-bit code path.
     GURL input(resolve_cases[i].base);
     GURL output = input.Resolve(resolve_cases[i].relative);
     EXPECT_EQ(resolve_cases[i].expected_valid, output.is_valid()) << i;
     EXPECT_EQ(resolve_cases[i].expected, output.spec()) << i;
     EXPECT_EQ(output.SchemeIsFileSystem(), output.inner_url() != NULL);
 
     // Wide code path.
-    GURL inputw(ConvertUTF8ToUTF16(resolve_cases[i].base));
+    GURL inputw(base::UTF8ToUTF16(resolve_cases[i].base));
     GURL outputw =
-        input.Resolve(ConvertUTF8ToUTF16(resolve_cases[i].relative));
+        input.Resolve(base::UTF8ToUTF16(resolve_cases[i].relative));
     EXPECT_EQ(resolve_cases[i].expected_valid, outputw.is_valid()) << i;
     EXPECT_EQ(resolve_cases[i].expected, outputw.spec()) << i;
     EXPECT_EQ(outputw.SchemeIsFileSystem(), outputw.inner_url() != NULL);
   }
 }
 
 TEST(GURLTest, GetOrigin) {
   struct TestCase {
     const char* input;
     const char* expected;
@@ skipping 403 matching lines @@
   };
 
   for (const auto& test : cases) {
     GURL url(test.url);
     EXPECT_EQ(test.expected, url.path()) << test.url;
     EXPECT_EQ(test.expected, url.GetContent()) << test.url;
   }
 }
 
 }  // namespace url