Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

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 <objbase.h>
@@ skipping 137 matching lines @@
 static bool IsDeviceActive(IMMDevice* device) {
   DWORD state = DEVICE_STATE_DISABLED;
   return SUCCEEDED(device->GetState(&state)) && (state & DEVICE_STATE_ACTIVE);
 }
 
 static HRESULT GetDeviceFriendlyNameInternal(IMMDevice* device,
                                              std::string* friendly_name) {
   // Retrieve user-friendly name of endpoint device.
   // Example: "Microphone (Realtek High Definition Audio)".
   ScopedComPtr<IPropertyStore> properties;
-  HRESULT hr = device->OpenPropertyStore(STGM_READ, properties.Receive());
+  HRESULT hr = device->OpenPropertyStore(STGM_READ, properties.GetAddressOf());
   if (FAILED(hr))
     return hr;
 
   base::win::ScopedPropVariant friendly_name_pv;
   hr = properties->GetValue(PKEY_Device_FriendlyName,
                             friendly_name_pv.Receive());
   if (FAILED(hr))
     return hr;
 
   if (friendly_name_pv.get().vt == VT_LPWSTR &&
@@ skipping 85 matching lines @@
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
   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());
+  HRESULT hr = device_enumerator->EnumAudioEndpoints(
+      data_flow, DEVICE_STATE_ACTIVE, collection.GetAddressOf());
   if (FAILED(hr)) {
     LOG(ERROR) << "IMMDeviceCollection::EnumAudioEndpoints: " << std::hex << hr;
     return 0;
   }
 
   // Retrieve the number of active audio devices for the specified direction
   UINT number_of_active_devices = 0;
   collection->GetCount(&number_of_active_devices);
   DVLOG(2) << ((data_flow == eCapture) ? "[in ] " : "[out] ")
            << "number of devices: " << number_of_active_devices;
@@ skipping 10 matching lines @@
 
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
   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());
+      data_flow, role, endpoint_device.GetAddressOf());
 
   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())) {
@@ skipping 14 matching lines @@
 
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
   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());
+      base::UTF8ToUTF16(device_id).c_str(), endpoint_device.GetAddressOf());
   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.
@@ skipping 27 matching lines @@
   // Fetching the controller device id could be as simple as fetching the value
   // of the "{B3F8FA53-0004-438E-9003-51A46E139BFC},2" property in the property
   // store of the |device|, but that key isn't defined in any header and
   // according to MS should not be relied upon.
   // So, instead, we go deeper, look at the device topology and fetch the
   // PKEY_Device_InstanceId of the associated physical audio device.
   ScopedComPtr<IDeviceTopology> topology;
   ScopedComPtr<IConnector> connector;
   ScopedCoMem<WCHAR> filter_id;
   if (FAILED(device->Activate(__uuidof(IDeviceTopology), CLSCTX_ALL, NULL,
-             &topology)) ||
+                              &topology)) ||
       // For our purposes checking the first connected device should be enough
       // and if there are cases where there are more than one device connected
       // we're not sure how to handle that anyway. So we pass 0.
-      FAILED(topology->GetConnector(0, connector.Receive())) ||
+      FAILED(topology->GetConnector(0, connector.GetAddressOf())) ||
       FAILED(connector->GetDeviceIdConnectedTo(&filter_id))) {
     DLOG(ERROR) << "Failed to get the device identifier of the audio device";
     return std::string();
   }
 
   // Now look at the properties of the connected device node and fetch the
   // instance id (PKEY_Device_InstanceId) of the device node that uniquely
   // identifies the controller.
   ScopedComPtr<IMMDevice> device_node;
   ScopedComPtr<IPropertyStore> properties;
   base::win::ScopedPropVariant instance_id;
-  if (FAILED(enumerator->GetDevice(filter_id, device_node.Receive())) ||
-      FAILED(device_node->OpenPropertyStore(STGM_READ, properties.Receive())) ||
+  if (FAILED(enumerator->GetDevice(filter_id, device_node.GetAddressOf())) ||
+      FAILED(device_node->OpenPropertyStore(STGM_READ,
+                                            properties.GetAddressOf())) ||
       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;
   base::WideToUTF8(instance_id.get().pwszVal,
                    wcslen(instance_id.get().pwszVal),
@@ skipping 30 matching lines @@
   ScopedComPtr<IMMDeviceEnumerator> enumerator(CreateDeviceEnumerator());
   std::string controller_id(
       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());
+                                 collection.GetAddressOf());
   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());
+    collection->Item(i, output_device.GetAddressOf());
     std::string output_controller_id(
         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();
 }
 
@@ skipping 16 matching lines @@
   ScopedComPtr<IMMDevice> device = CreateDefaultDevice(flow, role);
   if (!device.Get())
     return false;
 
   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());
+  HRESULT hr = device->QueryInterface(endpoint.GetAddressOf());
   if (FAILED(hr)) {
     DVLOG(1) << "IMMDevice::QueryInterface: " << std::hex << hr;
     return eAll;
   }
 
   EDataFlow data_flow;
   hr = endpoint->GetDataFlow(&data_flow);
   if (FAILED(hr)) {
     DVLOG(1) << "IMMEndpoint::GetDataFlow: " << std::hex << hr;
     return eAll;
@@ skipping 379 matching lines @@
 
   DXDIAG_INIT_PARAMS params = {sizeof(params)};
   params.dwDxDiagHeaderVersion = DXDIAG_DX9_SDK_VERSION;
   params.bAllowWHQLChecks = FALSE;
   params.pReserved = NULL;
   hr = provider->Initialize(&params);
   if (FAILED(hr))
     return false;
 
   ScopedComPtr<IDxDiagContainer, &IID_IDxDiagContainer> root;
-  hr = provider->GetRootContainer(root.Receive());
+  hr = provider->GetRootContainer(root.GetAddressOf());
   if (FAILED(hr))
     return false;
 
   // Limit to the SoundDevices subtree. The tree in its entirity is
   // enormous and only this branch contains useful information.
   ScopedComPtr<IDxDiagContainer, &IID_IDxDiagContainer> sound_devices;
   hr = root->GetChildContainer(L"DxDiag_DirectSound.DxDiag_SoundDevices.0",
-                               sound_devices.Receive());
+                               sound_devices.GetAddressOf());
   if (FAILED(hr))
     return false;
 
   base::win::ScopedVariant variant;
   hr = sound_devices->GetProp(L"szDriverName", variant.Receive());
   if (FAILED(hr))
     return false;
 
   if (variant.type() == VT_BSTR && variant.ptr()->bstrVal) {
     base::WideToUTF8(variant.ptr()->bstrVal, wcslen(variant.ptr()->bstrVal),
                      driver_name);
   }
 
   variant.Reset();
   hr = sound_devices->GetProp(L"szDriverVersion", variant.Receive());
   if (FAILED(hr))
     return false;
 
   if (variant.type() == VT_BSTR && variant.ptr()->bstrVal) {
     base::WideToUTF8(variant.ptr()->bstrVal, wcslen(variant.ptr()->bstrVal),
                      driver_version);
   }
 
   return true;
 }
 
 }  // namespace media