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

net/base/net_util.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 "net/base/net_util.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 
@@ skipping 616 matching lines @@
   const char kViewSource[] = "view-source:";
   const size_t kViewSourceLength = arraysize(kViewSource) - 1;
 
   // Format the underlying URL and adjust offsets.
   const std::string& url_str(url.possibly_invalid_spec());
   Offsets offsets_into_underlying_url(original_offsets);
   {
     base::OffsetAdjuster adjuster(&offsets_into_underlying_url);
     adjuster.Add(base::OffsetAdjuster::Adjustment(0, kViewSourceLength, 0));
   }
-  base::string16 result(ASCIIToUTF16(kViewSource) +
+  base::string16 result(base::ASCIIToUTF16(kViewSource) +
       FormatUrlWithOffsets(GURL(url_str.substr(kViewSourceLength)), languages,
                            format_types, unescape_rules, new_parsed, prefix_end,
                            &offsets_into_underlying_url));
   AdjustForComponentTransform(original_offsets, kViewSourceLength,
                               url_str.length(), offsets_into_underlying_url,
                               kViewSourceLength, result.length(),
                               offsets_for_adjustment);
   LimitOffsets(result, offsets_for_adjustment);
 
   // Adjust positions of the parsed components.
@@ skipping 155 matching lines @@
   std::string decoded_filename = unescaped_url_filename;
   if (!IsStringUTF8(decoded_filename)) {
     // TODO(jshin): this is probably not robust enough. To be sure, we need
     // encoding detection.
     base::string16 utf16_output;
     if (!referrer_charset.empty() &&
         base::CodepageToUTF16(unescaped_url_filename,
                               referrer_charset.c_str(),
                               base::OnStringConversionError::FAIL,
                               &utf16_output)) {
-      decoded_filename = UTF16ToUTF8(utf16_output);
+      decoded_filename = base::UTF16ToUTF8(utf16_output);
     } else {
-      decoded_filename = WideToUTF8(
+      decoded_filename = base::WideToUTF8(
           base::SysNativeMBToWide(unescaped_url_filename));
     }
   }
   // If the URL contains a (possibly empty) query, assume it is a generator, and
   // allow the determined extension to be overwritten.
   *should_overwrite_extension = !decoded_filename.empty() && url.has_query();
 
   return decoded_filename;
 }
 
@@ skipping 24 matching lines @@
   // This list is taken from the MSDN article "Naming a file"
   // http://msdn2.microsoft.com/en-us/library/aa365247(VS.85).aspx
   // I also added clock$ because GetSaveFileName seems to consider it as a
   // reserved name too.
   static const char* const known_devices[] = {
     "con", "prn", "aux", "nul", "com1", "com2", "com3", "com4", "com5",
     "com6", "com7", "com8", "com9", "lpt1", "lpt2", "lpt3", "lpt4",
     "lpt5", "lpt6", "lpt7", "lpt8", "lpt9", "clock$"
   };
 #if defined(OS_WIN)
-  std::string filename_lower = StringToLowerASCII(WideToUTF8(filename));
+  std::string filename_lower = StringToLowerASCII(base::WideToUTF8(filename));
 #elif defined(OS_POSIX)
   std::string filename_lower = StringToLowerASCII(filename);
 #endif
 
   for (size_t i = 0; i < arraysize(known_devices); ++i) {
     // Exact match.
     if (filename_lower == known_devices[i])
       return true;
     // Starts with "DEVICE.".
     if (filename_lower.find(std::string(known_devices[i]) + ".") == 0)
@@ skipping 67 matching lines @@
   // with the preferred extension for the MIME type if one is available.
   if (IsShellIntegratedExtension(extension))
     extension.assign(default_extension);
 #endif
 
   *file_name = file_name->ReplaceExtension(extension);
 }
 
 bool FilePathToString16(const base::FilePath& path, base::string16* converted) {
 #if defined(OS_WIN)
-  return WideToUTF16(path.value().c_str(), path.value().size(), converted);
+  return base::WideToUTF16(
+      path.value().c_str(), path.value().size(), converted);
 #elif defined(OS_POSIX)
   std::string component8 = path.AsUTF8Unsafe();
   return !component8.empty() &&
-         UTF8ToUTF16(component8.c_str(), component8.size(), converted);
+         base::UTF8ToUTF16(component8.c_str(), component8.size(), converted);
 #endif
 }
 
 bool IPNumberPrefixCheck(const IPAddressNumber& ip_number,
                          const unsigned char* ip_prefix,
                          size_t prefix_length_in_bits) {
   // Compare all the bytes that fall entirely within the prefix.
   int num_entire_bytes_in_prefix = prefix_length_in_bits / 8;
   for (int i = 0; i < num_entire_bytes_in_prefix; ++i) {
     if (ip_number[i] != ip_prefix[i])
@@ skipping 182 matching lines @@
 std::string GetDirectoryListingEntry(const base::string16& name,
                                      const std::string& raw_bytes,
                                      bool is_dir,
                                      int64 size,
                                      Time modified) {
   std::string result;
   result.append("<script>addRow(");
   base::EscapeJSONString(name, true, &result);
   result.append(",");
   if (raw_bytes.empty()) {
-    base::EscapeJSONString(EscapePath(UTF16ToUTF8(name)), true, &result);
+    base::EscapeJSONString(EscapePath(base::UTF16ToUTF8(name)), true, &result);
   } else {
     base::EscapeJSONString(EscapePath(raw_bytes), true, &result);
   }
   if (is_dir) {
     result.append(",1,");
   } else {
     result.append(",0,");
   }
 
   // Negative size means unknown or not applicable (e.g. directory).
@@ skipping 10 matching lines @@
     modified_str = base::TimeFormatShortDateAndTime(modified);
   }
   base::EscapeJSONString(modified_str, true, &result);
 
   result.append(");</script>\n");
 
   return result;
 }
 
 base::string16 StripWWW(const base::string16& text) {
-  const base::string16 www(ASCIIToUTF16("www."));
+  const base::string16 www(base::ASCIIToUTF16("www."));
   return StartsWith(text, www, true) ? text.substr(www.length()) : text;
 }
 
 base::string16 StripWWWFromHost(const GURL& url) {
   DCHECK(url.is_valid());
-  return StripWWW(ASCIIToUTF16(url.host()));
+  return StripWWW(base::ASCIIToUTF16(url.host()));
 }
 
 bool IsSafePortablePathComponent(const base::FilePath& component) {
   base::string16 component16;
   base::FilePath::StringType sanitized = component.value();
   SanitizeGeneratedFileName(&sanitized, true);
   base::FilePath::StringType extension = component.Extension();
   if (!extension.empty())
     extension.erase(extension.begin());  // Erase preceding '.'.
   return !component.empty() &&
@@ skipping 82 matching lines @@
       url.is_valid() &&
       !url.host().empty()) {
     // TODO(jungshik) : Decode a 'punycoded' IDN hostname. (bug 1264451)
     filename = url.host();
   }
 
   bool replace_trailing = false;
   base::FilePath::StringType result_str, default_name_str;
 #if defined(OS_WIN)
   replace_trailing = true;
-  result_str = UTF8ToUTF16(filename);
-  default_name_str = UTF8ToUTF16(default_name);
+  result_str = base::UTF8ToUTF16(filename);
+  default_name_str = base::UTF8ToUTF16(default_name);
 #else
   result_str = filename;
   default_name_str = default_name;
 #endif
   SanitizeGeneratedFileName(&result_str, replace_trailing);
   if (result_str.find_last_not_of(FILE_PATH_LITERAL("-_")) ==
       base::FilePath::StringType::npos) {
     result_str = !default_name_str.empty() ? default_name_str :
       base::FilePath::StringType(kFinalFallbackName);
     overwrite_extension = false;
@@ skipping 23 matching lines @@
                                                   content_disposition,
                                                   referrer_charset,
                                                   suggested_name,
                                                   mime_type,
                                                   default_file_name);
 
 #if defined(OS_WIN)
   base::FilePath generated_name(file_name);
 #else
   base::FilePath generated_name(
-      base::SysWideToNativeMB(UTF16ToWide(file_name)));
+      base::SysWideToNativeMB(base::UTF16ToWide(file_name)));
 #endif
 
 #if defined(OS_CHROMEOS)
   // When doing file manager operations on ChromeOS, the file paths get
   // normalized in WebKit layer, so let's ensure downloaded files have
   // normalized names. Otherwise, we won't be able to handle files with NFD
   // utf8 encoded characters in name.
   file_util::NormalizeFileNameEncoding(&generated_name);
 #endif
 
@@ skipping 477 matching lines @@
 
   // Ref.  This is valid, unescaped UTF-8, so we can just convert.
   if (parsed.ref.is_valid())
     url_string.push_back('#');
   AppendFormattedComponent(spec, parsed.ref, original_offsets,
       NonHostComponentTransform(UnescapeRule::NONE), &url_string,
       &new_parsed->ref, offsets_for_adjustment);
 
   // If we need to strip out http do it after the fact. This way we don't need
   // to worry about how offset_for_adjustment is interpreted.
-  if (omit_http && StartsWith(url_string, ASCIIToUTF16(kHTTP), true)) {
+  if (omit_http && StartsWith(url_string, base::ASCIIToUTF16(kHTTP), true)) {
     const size_t kHTTPSize = arraysize(kHTTP) - 1;
     url_string = url_string.substr(kHTTPSize);
     if (offsets_for_adjustment && !offsets_for_adjustment->empty()) {
       base::OffsetAdjuster offset_adjuster(offsets_for_adjustment);
       offset_adjuster.Add(base::OffsetAdjuster::Adjustment(0, kHTTPSize, 0));
     }
     if (prefix_end)
       *prefix_end -= kHTTPSize;
 
     // Adjust new_parsed.
@@ skipping 364 matching lines @@
   }
   return a1.size() * CHAR_BIT;
 }
 
 unsigned MaskPrefixLength(const IPAddressNumber& mask) {
   IPAddressNumber all_ones(mask.size(), 0xFF);
   return CommonPrefixLength(mask, all_ones);
 }
 
 }  // namespace net