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

net/base/escape.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 "net/base/escape.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
@@ skipping 87 matching lines @@
      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0
 };
 
 template<typename STR>
 STR UnescapeURLWithOffsetsImpl(const STR& escaped_text,
                                UnescapeRule::Type rules,
                                std::vector<size_t>* offsets_for_adjustment) {
   if (offsets_for_adjustment) {
     std::for_each(offsets_for_adjustment->begin(),
                   offsets_for_adjustment->end(),
-                  LimitOffset<std::wstring>(escaped_text.length()));
+                  LimitOffset<STR>(escaped_text.length()));
   }
   // Do not unescape anything, return the |escaped_text| text.
   if (rules == UnescapeRule::NONE)
     return escaped_text;
 
   // The output of the unescaping is always smaller than the input, so we can
   // reserve the input size to make sure we have enough buffer and don't have
   // to allocate in the loop below.
   STR result;
   result.reserve(escaped_text.length());
@@ skipping 51 matching lines @@
   // Make offset adjustment.
   if (offsets_for_adjustment && !adjustments.empty()) {
     std::for_each(offsets_for_adjustment->begin(),
                    offsets_for_adjustment->end(),
                    AdjustEncodingOffset(adjustments));
   }
 
   return result;
 }
 
-template<typename STR>
-STR UnescapeURLImpl(const STR& escaped_text,
-                    UnescapeRule::Type rules,
-                    size_t* offset_for_adjustment) {
-  std::vector<size_t> offsets;
-  if (offset_for_adjustment)
-    offsets.push_back(*offset_for_adjustment);
-  STR result = UnescapeURLWithOffsetsImpl(escaped_text, rules, &offsets);
-  if (offset_for_adjustment)
-    *offset_for_adjustment = offsets[0];
-  return result;
-}
-
 }  // namespace
 
 // Everything except alphanumerics and !'()*-._~
 // See RFC 2396 for the list of reserved characters.
 static const Charmap kQueryCharmap(
   0xffffffffL, 0xfc00987dL, 0x78000001L, 0xb8000001L,
   0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL);
 
 std::string EscapeQueryParamValue(const std::string& text, bool use_plus) {
   return Escape(text, kQueryCharmap, use_plus);
@@ skipping 41 matching lines @@
   0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL);
 
 std::string EscapeExternalHandlerValue(const std::string& text) {
   return Escape(text, kExternalHandlerCharmap, false);
 }
 
 string16 UnescapeAndDecodeUTF8URLComponentWithOffsets(
     const std::string& text,
     UnescapeRule::Type rules,
     std::vector<size_t>* offsets_for_adjustment) {
-  std::wstring result;
+  string16 result;
   std::vector<size_t> original_offsets;
   if (offsets_for_adjustment)
     original_offsets = *offsets_for_adjustment;
   std::string unescaped_url(
       UnescapeURLWithOffsetsImpl(text, rules, offsets_for_adjustment));
-  if (UTF8ToWideAndAdjustOffsets(unescaped_url.data(), unescaped_url.length(),
-                                &result, offsets_for_adjustment))
-    return WideToUTF16Hack(result);      // Character set looks like it's valid.
+  if (UTF8ToUTF16AndAdjustOffsets(unescaped_url.data(), unescaped_url.length(),
+                                  &result, offsets_for_adjustment))
+    return result;  // Character set looks like it's valid.
 
   // Not valid.  Return the escaped version.  Undo our changes to
   // |offset_for_adjustment| since we haven't changed the string after all.
   if (offsets_for_adjustment)
     *offsets_for_adjustment = original_offsets;
-  return WideToUTF16Hack(UTF8ToWideAndAdjustOffsets(
-      text, offsets_for_adjustment));
+  return UTF8ToUTF16AndAdjustOffsets(text, offsets_for_adjustment);
 }
 
 string16 UnescapeAndDecodeUTF8URLComponent(const std::string& text,
                                            UnescapeRule::Type rules,
                                            size_t* offset_for_adjustment) {
   std::vector<size_t> offsets;
   if (offset_for_adjustment)
     offsets.push_back(*offset_for_adjustment);
   string16 result =
       UnescapeAndDecodeUTF8URLComponentWithOffsets(text, rules, &offsets);
   if (offset_for_adjustment)
     *offset_for_adjustment = offsets[0];
   return result;
 }
 
 std::string UnescapeURLComponent(const std::string& escaped_text,
                                  UnescapeRule::Type rules) {
-  return UnescapeURLWithOffsetsImpl<std::string>(escaped_text, rules, NULL);
+  return UnescapeURLWithOffsetsImpl(escaped_text, rules, NULL);
 }
 
 string16 UnescapeURLComponent(const string16& escaped_text,
                               UnescapeRule::Type rules) {
-  return UnescapeURLWithOffsetsImpl<string16>(escaped_text, rules, NULL);
+  return UnescapeURLWithOffsetsImpl(escaped_text, rules, NULL);
 }
 
 
 template <class str>
 void AppendEscapedCharForHTMLImpl(typename str::value_type c, str* output) {
   static const struct {
     char key;
     const char* replacement;
   } kCharsToEscape[] = {
     { '<', "&lt;" },
@@ skipping 12 matching lines @@
     }
   }
   if (k == ARRAYSIZE_UNSAFE(kCharsToEscape))
     output->push_back(c);
 }
 
 void AppendEscapedCharForHTML(char c, std::string* output) {
   AppendEscapedCharForHTMLImpl(c, output);
 }
 
