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

media/audio/win/core_audio_util_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 "media/audio/win/core_audio_util_win.h"
 
 #include <audioclient.h>
 #include <devicetopology.h>
 #include <functiondiscoverykeys_devpkey.h>
 
@@ skipping 128 matching lines @@
   // must be called at least once for each thread that uses the COM library.
   CHECK_NE(hr, CO_E_NOTINITIALIZED);
 
   return SUCCEEDED(hr);
 }
 
 static std::string GetDeviceID(IMMDevice* device) {
   ScopedCoMem<WCHAR> device_id_com;
   std::string device_id;
   if (SUCCEEDED(device->GetId(&device_id_com)))
-    WideToUTF8(device_id_com, wcslen(device_id_com), &device_id);
+    base::WideToUTF8(device_id_com, wcslen(device_id_com), &device_id);
   return device_id;
 }
 
 bool CoreAudioUtil::IsSupported() {
   // It is possible to force usage of WaveXxx APIs by using a command line flag.
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kForceWaveAudio)) {
     LOG(WARNING) << "Forcing usage of Windows WaveXxx APIs";
     return false;
   }
@@ skipping 121 matching lines @@
   ScopedComPtr<IMMDevice> endpoint_device;
 
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
   if (!device_enumerator)
     return endpoint_device;
 
   // Retrieve an audio device specified by an endpoint device-identification
   // string.
-  HRESULT hr = device_enumerator->GetDevice(UTF8ToUTF16(device_id).c_str(),
-                                            endpoint_device.Receive());
+  HRESULT hr = device_enumerator->GetDevice(
+      base::UTF8ToUTF16(device_id).c_str(), endpoint_device.Receive());
   DVLOG_IF(1, FAILED(hr)) << "IMMDeviceEnumerator::GetDevice: "
                           << std::hex << hr;
   return endpoint_device;
 }
 
 HRESULT CoreAudioUtil::GetDeviceName(IMMDevice* device, AudioDeviceName* name) {
   DCHECK(IsSupported());
 
   // Retrieve unique name of endpoint device.
   // Example: "{0.0.1.00000000}.{8db6020f-18e3-4f25-b6f5-7726c9122574}".
   AudioDeviceName device_name;
   device_name.unique_id = GetDeviceID(device);
   if (device_name.unique_id.empty())
     return E_FAIL;
 
   // Retrieve user-friendly name of endpoint device.
   // Example: "Microphone (Realtek High Definition Audio)".
   ScopedComPtr<IPropertyStore> properties;
   HRESULT hr = device->OpenPropertyStore(STGM_READ, properties.Receive());
   if (FAILED(hr))
     return hr;
   base::win::ScopedPropVariant friendly_name;
   hr = properties->GetValue(PKEY_Device_FriendlyName, friendly_name.Receive());
   if (FAILED(hr))
     return hr;
   if (friendly_name.get().vt == VT_LPWSTR && friendly_name.get().pwszVal) {
-    WideToUTF8(friendly_name.get().pwszVal,
-               wcslen(friendly_name.get().pwszVal),
-               &device_name.device_name);
+    base::WideToUTF8(friendly_name.get().pwszVal,
+                     wcslen(friendly_name.get().pwszVal),
+                     &device_name.device_name);
   }
 
   *name = device_name;
   DVLOG(2) << "friendly name: " << device_name.device_name;
   DVLOG(2) << "unique id    : " << device_name.unique_id;
   return hr;
 }
 
 std::string CoreAudioUtil::GetAudioControllerID(IMMDevice* device,
     IMMDeviceEnumerator* enumerator) {
@@ skipping 28 matching lines @@
   if (FAILED(enumerator->GetDevice(filter_id, device_node.Receive())) ||
       FAILED(device_node->OpenPropertyStore(STGM_READ, properties.Receive())) ||
       FAILED(properties->GetValue(PKEY_Device_InstanceId,
                                   instance_id.Receive())) ||
       instance_id.get().vt != VT_LPWSTR) {
     DLOG(ERROR) << "Failed to get instance id of the audio device node";
     return std::string();
   }
 
   std::string controller_id;
-  WideToUTF8(instance_id.get().pwszVal,
-             wcslen(instance_id.get().pwszVal),
-             &controller_id);
+  base::WideToUTF8(instance_id.get().pwszVal,
+                   wcslen(instance_id.get().pwszVal),
+                   &controller_id);
 
   return controller_id;
 }
 
 std::string CoreAudioUtil::GetMatchingOutputDeviceID(
     const std::string& input_device_id) {
   ScopedComPtr<IMMDevice> input_device(CreateDevice(input_device_id));
   if (!input_device)
     return std::string();
 
@@ skipping 434 matching lines @@
     return false;
 
   // Using the AUDCLNT_BUFFERFLAGS_SILENT flag eliminates the need to
   // explicitly write silence data to the rendering buffer.
   DVLOG(2) << "filling up " << num_frames_to_fill << " frames with silence";
   return SUCCEEDED(render_client->ReleaseBuffer(num_frames_to_fill,
                                                 AUDCLNT_BUFFERFLAGS_SILENT));
 }
 
 }  // namespace media