Rename ScopedComPtr::get() to ScopedComPtr::Get()

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 <devicetopology.h>
 #include <dxdiag.h>
 #include <functiondiscoverykeys_devpkey.h>
 #include <stddef.h>
@@ skipping 235 matching lines @@
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio))
     return AUDCLNT_SHAREMODE_EXCLUSIVE;
   return AUDCLNT_SHAREMODE_SHARED;
 }
 
 int CoreAudioUtil::NumberOfActiveDevices(EDataFlow data_flow) {
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
-  if (!device_enumerator.get())
+  if (!device_enumerator.Get())
     return 0;
 
   // Generate a collection of active (present and not disabled) audio endpoint
   // devices for the specified data-flow direction.
   // This method will succeed even if all devices are disabled.
   ScopedComPtr<IMMDeviceCollection> collection;
   HRESULT hr = device_enumerator->EnumAudioEndpoints(data_flow,
                                                      DEVICE_STATE_ACTIVE,
                                                      collection.Receive());
   if (FAILED(hr)) {
@@ skipping 13 matching lines @@
   return CreateDeviceEnumeratorInternal(true);
 }
 
 ScopedComPtr<IMMDevice> CoreAudioUtil::CreateDefaultDevice(EDataFlow data_flow,
                                                            ERole role) {
   ScopedComPtr<IMMDevice> endpoint_device;
 
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
-  if (!device_enumerator.get())
+  if (!device_enumerator.Get())
     return endpoint_device;
 
   // Retrieve the default audio endpoint for the specified data-flow
   // direction and role.
   HRESULT hr = device_enumerator->GetDefaultAudioEndpoint(
       data_flow, role, endpoint_device.Receive());
 
   if (FAILED(hr)) {
     DVLOG(1) << "IMMDeviceEnumerator::GetDefaultAudioEndpoint: "
              << std::hex << hr;
     return endpoint_device;
   }
 
   // Verify that the audio endpoint device is active, i.e., that the audio
   // adapter that connects to the endpoint device is present and enabled.
-  if (!IsDeviceActive(endpoint_device.get())) {
+  if (!IsDeviceActive(endpoint_device.Get())) {
     DVLOG(1) << "Selected endpoint device is not active";
     endpoint_device.Reset();
   }
   return endpoint_device;
 }
 
 std::string CoreAudioUtil::GetDefaultOutputDeviceID() {
   ScopedComPtr<IMMDevice> device(CreateDefaultDevice(eRender, eConsole));
-  return device.get() ? GetDeviceID(device.get()) : std::string();
+  return device.Get() ? GetDeviceID(device.Get()) : std::string();
 }
 
 ScopedComPtr<IMMDevice> CoreAudioUtil::CreateDevice(
     const std::string& device_id) {
   ScopedComPtr<IMMDevice> endpoint_device;
 
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
-  if (!device_enumerator.get())
+  if (!device_enumerator.Get())
     return endpoint_device;
 
   // Retrieve an audio device specified by an endpoint device-identification
   // string.
   HRESULT hr = device_enumerator->GetDevice(
       base::UTF8ToUTF16(device_id).c_str(), endpoint_device.Receive());
   DVLOG_IF(1, FAILED(hr)) << "IMMDeviceEnumerator::GetDevice: "
                           << std::hex << hr;
 
   if (FAILED(hr)) {
     DVLOG(1) << "IMMDeviceEnumerator::GetDevice: " << std::hex << hr;
     return endpoint_device;
   }
 
   // Verify that the audio endpoint device is active, i.e., that the audio
   // adapter that connects to the endpoint device is present and enabled.
-  if (!IsDeviceActive(endpoint_device.get())) {
+  if (!IsDeviceActive(endpoint_device.Get())) {
     DVLOG(1) << "Selected endpoint device is not active";
     endpoint_device.Reset();
   }
   return endpoint_device;
 }
 
 HRESULT CoreAudioUtil::GetDeviceName(IMMDevice* device, AudioDeviceName* name) {
   // Retrieve unique name of endpoint device.
   // Example: "{0.0.1.00000000}.{8db6020f-18e3-4f25-b6f5-7726c9122574}".
   AudioDeviceName device_name;
@@ skipping 70 matching lines @@
   if (input_device_id == AudioDeviceDescription::kCommunicationsDeviceId)
     return AudioDeviceDescription::kCommunicationsDeviceId;
 
   ScopedComPtr<IMMDevice> input_device;
   if (IsDefaultDeviceId(input_device_id)) {
     input_device = CreateDefaultDevice(eCapture, eConsole);
   } else {
     input_device = CreateDevice(input_device_id);
   }
 
-  if (!input_device.get())
+  if (!input_device.Get())
     return std::string();
 
   // See if we can get id of the associated controller.
   ScopedComPtr<IMMDeviceEnumerator> enumerator(CreateDeviceEnumerator());
   std::string controller_id(
-      GetAudioControllerID(input_device.get(), enumerator.get()));
+      GetAudioControllerID(input_device.Get(), enumerator.Get()));
   if (controller_id.empty())
     return std::string();
 
   // Now enumerate the available (and active) output devices and see if any of
   // them is associated with the same controller.
   ScopedComPtr<IMMDeviceCollection> collection;
   enumerator->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE,
       collection.Receive());
-  if (!collection.get())
+  if (!collection.Get())
     return std::string();
 
   UINT count = 0;
   collection->GetCount(&count);
   ScopedComPtr<IMMDevice> output_device;
   for (UINT i = 0; i < count; ++i) {
     collection->Item(i, output_device.Receive());
     std::string output_controller_id(
-        GetAudioControllerID(output_device.get(), enumerator.get()));
+        GetAudioControllerID(output_device.Get(), enumerator.Get()));
     if (output_controller_id == controller_id)
       break;
     output_device = NULL;
   }
 
-  return output_device.get() ? GetDeviceID(output_device.get()) : std::string();
+  return output_device.Get() ? GetDeviceID(output_device.Get()) : std::string();
 }
 
 std::string CoreAudioUtil::GetFriendlyName(const std::string& device_id) {
   ScopedComPtr<IMMDevice> audio_device = CreateDevice(device_id);
-  if (!audio_device.get())
+  if (!audio_device.Get())
     return std::string();
 
   AudioDeviceName device_name;
-  HRESULT hr = GetDeviceName(audio_device.get(), &device_name);
+  HRESULT hr = GetDeviceName(audio_device.Get(), &device_name);
   if (FAILED(hr))
     return std::string();
 
   return device_name.device_name;
 }
 
 bool CoreAudioUtil::DeviceIsDefault(EDataFlow flow,
                                     ERole role,
                                     const std::string& device_id) {
   ScopedComPtr<IMMDevice> device = CreateDefaultDevice(flow, role);
-  if (!device.get())
+  if (!device.Get())
     return false;
 
-  std::string str_default(GetDeviceID(device.get()));
+  std::string str_default(GetDeviceID(device.Get()));
   return device_id.compare(str_default) == 0;
 }
 
 EDataFlow CoreAudioUtil::GetDataFlow(IMMDevice* device) {
   ScopedComPtr<IMMEndpoint> endpoint;
   HRESULT hr = device->QueryInterface(endpoint.Receive());
   if (FAILED(hr)) {
     DVLOG(1) << "IMMDevice::QueryInterface: " << std::hex << hr;
     return eAll;
   }
@@ skipping 16 matching lines @@
                                       CLSCTX_INPROC_SERVER,
                                       NULL,
                                       audio_client.ReceiveVoid());
   DVLOG_IF(1, FAILED(hr)) << "IMMDevice::Activate: " << std::hex << hr;
   return audio_client;
 }
 
 ScopedComPtr<IAudioClient> CoreAudioUtil::CreateDefaultClient(
     EDataFlow data_flow, ERole role) {
   ScopedComPtr<IMMDevice> default_device(CreateDefaultDevice(data_flow, role));
-  return (default_device.get() ? CreateClient(default_device.get())
+  return (default_device.Get() ? CreateClient(default_device.Get())
                                : ScopedComPtr<IAudioClient>());
 }
 
 ScopedComPtr<IAudioClient> CoreAudioUtil::CreateClient(
     const std::string& device_id, EDataFlow data_flow, ERole role) {
   if (IsDefaultDeviceId(device_id))
     return CreateDefaultClient(data_flow, role);
 
   ScopedComPtr<IMMDevice> device(CreateDevice(device_id));
-  if (!device.get())
+  if (!device.Get())
     return ScopedComPtr<IAudioClient>();
 
-  return CreateClient(device.get());
+  return CreateClient(device.Get());
 }
 
 HRESULT CoreAudioUtil::GetSharedModeMixFormat(
     IAudioClient* client, WAVEFORMATPCMEX* format) {
   ScopedCoMem<WAVEFORMATPCMEX> format_pcmex;
   HRESULT hr = client->GetMixFormat(
       reinterpret_cast<WAVEFORMATEX**>(&format_pcmex));
   if (FAILED(hr))
     return hr;
 
@@ skipping 25 matching lines @@
 
   return (hr == S_OK);
 }
 
 bool CoreAudioUtil::IsChannelLayoutSupported(const std::string& device_id,
                                              EDataFlow data_flow,
                                              ERole role,
                                              ChannelLayout channel_layout) {
   // First, get the preferred mixing format for shared mode streams.
   ScopedComPtr<IAudioClient> client(CreateClient(device_id, data_flow, role));
-  if (!client.get())
+  if (!client.Get())
     return false;
 
   WAVEFORMATPCMEX format;
-  HRESULT hr = GetSharedModeMixFormat(client.get(), &format);
+  HRESULT hr = GetSharedModeMixFormat(client.Get(), &format);
   if (FAILED(hr))
     return false;
 
   // Next, check if it is possible to use an alternative format where the
   // channel layout (and possibly number of channels) is modified.
 
   // Convert generic channel layout into Windows-specific channel configuration.
   ChannelConfig new_config = ChannelLayoutToChannelConfig(channel_layout);
   if (new_config == KSAUDIO_SPEAKER_UNSUPPORTED) {
     return false;
@@ skipping 12 matching lines @@
   DVLOG(2) << format;
 
   // Some devices can initialize a shared-mode stream with a format that is
   // not identical to the mix format obtained from the GetMixFormat() method.
   // However, chances of succeeding increases if we use the same number of
   // channels and the same sample rate as the mix format. I.e, this call will
   // return true only in those cases where the audio engine is able to support
   // an even wider range of shared-mode formats where the installation package
   // for the audio device includes a local effects (LFX) audio processing
   // object (APO) that can handle format conversions.
-  return CoreAudioUtil::IsFormatSupported(client.get(),
+  return CoreAudioUtil::IsFormatSupported(client.Get(),
                                           AUDCLNT_SHAREMODE_SHARED, &format);
 }
 
 HRESULT CoreAudioUtil::GetDevicePeriod(IAudioClient* client,
                                        AUDCLNT_SHAREMODE share_mode,
                                        REFERENCE_TIME* device_period) {
   // Get the period of the engine thread.
   REFERENCE_TIME default_period = 0;
   REFERENCE_TIME minimum_period = 0;
   HRESULT hr = client->GetDevicePeriod(&default_period, &minimum_period);
@@ skipping 84 matching lines @@
       device_id == AudioDeviceDescription::kLoopbackWithMuteDeviceId) {
     DCHECK(!is_output_device);
     device = CoreAudioUtil::CreateDefaultDevice(eRender, eConsole);
   } else if (device_id == AudioDeviceDescription::kCommunicationsDeviceId) {
     device = CoreAudioUtil::CreateDefaultDevice(
         is_output_device ? eRender : eCapture, eCommunications);
   } else {
     device = CreateDevice(device_id);
   }
 
-  if (!device.get()) {
+  if (!device.Get()) {
     // Map NULL-pointer to new error code which can be different from the
     // actual error code. The exact value is not important here.
     return AUDCLNT_E_DEVICE_INVALIDATED;
   }
 
-  ScopedComPtr<IAudioClient> client(CreateClient(device.get()));
-  if (!client.get()) {
+  ScopedComPtr<IAudioClient> client(CreateClient(device.Get()));
+  if (!client.Get()) {
     // Map NULL-pointer to new error code which can be different from the
     // actual error code. The exact value is not important here.
     return AUDCLNT_E_ENDPOINT_CREATE_FAILED;
   }
 
-  HRESULT hr = GetPreferredAudioParameters(client.get(), params);
+  HRESULT hr = GetPreferredAudioParameters(client.Get(), params);
   if (FAILED(hr) || is_output_device || !params->IsValid())
     return hr;
 
   // The following functionality is only for input devices.
   DCHECK(!is_output_device);
 
   // TODO(dalecurtis): Old code rewrote != 1 channels to stereo, do we still
   // need to do the same thing?
   if (params->channels() != 1) {
     params->Reset(params->format(), CHANNEL_LAYOUT_STEREO,
                   params->sample_rate(), params->bits_per_sample(),
                   params->frames_per_buffer());
   }
 
   return hr;
 }
 
 ChannelConfig CoreAudioUtil::GetChannelConfig(const std::string& device_id,
                                               EDataFlow data_flow) {
   ScopedComPtr<IAudioClient> client(
       CreateClient(device_id, data_flow, eConsole));
 
   WAVEFORMATPCMEX format = {};
-  if (!client.get() || FAILED(GetSharedModeMixFormat(client.get(), &format)))
+  if (!client.Get() || FAILED(GetSharedModeMixFormat(client.Get(), &format)))
     return 0;
 
   return static_cast<ChannelConfig>(format.dwChannelMask);
 }
 
 HRESULT CoreAudioUtil::SharedModeInitialize(IAudioClient* client,
                                             const WAVEFORMATPCMEX* format,
                                             HANDLE event_handle,
                                             uint32_t* endpoint_buffer_size,
                                             const GUID* session_guid) {
@@ skipping 148 matching lines @@
 
   if (variant.type() == VT_BSTR && variant.ptr()->bstrVal) {
     base::WideToUTF8(variant.ptr()->bstrVal, wcslen(variant.ptr()->bstrVal),
                      driver_version);
   }
 
   return true;
 }
 
 }  // namespace media