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

net/base/net_util.h

 // 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.
 
 #ifndef NET_BASE_NET_UTIL_H_
 #define NET_BASE_NET_UTIL_H_
 #pragma once
 
 #include "build/build_config.h"
 
@@ skipping 117 matching lines @@
 void GetIdentityFromURL(const GURL& url,
                         string16* username,
                         string16* password);
 
 // Returns either the host from |url|, or, if the host is empty, the full spec.
 std::string GetHostOrSpecFromURL(const GURL& url);
 
 // Return the value of the HTTP response header with name 'name'.  'headers'
 // should be in the format that URLRequest::GetResponseHeaders() returns.
 // Returns the empty string if the header is not found.
-std::wstring GetSpecificHeader(const std::wstring& headers,
-                               const std::wstring& name);
 std::string GetSpecificHeader(const std::string& headers,
                               const std::string& name);
 
 // Return the value of the HTTP response header field's parameter named
 // 'param_name'.  Returns the empty string if the parameter is not found or is
 // improperly formatted.
-std::wstring GetHeaderParamValue(const std::wstring& field,
-                                 const std::wstring& param_name,
-                                 QuoteRule::Type quote_rule);
-std::string GetHeaderParamValue(const std::string& field,
+std::string GetHeaderParamValue(const std::string& header,
                                 const std::string& param_name,
                                 QuoteRule::Type quote_rule);
 
 // Return the filename extracted from Content-Disposition header. The following
 // formats are tried in order listed below:
 //
 // 1. RFC 5987
 // 2. RFC 2047
 // 3. Raw-8bit-characters :
 //    a. UTF-8, b. referrer_charset, c. default os codepage.
@@ skipping 30 matching lines @@
 // designed to work on the substring of the host out of a URL spec).
 //
 // |languages| is a comma separated list of ISO 639 language codes. It
 // is used to determine whether a hostname is 'comprehensible' to a user
 // who understands languages listed. |host| will be converted to a
 // human-readable form (Unicode) ONLY when each component of |host| is
 // regarded as 'comprehensible'. Scipt-mixing is not allowed except that
 // Latin letters in the ASCII range can be mixed with a limited set of
 // script-language pairs (currently Han, Kana and Hangul for zh,ja and ko).
 // When |languages| is empty, even that mixing is not allowed.
-//
-// (|offset[s]_for_adjustment|) specifies one or more offsets into the original
-// |url|'s spec(); each offset will be adjusted to point at the same logical
-// place in the result strings during decoding.  If this isn't possible because
-// an offset points past the end of |host| or into the middle of a punycode
-// sequence, the offending offset will be set to std::wstring::npos.
-// |offset[s]_for_adjustment| may be NULL.
-std::wstring IDNToUnicode(const char* host,
-                          size_t host_len,
-                          const std::wstring& languages,
-                          size_t* offset_for_adjustment);
-std::wstring IDNToUnicodeWithOffsets(
-    const char* host,
-    size_t host_len,
-    const std::wstring& languages,
-    std::vector<size_t>* offsets_for_adjustment);
+string16 IDNToUnicode(const char* host,
+                      size_t host_len,
+                      const std::string& languages);
 
 // Canonicalizes |host| and returns it.  Also fills |host_info| with
 // IP address information.  |host_info| must not be NULL.
 std::string CanonicalizeHost(const std::string& host,
                              url_canon::CanonHostInfo* host_info);
-std::string CanonicalizeHost(const std::wstring& host,
-                             url_canon::CanonHostInfo* host_info);
 
 // Returns true if |host| is not an IP address and is compliant with a set of
 // rules based on RFC 1738 and tweaked to be compatible with the real world.
 // The rules are:
 //   * One or more components separated by '.'
 //   * Each component begins and ends with an alphanumeric character
 //   * Each component contains only alphanumeric characters and '-' or '_'
 //   * The last component does not begin with a digit
 //   * Optional trailing dot after last component (means "treat as FQDN")
 // If |desired_tld| is non-NULL, the host will only be considered invalid if
@@ skipping 64 matching lines @@
 // Appends the given part of the original URL to the output string formatted for
 // the user. The given parsed structure will be updated. The host name formatter
 // also takes the same accept languages component as ElideURL. |new_parsed| may
 // be null.
 //
 // (|offset[s]_for_adjustment|) specifies one or more offsets into the original
 // |url|'s spec(); each offset will be adjusted to point at the same logical
 // place in the result strings after reformatting of the host.  If this isn't
 // possible because an offset points past the end of the host or into the middle
 // of a multi-character sequence, the offending offset will be set to
-// std::wstring::npos. |offset[s]_for_adjustment| may be NULL.
+// string16::npos. |offset[s]_for_adjustment| may be NULL.
 void AppendFormattedHost(const GURL& url,
-                         const std::wstring& languages,
-                         std::wstring* output,
+                         const std::string& languages,
+                         string16* output,
                          url_parse::Parsed* new_parsed,
                          size_t* offset_for_adjustment);
 void AppendFormattedHostWithOffsets(
     const GURL& url,
-    const std::wstring& languages,
-    std::wstring* output,
+    const std::string& languages,
+    string16* output,
     url_parse::Parsed* new_parsed,
     std::vector<size_t>* offsets_for_adjustment);
 
 // Creates a string representation of |url|. The IDN host name may be in Unicode
 // if |languages| accepts the Unicode representation. |format_type| is a bitmask
 // of FormatUrlTypes, see it for details. |unescape_rules| defines how to clean
 // the URL for human readability. You will generally want |UnescapeRule::SPACES|
 // for display to the user if you can handle spaces, or |UnescapeRule::NORMAL|
 // if not. If the path part and the query part seem to be encoded in %-encoded
 // UTF-8, decodes %-encoding and UTF-8.
@@ skipping 160 matching lines @@
 struct ClampComponentOffset {
   explicit ClampComponentOffset(size_t component_start);
   size_t operator()(size_t offset);
 
   const size_t component_start;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_UTIL_H_