Clean up URL test string conversions.

url/url_canon_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 <errno.h>
 #include <stddef.h>
 
 #include "base/macros.h"
+#include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/third_party/mozilla/url_parse.h"
 #include "url/url_canon.h"
 #include "url/url_canon_internal.h"
 #include "url/url_canon_stdstring.h"
 #include "url/url_test_utils.h"
 
 namespace url {
 
-using test_utils::WStringToUTF16;
-using test_utils::ConvertUTF8ToUTF16;
-using test_utils::ConvertUTF16ToUTF8;
-
 namespace {
 
 struct ComponentCase {
   const char* input;
   const char* expected;
   Component expected_component;
   bool expected_success;
 };
 
 // ComponentCase but with dual 8-bit/16-bit input. Generally, the unit tests
@@ skipping 156 matching lines @@
                                          &output);
       }
       output.Complete();
       EXPECT_EQ(utf_cases[i].expected_success, success);
       EXPECT_EQ(std::string(utf_cases[i].output), out_str);
     }
     if (utf_cases[i].input16) {
       out_str.clear();
       StdStringCanonOutput output(&out_str);
 
-      base::string16 input_str(WStringToUTF16(utf_cases[i].input16));
+      base::string16 input_str(
+          test_utils::TruncateWStringToUTF16(utf_cases[i].input16));
       int input_len = static_cast<int>(input_str.length());
       bool success = true;
       for (int ch = 0; ch < input_len; ch++) {
         success &= AppendUTF8EscapedChar(input_str.c_str(), &ch, input_len,
                                          &output);
       }
       output.Complete();
       EXPECT_EQ(utf_cases[i].expected_success, success);
       EXPECT_EQ(std::string(utf_cases[i].output), out_str);
     }
 
     if (utf_cases[i].input8 && utf_cases[i].input16 &&
         utf_cases[i].expected_success) {
       // Check that the UTF-8 and UTF-16 inputs are equivalent.
 
       // UTF-16 -> UTF-8
       std::string input8_str(utf_cases[i].input8);
-      base::string16 input16_str(WStringToUTF16(utf_cases[i].input16));
-      EXPECT_EQ(input8_str, ConvertUTF16ToUTF8(input16_str));
+      base::string16 input16_str(
+          test_utils::TruncateWStringToUTF16(utf_cases[i].input16));
+      EXPECT_EQ(input8_str, base::UTF16ToUTF8(input16_str));
 
       // UTF-8 -> UTF-16
-      EXPECT_EQ(input16_str, ConvertUTF8ToUTF16(input8_str));
+      EXPECT_EQ(input16_str, base::UTF8ToUTF16(input8_str));
     }
   }
 }
 
 TEST(URLCanonTest, Scheme) {
   // Here, we're mostly testing that unusual characters are handled properly.
   // The canonicalizer doesn't do any parsing or whitespace detection. It will
   // also do its best on error, and will escape funny sequences (these won't be
   // valid schemes and it will return error).
   //
@@ skipping 27 matching lines @@
 
     EXPECT_EQ(scheme_cases[i].expected_success, success);
     EXPECT_EQ(std::string(scheme_cases[i].expected), out_str);
     EXPECT_EQ(scheme_cases[i].expected_component.begin, out_comp.begin);
     EXPECT_EQ(scheme_cases[i].expected_component.len, out_comp.len);
 
     // Now try the wide version.
     out_str.clear();
     StdStringCanonOutput output2(&out_str);
 
-    base::string16 wide_input(ConvertUTF8ToUTF16(scheme_cases[i].input));
+    base::string16 wide_input(base::UTF8ToUTF16(scheme_cases[i].input));
     in_comp.len = static_cast<int>(wide_input.length());
     success = CanonicalizeScheme(wide_input.c_str(), in_comp, &output2,
                                  &out_comp);
     output2.Complete();
 
     EXPECT_EQ(scheme_cases[i].expected_success, success);
     EXPECT_EQ(std::string(scheme_cases[i].expected), out_str);
     EXPECT_EQ(scheme_cases[i].expected_component.begin, out_comp.begin);
     EXPECT_EQ(scheme_cases[i].expected_component.len, out_comp.len);
   }
