Eliminate wstring from base/utf_offset_string_conversions.h, net/base/escape.h, and net/base/net_...

net/base/escape_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 <algorithm>
 #include <string>
 
 #include "net/base/escape.h"
 
 #include "base/basictypes.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 static const size_t kNpos = string16::npos;
 
 struct EscapeCase {
-  const wchar_t* input;
-  const wchar_t* output;
+  const char* input;
+  const char* output;
 };
 
 struct UnescapeURLCase {
   const wchar_t* input;
   UnescapeRule::Type rules;
   const wchar_t* output;
 };
 
 struct UnescapeURLCaseASCII {
   const char* input;
@@ skipping 22 matching lines @@
 
 struct EscapeForHTMLCase {
   const char* input;
   const char* expected_output;
 };
 
 }  // namespace
 
 TEST(EscapeTest, EscapeTextForFormSubmission) {
   const EscapeCase escape_cases[] = {
-    {L"foo", L"foo"},
-    {L"foo bar", L"foo+bar"},
-    {L"foo++", L"foo%2B%2B"}
+    {"foo", "foo"},
+    {"foo bar", "foo+bar"},
+    {"foo++", "foo%2B%2B"}
   };
   for (size_t i = 0; i < arraysize(escape_cases); ++i) {
     EscapeCase value = escape_cases[i];
-    EXPECT_EQ(WideToUTF16Hack(value.output),
-              EscapeQueryParamValueUTF8(WideToUTF16Hack(value.input), true));
+    EXPECT_EQ(UTF8ToUTF16(value.output),
+              EscapeQueryParamValueUTF8(UTF8ToUTF16(value.input), true));
   }
 
   const EscapeCase escape_cases_no_plus[] = {
-    {L"foo", L"foo"},
-    {L"foo bar", L"foo%20bar"},
-    {L"foo++", L"foo%2B%2B"}
+    {"foo", "foo"},
+    {"foo bar", "foo%20bar"},
+    {"foo++", "foo%2B%2B"}
   };
   for (size_t i = 0; i < arraysize(escape_cases_no_plus); ++i) {
     EscapeCase value = escape_cases_no_plus[i];
-    EXPECT_EQ(WideToUTF16Hack(value.output),
-              EscapeQueryParamValueUTF8(WideToUTF16Hack(value.input), false));
+    EXPECT_EQ(ASCIIToUTF16(value.output),
+              EscapeQueryParamValueUTF8(ASCIIToUTF16(value.input), false));
   }
 
   // Test all the values in we're supposed to be escaping.
   const std::string no_escape(
     "abcdefghijklmnopqrstuvwxyz"
     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     "0123456789"
     "!'()*-._~");
   for (int i = 0; i < 256; ++i) {
     std::string in;
@@ skipping 14 matching lines @@
     }
   }
 
   // Check to see if EscapeQueryParamValueUTF8 is the same as
   // EscapeQueryParamValue(..., kCodepageUTF8,)
   string16 test_str;
   test_str.reserve(5000);
   for (int i = 1; i < 5000; ++i) {
     test_str.push_back(i);
   }
