Update uses of UTF conversions in courgette/, device/, extensions/, google_apis/, gpu/, ipc/, media…

net/base/escape_unittest.cc

 // Copyright (c) 2012 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"
@@ skipping 232 matching lines @@
     {L"%01%02%03%04%05%06%07%08%09 %25", UnescapeRule::CONTROL_CHARS,
      L"\x01\x02\x03\x04\x05\x06\x07\x08\x09 %25"},
     {L"Hello%20%13%10%02", UnescapeRule::SPACES, L"Hello %13%10%02"},
     {L"Hello%20%13%10%02", UnescapeRule::CONTROL_CHARS,
      L"Hello%20\x13\x10\x02"},
     {L"Hello\x9824\x9827", UnescapeRule::CONTROL_CHARS,
      L"Hello\x9824\x9827"},
   };
 
   for (size_t i = 0; i < arraysize(unescape_cases); i++) {
-    base::string16 str(WideToUTF16(unescape_cases[i].input));
-    EXPECT_EQ(WideToUTF16(unescape_cases[i].output),
+    base::string16 str(base::WideToUTF16(unescape_cases[i].input));
+    EXPECT_EQ(base::WideToUTF16(unescape_cases[i].output),
               UnescapeURLComponent(str, unescape_cases[i].rules));
   }
 
   // Test the NULL character unescaping (which wouldn't work above since those
   // are just char pointers).
-  base::string16 input(WideToUTF16(L"Null"));
+  base::string16 input(base::WideToUTF16(L"Null"));
   input.push_back(0);  // Also have a NULL in the input.
-  input.append(WideToUTF16(L"%00%39Test"));
+  input.append(base::WideToUTF16(L"%00%39Test"));
 
   // When we're unescaping NULLs
-  base::string16 expected(WideToUTF16(L"Null"));
+  base::string16 expected(base::WideToUTF16(L"Null"));
   expected.push_back(0);
   expected.push_back(0);
-  expected.append(ASCIIToUTF16("9Test"));
+  expected.append(base::ASCIIToUTF16("9Test"));
   EXPECT_EQ(expected, UnescapeURLComponent(input, UnescapeRule::CONTROL_CHARS));
 
   // When we're not unescaping NULLs.
-  expected = WideToUTF16(L"Null");
+  expected = base::WideToUTF16(L"Null");
   expected.push_back(0);
-  expected.append(WideToUTF16(L"%009Test"));
+  expected.append(base::WideToUTF16(L"%009Test"));
   EXPECT_EQ(expected, UnescapeURLComponent(input, UnescapeRule::NORMAL));
 }
 
 TEST(EscapeTest, UnescapeAndDecodeUTF8URLComponent) {
   const UnescapeAndDecodeCase unescape_cases[] = {
     { "%",
       "%",
       "%",
      L"%"},
     { "+",
@@ skipping 39 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.
     base::string16 decoded = UnescapeAndDecodeUTF8URLComponent(
         unescape_cases[i].input, UnescapeRule::NORMAL, NULL);
-    EXPECT_EQ(WideToUTF16(unescape_cases[i].decoded), decoded);
+    EXPECT_EQ(base::WideToUTF16(unescape_cases[i].decoded), decoded);
   }
 }
 
 TEST(EscapeTest, AdjustOffset) {
   const AdjustOffsetCase adjust_cases[] = {
     {"", 0, 0},
     {"", 1, std::string::npos},
     {"test", 0, 0},
     {"test", 2, 2},
     {"test", 4, 4},
@@ skipping 35 matching lines @@
     { "&lt;&gt;&amp;&quot;&#39;", "<>&\"'" },
     { "& lt; &amp ; &; '", "& lt; &amp ; &; '" },
     { "&amp;", "&" },
     { "&quot;", "\"" },
     { "&#39;", "'" },
     { "&lt;", "<" },
     { "&gt;", ">" },
     { "&amp; &", "& &" },
   };
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    base::string16 result = UnescapeForHTML(ASCIIToUTF16(tests[i].input));
-    EXPECT_EQ(ASCIIToUTF16(tests[i].expected_output), result);
+    base::string16 result = UnescapeForHTML(base::ASCIIToUTF16(tests[i].input));
+    EXPECT_EQ(base::ASCIIToUTF16(tests[i].expected_output), result);
   }
 }
 
 TEST(EscapeTest, AdjustEncodingOffset) {
   // Imagine we have strings as shown in the following cases where the
   // %XX's represent encoded characters
 
   // 1: abc%ECdef ==> abcXdef
   std::vector<size_t> offsets;
   for (size_t t = 0; t < 9; ++t)
@@ skipping 21 matching lines @@
                 internal::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]);
 }
 
 }  // namespace
 }  // namespace net