@@ skipping 244 matching lines @@
       EXPECT_EQ(std::string(host_cases[i].expected), out_str) <<
                 "for input: " << host_cases[i].input8;
       EXPECT_EQ(host_cases[i].expected_component.begin, out_comp.begin) <<
                 "for input: " << host_cases[i].input8;
       EXPECT_EQ(host_cases[i].expected_component.len, out_comp.len) <<
                 "for input: " << host_cases[i].input8;
     }
 
     // Wide version.
     if (host_cases[i].input16) {
-      base::string16 input16(WStringToUTF16(host_cases[i].input16));
+      base::string16 input16(
+          test_utils::TruncateWStringToUTF16(host_cases[i].input16));
       int host_len = static_cast<int>(input16.length());
       Component in_comp(0, host_len);
       Component out_comp;
 
       out_str.clear();
       StdStringCanonOutput output(&out_str);
 
       bool success = CanonicalizeHost(input16.c_str(), in_comp, &output,
                                       &out_comp);
       output.Complete();
@@ skipping 29 matching lines @@
       EXPECT_EQ(std::string(host_cases[i].expected_address_hex),
                 BytesToHexString(host_info.address, host_info.AddressLength()));
       if (host_cases[i].expected_family == CanonHostInfo::IPV4) {
         EXPECT_EQ(host_cases[i].expected_num_ipv4_components,
                   host_info.num_ipv4_components);
       }
     }
 
     // Wide version.
     if (host_cases[i].input16) {
-      base::string16 input16(WStringToUTF16(host_cases[i].input16));
+      base::string16 input16(
+          test_utils::TruncateWStringToUTF16(host_cases[i].input16));
       int host_len = static_cast<int>(input16.length());
       Component in_comp(0, host_len);
 
       out_str.clear();
       StdStringCanonOutput output(&out_str);
       CanonHostInfo host_info;
 
       CanonicalizeHostVerbose(input16.c_str(), in_comp, &output, &host_info);
       output.Complete();
 
@@ skipping 101 matching lines @@
               BytesToHexString(host_info.address, host_info.AddressLength()));
     if (host_info.family == CanonHostInfo::IPV4) {
       EXPECT_STREQ(cases[i].expected, out_str1.c_str());
       EXPECT_EQ(cases[i].expected_component.begin, host_info.out_host.begin);
       EXPECT_EQ(cases[i].expected_component.len, host_info.out_host.len);
       EXPECT_EQ(cases[i].expected_num_ipv4_components,
                 host_info.num_ipv4_components);
     }
 
     // 16-bit version.
-    base::string16 input16(WStringToUTF16(cases[i].input16));
+    base::string16 input16(
+        test_utils::TruncateWStringToUTF16(cases[i].input16));
     component = Component(0, static_cast<int>(input16.length()));
 
     std::string out_str2;
     StdStringCanonOutput output2(&out_str2);
     CanonicalizeIPAddress(input16.c_str(), component, &output2, &host_info);
     output2.Complete();
 
     EXPECT_EQ(cases[i].expected_family, host_info.family);
     EXPECT_EQ(std::string(cases[i].expected_address_hex),
               BytesToHexString(host_info.address, host_info.AddressLength()));
@@ skipping 131 matching lines @@
     EXPECT_EQ(std::string(cases[i].expected_address_hex),
               BytesToHexString(host_info.address, host_info.AddressLength())) << "iter " << i << " host " << cases[i].input8;
     if (host_info.family == CanonHostInfo::IPV6) {
       EXPECT_STREQ(cases[i].expected, out_str1.c_str());
       EXPECT_EQ(cases[i].expected_component.begin,
                 host_info.out_host.begin);
       EXPECT_EQ(cases[i].expected_component.len, host_info.out_host.len);
     }
 
     // 16-bit version.
-    base::string16 input16(WStringToUTF16(cases[i].input16));
+    base::string16 input16(
+        test_utils::TruncateWStringToUTF16(cases[i].input16));
     component = Component(0, static_cast<int>(input16.length()));
 
     std::string out_str2;
     StdStringCanonOutput output2(&out_str2);
     CanonicalizeIPAddress(input16.c_str(), component, &output2, &host_info);
     output2.Complete();
 
     EXPECT_EQ(cases[i].expected_family, host_info.family);
     EXPECT_EQ(std::string(cases[i].expected_address_hex),
               BytesToHexString(host_info.address, host_info.AddressLength()));