-  string16 wide;
+  string16 utf16;
   EXPECT_TRUE(EscapeQueryParamValue(test_str, base::kCodepageUTF8, true,
-                                    &wide));
-  EXPECT_EQ(wide, EscapeQueryParamValueUTF8(test_str, true));
+                                    &utf16));
+  EXPECT_EQ(utf16, EscapeQueryParamValueUTF8(test_str, true));
   EXPECT_TRUE(EscapeQueryParamValue(test_str, base::kCodepageUTF8, false,
-                                    &wide));
-  EXPECT_EQ(wide, EscapeQueryParamValueUTF8(test_str, false));
+                                    &utf16));
+  EXPECT_EQ(utf16, EscapeQueryParamValueUTF8(test_str, false));
 }
 
 TEST(EscapeTest, EscapePath) {
   ASSERT_EQ(
     // Most of the character space we care about, un-escaped
     EscapePath(
       "\x02\n\x1d !\"#$%&'()*+,-./0123456789:;"
       "<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
       "[\\]^_`abcdefghijklmnopqrstuvwxyz"
       "{|}~\x7f\x80\xff"),
@@ skipping 38 matching lines @@
      UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS,
      "Some random text %-OK"},
     {"%A0%B1%C2%D3%E4%F5", UnescapeRule::NORMAL, "\xA0\xB1\xC2\xD3\xE4\xF5"},
     {"%Aa%Bb%Cc%Dd%Ee%Ff", UnescapeRule::NORMAL, "\xAa\xBb\xCc\xDd\xEe\xFf"},
     // Certain URL-sensitive characters should not be unescaped unless asked.
     {"Hello%20%13%10world %23# %3F? %3D= %26& %25% %2B+", UnescapeRule::SPACES,
      "Hello %13%10world %23# %3F? %3D= %26& %25% %2B+"},
     {"Hello%20%13%10world %23# %3F? %3D= %26& %25% %2B+",
      UnescapeRule::URL_SPECIAL_CHARS,
      "Hello%20%13%10world ## ?? == && %% ++"},
+    // We can neither escape nor unescape '@' since some websites expect it to
+    // be preserved as either '@' or "%40".
+    // See http://b/996720 and http://crbug.com/23933 .
+    {"me@my%40example", UnescapeRule::NORMAL, "me@my%40example"},
     // Control characters.
     {"%01%02%03%04%05%06%07%08%09 %25", UnescapeRule::URL_SPECIAL_CHARS,
      "%01%02%03%04%05%06%07%08%09 %"},
     {"%01%02%03%04%05%06%07%08%09 %25", UnescapeRule::CONTROL_CHARS,
      "\x01\x02\x03\x04\x05\x06\x07\x08\x09 %25"},
     {"Hello%20%13%10%02", UnescapeRule::SPACES, "Hello %13%10%02"},
     {"Hello%20%13%10%02", UnescapeRule::CONTROL_CHARS, "Hello%20\x13\x10\x02"},
   };
 
   for (size_t i = 0; i < arraysize(unescape_cases); i++) {
@@ skipping 139 matching lines @@
                                                  UnescapeRule::NORMAL);
     EXPECT_EQ(std::string(unescape_cases[i].url_unescaped), unescaped);
 
     unescaped = UnescapeURLComponent(unescape_cases[i].input,
                                      UnescapeRule::REPLACE_PLUS_WITH_SPACE);
     EXPECT_EQ(std::string(unescape_cases[i].query_unescaped), unescaped);
 
     // TODO: Need to test unescape_spaces and unescape_percent.
     string16 decoded = UnescapeAndDecodeUTF8URLComponent(
         unescape_cases[i].input, UnescapeRule::NORMAL, NULL);
-    EXPECT_EQ(WideToUTF16Hack(std::wstring(unescape_cases[i].decoded)),
-              decoded);
+    EXPECT_EQ(WideToUTF16(unescape_cases[i].decoded), decoded);
   }
 }
 
 TEST(EscapeTest, AdjustOffset) {
   const AdjustOffsetCase adjust_cases[] = {
-    {"", 0, std::wstring::npos},
+    {"", 0, std::string::npos},
     {"test", 0, 0},
     {"test", 2, 2},
-    {"test", 4, std::wstring::npos},
-    {"test", std::wstring::npos, std::wstring::npos},
+    {"test", 4, std::string::npos},
+    {"test", std::string::npos, std::string::npos},
     {"%2dtest", 6, 4},
-    {"%2dtest", 2, std::wstring::npos},
+    {"%2dtest", 2, std::string::npos},
     {"test%2d", 2, 2},
     {"%E4%BD%A0+%E5%A5%BD", 9, 1},
-    {"%E4%BD%A0+%E5%A5%BD", 6, std::wstring::npos},
+    {"%E4%BD%A0+%E5%A5%BD", 6, std::string::npos},
     {"%ED%B0%80+%E5%A5%BD", 6, 6},
   };
 
   for (size_t i = 0; i < arraysize(adjust_cases); i++) {
     size_t offset = adjust_cases[i].input_offset;
     UnescapeAndDecodeUTF8URLComponent(adjust_cases[i].input,
                                       UnescapeRule::NORMAL, &offset);
     EXPECT_EQ(adjust_cases[i].output_offset, offset);
   }
 }
@@ skipping 58 matching lines @@
   adjustments.push_back(9);
   adjustments.push_back(15);
   std::for_each(offsets.begin(), offsets.end(),
                 AdjustEncodingOffset(adjustments));
   size_t expected_2[] = {0, kNpos, kNpos, 1, 2, 3, 4, kNpos, kNpos, 5, kNpos,
                          kNpos, 6, 7, 8, 9, kNpos, kNpos};
   EXPECT_EQ(offsets.size(), arraysize(expected_2));
   for (size_t i = 0; i < arraysize(expected_2); ++i)
     EXPECT_EQ(expected_2[i], offsets[i]);
 }