Move UTF16ToASCII, remove WideToASCII.

gpu/config/gpu_info_collector_win.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 "gpu/config/gpu_info_collector.h"
 
 // This has to be included before windows.h.
 #include "third_party/re2/re2/re2.h"
 
 #include <windows.h>
 #include <d3d9.h>
 #include <d3d11.h>
 #include <dxgi.h>
 #include <setupapi.h>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/scoped_native_library.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/worker_pool.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_egl.h"
 
@@ skipping 139 matching lines @@
   if (key.OpenKey(L"DisplayLink", KEY_READ | KEY_WOW64_64KEY))
     return Version();
 
   if (key.OpenKey(L"Core", KEY_READ | KEY_WOW64_64KEY))
     return Version();
 
   base::string16 version;
   if (key.ReadValue(L"Version", &version))
     return Version();
 
-  return Version(WideToASCII(version));
+  return Version(base::UTF16ToASCII(version));
 }
 
 // Returns whether Lenovo dCute is installed.
 bool IsLenovoDCuteInstalled() {
   base::win::RegKey key;
 
   if (key.Open(HKEY_LOCAL_MACHINE, L"SOFTWARE", KEY_READ | KEY_WOW64_64KEY))
     return false;
 
   if (key.OpenKey(L"Lenovo", KEY_READ | KEY_WOW64_64KEY))
@@ skipping 200 matching lines @@
       driver_key += value;
       LONG result = RegOpenKeyExW(
           HKEY_LOCAL_MACHINE, driver_key.c_str(), 0, KEY_QUERY_VALUE, &key);
       if (result == ERROR_SUCCESS) {
         DWORD dwcb_data = sizeof(value);
         std::string driver_version;
         result = RegQueryValueExW(
             key, L"DriverVersion", NULL, NULL,
             reinterpret_cast<LPBYTE>(value), &dwcb_data);
         if (result == ERROR_SUCCESS)
-          driver_version = WideToASCII(std::wstring(value));
+          driver_version = base::UTF16ToASCII(std::wstring(value));
 
         std::string driver_date;
         dwcb_data = sizeof(value);
         result = RegQueryValueExW(
             key, L"DriverDate", NULL, NULL,
             reinterpret_cast<LPBYTE>(value), &dwcb_data);
         if (result == ERROR_SUCCESS)
-          driver_date = WideToASCII(std::wstring(value));
+          driver_date = base::UTF16ToASCII(std::wstring(value));
 
         std::string driver_vendor;
         dwcb_data = sizeof(value);
         result = RegQueryValueExW(
             key, L"ProviderName", NULL, NULL,
             reinterpret_cast<LPBYTE>(value), &dwcb_data);
         if (result == ERROR_SUCCESS) {
-          driver_vendor = WideToASCII(std::wstring(value));
+          driver_vendor = base::UTF16ToASCII(std::wstring(value));
           if (driver_vendor == "Advanced Micro Devices, Inc." ||
               driver_vendor == "ATI Technologies Inc.") {
             // We are conservative and assume that in the absence of a clear
             // signal the videocard is assumed to be switchable. Additionally,
             // some switchable systems with Intel GPUs aren't correctly
             // detected, so always count them.
             AMDVideoCardType amd_card_type = GetAMDVideocardType();
             gpu_info->amd_switchable = (gpu_info->gpu.vendor_id == 0x8086) ||
                                        (amd_card_type != STANDALONE);
           }
@@ skipping 93 matching lines @@
     if (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) {
       id = dd.DeviceID;
       break;
     }
   }
 
   if (id.length() > 20) {
     int vendor = 0, device = 0;
     std::wstring vendor_string = id.substr(8, 4);
     std::wstring device_string = id.substr(17, 4);
-    base::HexStringToInt(WideToASCII(vendor_string), &vendor);
-    base::HexStringToInt(WideToASCII(device_string), &device);
+    base::HexStringToInt(base::UTF16ToASCII(vendor_string), &vendor);
+    base::HexStringToInt(base::UTF16ToASCII(device_string), &device);
     *vendor_id = vendor;
     *device_id = device;
     return kGpuIDSuccess;
   }
   return kGpuIDFailure;
 }
 
 bool CollectBasicGraphicsInfo(GPUInfo* gpu_info) {
   TRACE_EVENT0("gpu", "CollectPreliminaryGraphicsInfo");
 
@@ skipping 33 matching lines @@
       break;
     }
   }
 
   if (id.length() <= 20)
     return false;
 
   int vendor_id = 0, device_id = 0;
   base::string16 vendor_id_string = id.substr(8, 4);
   base::string16 device_id_string = id.substr(17, 4);
-  base::HexStringToInt(WideToASCII(vendor_id_string), &vendor_id);
-  base::HexStringToInt(WideToASCII(device_id_string), &device_id);
+  base::HexStringToInt(base::UTF16ToASCII(vendor_id_string), &vendor_id);
+  base::HexStringToInt(base::UTF16ToASCII(device_id_string), &device_id);
   gpu_info->gpu.vendor_id = vendor_id;
   gpu_info->gpu.device_id = device_id;
   // TODO(zmo): we only need to call CollectDriverInfoD3D() if we use ANGLE.
   if (!CollectDriverInfoD3D(id, gpu_info))
     return false;
 
   // Collect basic information about supported D3D11 features. Delay for 45
   // seconds so as not to regress performance tests.
   if (D3D11ShouldWork(*gpu_info)) {
     // This is on a field trial so we can turn it off easily if it blows up
@@ skipping 37 matching lines @@
     basic_gpu_info->software_rendering = true;
     return;
   }
 
   MergeGPUInfoGL(basic_gpu_info, context_gpu_info);
 
   basic_gpu_info->dx_diagnostics = context_gpu_info.dx_diagnostics;
 }
 
 }  // namespace gpu