@@ skipping 31 matching lines @@
                                           Component(0, 12), &output));
     output.Complete();
     EXPECT_EQ("xn--mnchen-3ya.com", out_str);
   }
 
   // Failure case.
   {
     std::string out_str;
     StdStringCanonOutput output(&out_str);
     EXPECT_FALSE(CanonicalizeHostSubstring(
-        WStringToUTF16(L"\xfdd0zyx.com").c_str(), Component(0, 8), &output));
+        test_utils::TruncateWStringToUTF16(L"\xfdd0zyx.com").c_str(),
+        Component(0, 8), &output));
     output.Complete();
     EXPECT_EQ("%EF%BF%BDzyx.com", out_str);
   }
 
   // Should return true for empty input strings.
   {
     std::string out_str;
     StdStringCanonOutput output(&out_str);
     EXPECT_TRUE(CanonicalizeHostSubstring("", Component(0, 0), &output));
     output.Complete();
@@ skipping 57 matching lines @@
     EXPECT_EQ(user_info_cases[i].expected_success, success);
     EXPECT_EQ(std::string(user_info_cases[i].expected), out_str);
     EXPECT_EQ(user_info_cases[i].expected_username.begin, out_user.begin);
     EXPECT_EQ(user_info_cases[i].expected_username.len, out_user.len);
     EXPECT_EQ(user_info_cases[i].expected_password.begin, out_pass.begin);
     EXPECT_EQ(user_info_cases[i].expected_password.len, out_pass.len);
 
     // Now try the wide version
     out_str.clear();
     StdStringCanonOutput output2(&out_str);
-    base::string16 wide_input(ConvertUTF8ToUTF16(user_info_cases[i].input));
+    base::string16 wide_input(base::UTF8ToUTF16(user_info_cases[i].input));
     success = CanonicalizeUserInfo(wide_input.c_str(),
                                    parsed.username,
                                    wide_input.c_str(),
                                    parsed.password,
                                    &output2,
                                    &out_user,
                                    &out_pass);
     output2.Complete();
 
     EXPECT_EQ(user_info_cases[i].expected_success, success);
@@ skipping 42 matching lines @@
     output1.Complete();
 
     EXPECT_EQ(port_cases[i].expected_success, success);
     EXPECT_EQ(std::string(port_cases[i].expected), out_str);
     EXPECT_EQ(port_cases[i].expected_component.begin, out_comp.begin);
     EXPECT_EQ(port_cases[i].expected_component.len, out_comp.len);
 
     // Now try the wide version
     out_str.clear();
     StdStringCanonOutput output2(&out_str);
-    base::string16 wide_input(ConvertUTF8ToUTF16(port_cases[i].input));
+    base::string16 wide_input(base::UTF8ToUTF16(port_cases[i].input));
     success = CanonicalizePort(wide_input.c_str(),
                                in_comp,
                                port_cases[i].default_port,
                                &output2,
                                &out_comp);
     output2.Complete();
 
     EXPECT_EQ(port_cases[i].expected_success, success);
     EXPECT_EQ(std::string(port_cases[i].expected), out_str);
     EXPECT_EQ(port_cases[i].expected_component.begin, out_comp.begin);
@@ skipping 99 matching lines @@
           CanonicalizePath(path_cases[i].input8, in_comp, &output, &out_comp);
       output.Complete();
 
       EXPECT_EQ(path_cases[i].expected_success, success);
       EXPECT_EQ(path_cases[i].expected_component.begin, out_comp.begin);
       EXPECT_EQ(path_cases[i].expected_component.len, out_comp.len);
       EXPECT_EQ(path_cases[i].expected, out_str);
     }
 
     if (path_cases[i].input16) {
-      base::string16 input16(WStringToUTF16(path_cases[i].input16));
+      base::string16 input16(
+          test_utils::TruncateWStringToUTF16(path_cases[i].input16));
       int len = static_cast<int>(input16.length());
       Component in_comp(0, len);
       Component out_comp;
       std::string out_str;
       StdStringCanonOutput output(&out_str);
 
       bool success =
           CanonicalizePath(input16.c_str(), in_comp, &output, &out_comp);
       output.Complete();
 
@@ skipping 54 matching lines @@
 
       StdStringCanonOutput output(&out_str);
       CanonicalizeQuery(query_cases[i].input8, in_comp, NULL, &output,
                         &out_comp);
       output.Complete();
 
       EXPECT_EQ(query_cases[i].expected, out_str);
     }
 
     if (query_cases[i].input16) {
-      base::string16 input16(WStringToUTF16(query_cases[i].input16));
+      base::string16 input16(
+          test_utils::TruncateWStringToUTF16(query_cases[i].input16));
       int len = static_cast<int>(input16.length());
       Component in_comp(0, len);
       std::string out_str;
 
       StdStringCanonOutput output(&out_str);
       CanonicalizeQuery(input16.c_str(), in_comp, NULL, &output, &out_comp);
       output.Complete();
 
       EXPECT_EQ(query_cases[i].expected, out_str);
     }