-void AppendEscapedCharForHTML(wchar_t c, string16* output) {
-  AppendEscapedCharForHTMLImpl(c, output);
-}
-
 template <class str>
 str EscapeForHTMLImpl(const str& input) {
   str result;
   result.reserve(input.size());  // optimize for no escaping
 
   for (typename str::const_iterator it = input.begin(); it != input.end(); ++it)
     AppendEscapedCharForHTMLImpl(*it, &result);
 
   return result;
 }
 
 std::string EscapeForHTML(const std::string& input) {
   return EscapeForHTMLImpl(input);
 }
 
 string16 EscapeForHTML(const string16& input) {
   return EscapeForHTMLImpl(input);
 }
 
 string16 UnescapeForHTML(const string16& input) {
   static const struct {
-    const wchar_t* ampersand_code;
+    const char* ampersand_code;
     const char replacement;
   } kEscapeToChars[] = {
-    { L"&lt;", '<' },
-    { L"&gt;", '>' },
-    { L"&amp;", '&' },
-    { L"&quot;", '"' },
-    { L"&#39;", '\''},
+    { "&lt;", '<' },
+    { "&gt;", '>' },
+    { "&amp;", '&' },
+    { "&quot;", '"' },
+    { "&#39;", '\''},
   };
 
-  if (input.find(WideToUTF16(L"&")) == std::string::npos)
+  if (input.find(ASCIIToUTF16("&")) == std::string::npos)
     return input;
 
   string16 ampersand_chars[ARRAYSIZE_UNSAFE(kEscapeToChars)];
   string16 text(input);
   for (string16::iterator iter = text.begin(); iter != text.end(); ++iter) {
     if (*iter == '&') {
       // Potential ampersand encode char.
       size_t index = iter - text.begin();
       for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kEscapeToChars); i++) {
         if (ampersand_chars[i].empty())
-          ampersand_chars[i] = WideToUTF16(kEscapeToChars[i].ampersand_code);
+          ampersand_chars[i] = ASCIIToUTF16(kEscapeToChars[i].ampersand_code);
         if (text.find(ampersand_chars[i], index) == index) {
           text.replace(iter, iter + ampersand_chars[i].length(),
                        1, kEscapeToChars[i].replacement);
           break;
         }
       }
     }
   }
   return text;
 }
@@ skipping 14 matching lines @@
       return;
     }
     if (offset <= (location + 2)) {
       offset = string16::npos;
       return;
     }
     adjusted_offset -= 2;
   }
   offset = adjusted_offset;
 }