@@ skipping 41 matching lines @@
       CanonicalizeRef(ref_cases[i].input8, in_comp, &output, &out_comp);
       output.Complete();
 
       EXPECT_EQ(ref_cases[i].expected_component.begin, out_comp.begin);
       EXPECT_EQ(ref_cases[i].expected_component.len, out_comp.len);
       EXPECT_EQ(ref_cases[i].expected, out_str);
     }
 
     // 16-bit input
     if (ref_cases[i].input16) {
-      base::string16 input16(WStringToUTF16(ref_cases[i].input16));
+      base::string16 input16(
+          test_utils::TruncateWStringToUTF16(ref_cases[i].input16));
       int len = static_cast<int>(input16.length());
       Component in_comp(0, len);
       Component out_comp;
 
       std::string out_str;
       StdStringCanonOutput output(&out_str);
       CanonicalizeRef(input16.c_str(), in_comp, &output, &out_comp);
       output.Complete();
 
       EXPECT_EQ(ref_cases[i].expected_component.begin, out_comp.begin);
@@ skipping 615 matching lines @@
 
 TEST(URLCanonTest, _itow_s) {
   // We fill the buffer with 0xff to ensure that it's getting properly
   // null-terminated. We also allocate one byte more than what we tell
   // _itoa_s about, and ensure that the extra byte is untouched.
   base::char16 buf[6];
   const char fill_mem = 0xff;
   const base::char16 fill_char = 0xffff;
   memset(buf, fill_mem, sizeof(buf));
   EXPECT_EQ(0, _itow_s(12, buf, sizeof(buf) / 2 - 1, 10));
-  EXPECT_EQ(WStringToUTF16(L"12"), base::string16(buf));
+  EXPECT_EQ(base::UTF8ToUTF16("12"), base::string16(buf));
   EXPECT_EQ(fill_char, buf[3]);
 
   // Test the edge cases - exactly the buffer size and one over
   EXPECT_EQ(0, _itow_s(1234, buf, sizeof(buf) / 2 - 1, 10));
-  EXPECT_EQ(WStringToUTF16(L"1234"), base::string16(buf));
+  EXPECT_EQ(base::UTF8ToUTF16("1234"), base::string16(buf));
   EXPECT_EQ(fill_char, buf[5]);
 
   memset(buf, fill_mem, sizeof(buf));
   EXPECT_EQ(EINVAL, _itow_s(12345, buf, sizeof(buf) / 2 - 1, 10));
   EXPECT_EQ(fill_char, buf[5]);  // should never write to this location
 
   // Test the template overload (note that this will see the full buffer)
   memset(buf, fill_mem, sizeof(buf));
   EXPECT_EQ(0, _itow_s(12, buf, 10));
-  EXPECT_EQ(WStringToUTF16(L"12"), base::string16(buf));
+  EXPECT_EQ(base::UTF8ToUTF16("12"),
+            base::string16(buf));
   EXPECT_EQ(fill_char, buf[3]);
 
   memset(buf, fill_mem, sizeof(buf));
   EXPECT_EQ(0, _itow_s(12345, buf, 10));
-  EXPECT_EQ(WStringToUTF16(L"12345"), base::string16(buf));
+  EXPECT_EQ(base::UTF8ToUTF16("12345"), base::string16(buf));
 
   EXPECT_EQ(EINVAL, _itow_s(123456, buf, 10));
 }
 
 #endif  // !WIN32
 
 // Returns true if the given two structures are the same.
 static bool ParsedIsEqual(const Parsed& a, const Parsed& b) {
   return a.scheme.begin == b.scheme.begin && a.scheme.len == b.scheme.len &&
          a.username.begin == b.username.begin && a.username.len == b.username.len &&
@@ skipping 215 matching lines @@
   Parsed parsed;
   ParseFileURL(src, src_len, &parsed);
 
   // Override two components, the path with something short, and the query with
   // something long enough to trigger the bug.
   Replacements<base::char16> repl;
   base::string16 new_query;
   for (int i = 0; i < 4800; i++)
     new_query.push_back('a');
 
-  base::string16 new_path(WStringToUTF16(L"/foo"));
+  base::string16 new_path(test_utils::TruncateWStringToUTF16(L"/foo"));
   repl.SetPath(new_path.c_str(), Component(0, 4));
   repl.SetQuery(new_query.c_str(),
                 Component(0, static_cast<int>(new_query.length())));
 
   // Call ReplaceComponents on the string. It doesn't matter if we call it for
   // standard URLs, file URLs, etc, since they will go to the same replacement
   // function that was buggy.
   Parsed repl_parsed;
   std::string repl_str;
   StdStringCanonOutput repl_output(&repl_str);
@@ skipping 32 matching lines @@
   };
 
   for (auto& test_case : cases) {
     SCOPED_TRACE(test_case.scheme);
     EXPECT_EQ(test_case.expected_port,
               DefaultPortForScheme(test_case.scheme, strlen(test_case.scheme)));
   }
 }
 
 }  // namespace url