media: Use IFACEMETHODIMP in COM implementation declaration

See discussion thread at
https://groups.google.com/a/chromium.org/g/cxx/c/h4bdRqbduNY/m/O8Blk8SoEQAJ

The recommendation style is as follows:

class Foo : public IComIsFun {
  IFACEMETHODIMP IsFun(BOOL* fun) override;
};

HRESULT Foo::IsFun(BOOL* fun) { *fun = false; return S_OK; }

Change-Id: I3209682f14489d9c1b31cf5f563a50cccf42a05e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2065857Reviewed-by: Henrik Andreasson <henrika@chromium.org>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Commit-Queue: Xiaohan Wang <xhwang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#743129}

media/audio/win/audio_device_listener_win.cc

@@ -67,15 +67,15 @@ AudioDeviceListenerWin::~AudioDeviceListenerWin() {
                              << "failed: " << std::hex << hr;
 }
 
-STDMETHODIMP_(ULONG) AudioDeviceListenerWin::AddRef() {
+ULONG AudioDeviceListenerWin::AddRef() {
   return 1;
 }
 
-STDMETHODIMP_(ULONG) AudioDeviceListenerWin::Release() {
+ULONG AudioDeviceListenerWin::Release() {
   return 1;
 }
 
-STDMETHODIMP AudioDeviceListenerWin::QueryInterface(REFIID iid, void** object) {
+HRESULT AudioDeviceListenerWin::QueryInterface(REFIID iid, void** object) {
   if (iid == IID_IUnknown || iid == __uuidof(IMMNotificationClient)) {
     *object = static_cast<IMMNotificationClient*>(this);
     return S_OK;
@@ -85,33 +85,32 @@ STDMETHODIMP AudioDeviceListenerWin::QueryInterface(REFIID iid, void** object) {
   return E_NOINTERFACE;
 }
 
-STDMETHODIMP AudioDeviceListenerWin::OnPropertyValueChanged(
-    LPCWSTR device_id,
-    const PROPERTYKEY key) {
+HRESULT AudioDeviceListenerWin::OnPropertyValueChanged(LPCWSTR device_id,
+                                                       const PROPERTYKEY key) {
   // Property changes are handled by IAudioSessionControl listeners hung off of
   // each WASAPIAudioOutputStream() since not all property changes make it to
   // this method and those that do are spammed 10s of times.
   return S_OK;
 }
 
-STDMETHODIMP AudioDeviceListenerWin::OnDeviceAdded(LPCWSTR device_id) {
+HRESULT AudioDeviceListenerWin::OnDeviceAdded(LPCWSTR device_id) {
   // We don't care when devices are added.
   return S_OK;
 }
 
-STDMETHODIMP AudioDeviceListenerWin::OnDeviceRemoved(LPCWSTR device_id) {
+HRESULT AudioDeviceListenerWin::OnDeviceRemoved(LPCWSTR device_id) {
   // We don't care when devices are removed.
   return S_OK;
 }
 
-STDMETHODIMP AudioDeviceListenerWin::OnDeviceStateChanged(LPCWSTR device_id,
-                                                          DWORD new_state) {
+HRESULT AudioDeviceListenerWin::OnDeviceStateChanged(LPCWSTR device_id,
+                                                     DWORD new_state) {
   if (auto* monitor = base::SystemMonitor::Get())
     monitor->ProcessDevicesChanged(base::SystemMonitor::DEVTYPE_AUDIO);
   return S_OK;
 }
 
-STDMETHODIMP AudioDeviceListenerWin::OnDefaultDeviceChanged(
+HRESULT AudioDeviceListenerWin::OnDefaultDeviceChanged(
     EDataFlow flow,
     ERole role,
     LPCWSTR new_default_device_id) {

media/audio/win/audio_device_listener_win.h

@@ -45,18 +45,18 @@ class MEDIA_EXPORT AudioDeviceListenerWin : public IMMNotificationClient {
       base::TimeDelta::FromMilliseconds(250);
 
   // IMMNotificationClient implementation.
-  STDMETHODIMP_(ULONG) AddRef() override;
-  STDMETHODIMP_(ULONG) Release() override;
-  STDMETHODIMP QueryInterface(REFIID iid, void** object) override;
-  STDMETHODIMP OnPropertyValueChanged(LPCWSTR device_id,
-                                      const PROPERTYKEY key) override;
-  STDMETHODIMP OnDeviceAdded(LPCWSTR device_id) override;
-  STDMETHODIMP OnDeviceRemoved(LPCWSTR device_id) override;
-  STDMETHODIMP OnDeviceStateChanged(LPCWSTR device_id,
-                                    DWORD new_state) override;
-  STDMETHODIMP OnDefaultDeviceChanged(EDataFlow flow,
-                                      ERole role,
-                                      LPCWSTR new_default_device_id) override;
+  IFACEMETHODIMP_(ULONG) AddRef() override;
+  IFACEMETHODIMP_(ULONG) Release() override;
+  IFACEMETHODIMP QueryInterface(REFIID iid, void** object) override;
+  IFACEMETHODIMP OnPropertyValueChanged(LPCWSTR device_id,
+                                        const PROPERTYKEY key) override;
+  IFACEMETHODIMP OnDeviceAdded(LPCWSTR device_id) override;
+  IFACEMETHODIMP OnDeviceRemoved(LPCWSTR device_id) override;
+  IFACEMETHODIMP OnDeviceStateChanged(LPCWSTR device_id,
+                                      DWORD new_state) override;
+  IFACEMETHODIMP OnDefaultDeviceChanged(EDataFlow flow,
+                                        ERole role,
+                                        LPCWSTR new_default_device_id) override;
 
   const base::RepeatingClosure listener_cb_;
   Microsoft::WRL::ComPtr<IMMDeviceEnumerator> device_enumerator_;

media/audio/win/audio_session_event_listener_win.cc

@@ -30,16 +30,15 @@ AudioSessionEventListener::~AudioSessionEventListener() {
       << "UnregisterAudioSessionNotification() failed: " << std::hex << hr;
 }
 
-STDMETHODIMP_(ULONG) AudioSessionEventListener::AddRef() {
+ULONG AudioSessionEventListener::AddRef() {
   return 1;  // Class is owned in Chromium code and should have no outside refs.
 }
 
-STDMETHODIMP_(ULONG) AudioSessionEventListener::Release() {
+ULONG AudioSessionEventListener::Release() {
   return 1;  // Class is owned in Chromium code and should have no outside refs.
 }
 
-STDMETHODIMP AudioSessionEventListener::QueryInterface(REFIID iid,
-                                                       void** object) {
+HRESULT AudioSessionEventListener::QueryInterface(REFIID iid, void** object) {
   if (iid == IID_IUnknown || iid == __uuidof(IAudioSessionEvents)) {
     *object = static_cast<IAudioSessionEvents*>(this);
     return S_OK;
@@ -49,7 +48,7 @@ STDMETHODIMP AudioSessionEventListener::QueryInterface(REFIID iid,
   return E_NOINTERFACE;
 }
 
-STDMETHODIMP AudioSessionEventListener::OnChannelVolumeChanged(
+HRESULT AudioSessionEventListener::OnChannelVolumeChanged(
     DWORD channel_count,
     float new_channel_volume_array[],
     DWORD changed_channel,
@@ -57,25 +56,24 @@ STDMETHODIMP AudioSessionEventListener::OnChannelVolumeChanged(
   return S_OK;
 }
 
-STDMETHODIMP
+IFACEMETHODIMP
 AudioSessionEventListener::OnDisplayNameChanged(LPCWSTR new_display_name,
                                                 LPCGUID event_context) {
   return S_OK;
 }
 
-STDMETHODIMP AudioSessionEventListener::OnGroupingParamChanged(
+HRESULT AudioSessionEventListener::OnGroupingParamChanged(
     LPCGUID new_grouping_param,
     LPCGUID event_context) {
   return S_OK;
 }
 
-STDMETHODIMP AudioSessionEventListener::OnIconPathChanged(
-    LPCWSTR new_icon_path,
-    LPCGUID event_context) {
+HRESULT AudioSessionEventListener::OnIconPathChanged(LPCWSTR new_icon_path,
+                                                     LPCGUID event_context) {
   return S_OK;
 }
 
-STDMETHODIMP AudioSessionEventListener::OnSessionDisconnected(
+HRESULT AudioSessionEventListener::OnSessionDisconnected(
     AudioSessionDisconnectReason disconnect_reason) {
   DVLOG(1) << __func__ << ": " << disconnect_reason;
   if (device_change_cb_)
@@ -83,15 +81,14 @@ STDMETHODIMP AudioSessionEventListener::OnSessionDisconnected(
   return S_OK;
 }
 
-STDMETHODIMP AudioSessionEventListener::OnSimpleVolumeChanged(
+HRESULT AudioSessionEventListener::OnSimpleVolumeChanged(
     float new_volume,
     BOOL new_mute,
     LPCGUID event_context) {
   return S_OK;
 }
 
-STDMETHODIMP AudioSessionEventListener::OnStateChanged(
-    AudioSessionState new_state) {
+HRESULT AudioSessionEventListener::OnStateChanged(AudioSessionState new_state) {
   return S_OK;
 }
 

media/audio/win/audio_session_event_listener_win.h

@@ -27,27 +27,27 @@ class MEDIA_EXPORT AudioSessionEventListener : public IAudioSessionEvents {
  private:
   friend class AudioSessionEventListenerTest;
 
-  STDMETHODIMP_(ULONG) AddRef() override;
-  STDMETHODIMP_(ULONG) Release() override;
-  STDMETHODIMP QueryInterface(REFIID iid, void** object) override;
+  IFACEMETHODIMP_(ULONG) AddRef() override;
+  IFACEMETHODIMP_(ULONG) Release() override;
+  IFACEMETHODIMP QueryInterface(REFIID iid, void** object) override;
 
   // IAudioSessionEvents implementation.
-  STDMETHODIMP OnChannelVolumeChanged(DWORD channel_count,
-                                      float new_channel_volume_array[],
-                                      DWORD changed_channel,
+  IFACEMETHODIMP OnChannelVolumeChanged(DWORD channel_count,
+                                        float new_channel_volume_array[],
+                                        DWORD changed_channel,
+                                        LPCGUID event_context) override;
+  IFACEMETHODIMP OnDisplayNameChanged(LPCWSTR new_display_name,
                                       LPCGUID event_context) override;
-  STDMETHODIMP OnDisplayNameChanged(LPCWSTR new_display_name,
-                                    LPCGUID event_context) override;
-  STDMETHODIMP OnGroupingParamChanged(LPCGUID new_grouping_param,
-                                      LPCGUID event_context) override;
-  STDMETHODIMP OnIconPathChanged(LPCWSTR new_icon_path,
-                                 LPCGUID event_context) override;
-  STDMETHODIMP OnSessionDisconnected(
+  IFACEMETHODIMP OnGroupingParamChanged(LPCGUID new_grouping_param,
+                                        LPCGUID event_context) override;
+  IFACEMETHODIMP OnIconPathChanged(LPCWSTR new_icon_path,
+                                   LPCGUID event_context) override;
+  IFACEMETHODIMP OnSessionDisconnected(
       AudioSessionDisconnectReason disconnect_reason) override;
-  STDMETHODIMP OnSimpleVolumeChanged(float new_volume,
-                                     BOOL new_mute,
-                                     LPCGUID event_context) override;
-  STDMETHODIMP OnStateChanged(AudioSessionState new_state) override;
+  IFACEMETHODIMP OnSimpleVolumeChanged(float new_volume,
+                                       BOOL new_mute,
+                                       LPCGUID event_context) override;
+  IFACEMETHODIMP OnStateChanged(AudioSessionState new_state) override;
 
   base::OnceClosure device_change_cb_;
   Microsoft::WRL::ComPtr<IAudioSessionControl> audio_session_control_;

media/capture/video/video_capture_device_unittest.cc

@@ -164,15 +164,15 @@ class MockMFPhotoCallback final : public IMFCaptureEngineOnSampleCallback {
   MOCK_METHOD0(DoRelease, ULONG(void));
   MOCK_METHOD1(DoOnSample, HRESULT(IMFSample*));
 
-  STDMETHODIMP QueryInterface(REFIID riid, void** object) override {
+  IFACEMETHODIMP QueryInterface(REFIID riid, void** object) override {
     return DoQueryInterface(riid, object);
   }
 
-  STDMETHODIMP_(ULONG) AddRef() override { return DoAddRef(); }
+  IFACEMETHODIMP_(ULONG) AddRef() override { return DoAddRef(); }
 
-  STDMETHODIMP_(ULONG) Release() override { return DoRelease(); }
+  IFACEMETHODIMP_(ULONG) Release() override { return DoRelease(); }
 
-  STDMETHODIMP OnSample(IMFSample* sample) override {
+  IFACEMETHODIMP OnSample(IMFSample* sample) override {
     return DoOnSample(sample);
   }
 };

media/capture/video/win/filter_base_win.cc

@@ -15,7 +15,7 @@ class PinEnumerator final : public IEnumPins,
   explicit PinEnumerator(FilterBase* filter) : filter_(filter), index_(0) {}
 
   // IUnknown implementation.
-  STDMETHODIMP QueryInterface(REFIID iid, void** object_ptr) override {
+  IFACEMETHODIMP QueryInterface(REFIID iid, void** object_ptr) override {
     if (iid == IID_IEnumPins || iid == IID_IUnknown) {
       AddRef();
       *object_ptr = static_cast<IEnumPins*>(this);
@@ -24,18 +24,18 @@ class PinEnumerator final : public IEnumPins,
     return E_NOINTERFACE;
   }
 
-  STDMETHODIMP_(ULONG) AddRef() override {
+  IFACEMETHODIMP_(ULONG) AddRef() override {
     base::RefCounted<PinEnumerator>::AddRef();
     return 1;
   }
 
-  STDMETHODIMP_(ULONG) Release() override {
+  IFACEMETHODIMP_(ULONG) Release() override {
     base::RefCounted<PinEnumerator>::Release();
     return 1;
   }
 
   // Implement IEnumPins.
-  STDMETHODIMP Next(ULONG count, IPin** pins, ULONG* fetched) override {
+  IFACEMETHODIMP Next(ULONG count, IPin** pins, ULONG* fetched) override {
     ULONG pins_fetched = 0;
     while (pins_fetched < count && filter_->NoOfPins() > index_) {
       IPin* pin = filter_->GetPin(index_++);
@@ -49,7 +49,7 @@ class PinEnumerator final : public IEnumPins,
     return pins_fetched == count ? S_OK : S_FALSE;
   }
 
-  STDMETHODIMP Skip(ULONG count) override {
+  IFACEMETHODIMP Skip(ULONG count) override {
     if (filter_->NoOfPins() - index_ > count) {
       index_ += count;
       return S_OK;
@@ -58,12 +58,12 @@ class PinEnumerator final : public IEnumPins,
     return S_FALSE;
   }
 
-  STDMETHODIMP Reset() override {
+  IFACEMETHODIMP Reset() override {
     index_ = 0;
     return S_OK;
   }
 
-  STDMETHODIMP Clone(IEnumPins** clone) override {
+  IFACEMETHODIMP Clone(IEnumPins** clone) override {
     PinEnumerator* pin_enum = new PinEnumerator(filter_.get());
     pin_enum->AddRef();
     pin_enum->index_ = index_;
@@ -82,17 +82,17 @@ class PinEnumerator final : public IEnumPins,
 FilterBase::FilterBase() : state_(State_Stopped) {
 }
 
-STDMETHODIMP FilterBase::EnumPins(IEnumPins** enum_pins) {
+HRESULT FilterBase::EnumPins(IEnumPins** enum_pins) {
   *enum_pins = new PinEnumerator(this);
   (*enum_pins)->AddRef();
   return S_OK;
 }
 
-STDMETHODIMP FilterBase::FindPin(LPCWSTR id, IPin** pin) {
+HRESULT FilterBase::FindPin(LPCWSTR id, IPin** pin) {
   return E_NOTIMPL;
 }
 
-STDMETHODIMP FilterBase::QueryFilterInfo(FILTER_INFO* info) {
+HRESULT FilterBase::QueryFilterInfo(FILTER_INFO* info) {
   info->pGraph = owning_graph_.Get();
   info->achName[0] = L'\0';
   if (info->pGraph)
@@ -100,52 +100,52 @@ STDMETHODIMP FilterBase::QueryFilterInfo(FILTER_INFO* info) {
   return S_OK;
 }
 
-STDMETHODIMP FilterBase::JoinFilterGraph(IFilterGraph* graph, LPCWSTR name) {
+HRESULT FilterBase::JoinFilterGraph(IFilterGraph* graph, LPCWSTR name) {
   owning_graph_ = graph;
   return S_OK;
 }
 
-STDMETHODIMP FilterBase::QueryVendorInfo(LPWSTR* pVendorInfo) {
+HRESULT FilterBase::QueryVendorInfo(LPWSTR* pVendorInfo) {
   return S_OK;
 }
 
 // Implement IMediaFilter.
-STDMETHODIMP FilterBase::Stop() {
+HRESULT FilterBase::Stop() {
   state_ = State_Stopped;
   return S_OK;
 }
 
-STDMETHODIMP FilterBase::Pause() {
+HRESULT FilterBase::Pause() {
   state_ = State_Paused;
   return S_OK;
 }
 
-STDMETHODIMP FilterBase::Run(REFERENCE_TIME start) {
+HRESULT FilterBase::Run(REFERENCE_TIME start) {
   state_ = State_Running;
   return S_OK;
 }
 
-STDMETHODIMP FilterBase::GetState(DWORD msec_timeout, FILTER_STATE* state) {
+HRESULT FilterBase::GetState(DWORD msec_timeout, FILTER_STATE* state) {
   *state = state_;
   return S_OK;
 }
 
-STDMETHODIMP FilterBase::SetSyncSource(IReferenceClock* clock) {
+HRESULT FilterBase::SetSyncSource(IReferenceClock* clock) {
   return S_OK;
 }
 
-STDMETHODIMP FilterBase::GetSyncSource(IReferenceClock** clock) {
+HRESULT FilterBase::GetSyncSource(IReferenceClock** clock) {
   return E_NOTIMPL;
 }
 
 // Implement from IPersistent.
-STDMETHODIMP FilterBase::GetClassID(CLSID* class_id) {
+HRESULT FilterBase::GetClassID(CLSID* class_id) {
   NOTREACHED();
   return E_NOTIMPL;
 }
 
 // Implement IUnknown.
-STDMETHODIMP FilterBase::QueryInterface(REFIID id, void** object_ptr) {
+HRESULT FilterBase::QueryInterface(REFIID id, void** object_ptr) {
   if (id == IID_IMediaFilter || id == IID_IUnknown) {
     *object_ptr = static_cast<IMediaFilter*>(this);
   } else if (id == IID_IPersist) {

media/capture/video/win/filter_base_win.h

@@ -29,36 +29,36 @@ class FilterBase : public IBaseFilter, public base::RefCounted<FilterBase> {
   virtual IPin* GetPin(int index) = 0;
 
   // Inherited from IUnknown.
-  STDMETHODIMP QueryInterface(REFIID id, void** object_ptr) override;
-  STDMETHODIMP_(ULONG) AddRef() override;
-  STDMETHODIMP_(ULONG) Release() override;
+  IFACEMETHODIMP QueryInterface(REFIID id, void** object_ptr) override;
+  IFACEMETHODIMP_(ULONG) AddRef() override;
+  IFACEMETHODIMP_(ULONG) Release() override;
 
   // Inherited from IBaseFilter.
-  STDMETHODIMP EnumPins(IEnumPins** enum_pins) override;
+  IFACEMETHODIMP EnumPins(IEnumPins** enum_pins) override;
 
-  STDMETHODIMP FindPin(LPCWSTR id, IPin** pin) override;
+  IFACEMETHODIMP FindPin(LPCWSTR id, IPin** pin) override;
 
-  STDMETHODIMP QueryFilterInfo(FILTER_INFO* info) override;
+  IFACEMETHODIMP QueryFilterInfo(FILTER_INFO* info) override;
 
-  STDMETHODIMP JoinFilterGraph(IFilterGraph* graph, LPCWSTR name) override;
+  IFACEMETHODIMP JoinFilterGraph(IFilterGraph* graph, LPCWSTR name) override;
 
-  STDMETHODIMP QueryVendorInfo(LPWSTR* vendor_info) override;
+  IFACEMETHODIMP QueryVendorInfo(LPWSTR* vendor_info) override;
 
   // Inherited from IMediaFilter.
-  STDMETHODIMP Stop() override;
+  IFACEMETHODIMP Stop() override;
 
-  STDMETHODIMP Pause() override;
+  IFACEMETHODIMP Pause() override;
 
-  STDMETHODIMP Run(REFERENCE_TIME start) override;
+  IFACEMETHODIMP Run(REFERENCE_TIME start) override;
 
-  STDMETHODIMP GetState(DWORD msec_timeout, FILTER_STATE* state) override;
+  IFACEMETHODIMP GetState(DWORD msec_timeout, FILTER_STATE* state) override;
 
-  STDMETHODIMP SetSyncSource(IReferenceClock* clock) override;
+  IFACEMETHODIMP SetSyncSource(IReferenceClock* clock) override;
 
-  STDMETHODIMP GetSyncSource(IReferenceClock** clock) override;
+  IFACEMETHODIMP GetSyncSource(IReferenceClock** clock) override;
 
   // Inherited from IPersistent.
-  STDMETHODIMP GetClassID(CLSID* class_id) override = 0;
+  IFACEMETHODIMP GetClassID(CLSID* class_id) override = 0;
 
  protected:
   friend class base::RefCounted<FilterBase>;

media/capture/video/win/pin_base_win.cc

@@ -15,7 +15,7 @@ class TypeEnumerator final : public IEnumMediaTypes,
   explicit TypeEnumerator(PinBase* pin) : pin_(pin), index_(0) {}
 
   // Implement from IUnknown.
-  STDMETHODIMP QueryInterface(REFIID iid, void** object_ptr) override {
+  IFACEMETHODIMP QueryInterface(REFIID iid, void** object_ptr) override {
     if (iid == IID_IEnumMediaTypes || iid == IID_IUnknown) {
       AddRef();
       *object_ptr = static_cast<IEnumMediaTypes*>(this);
@@ -24,20 +24,20 @@ class TypeEnumerator final : public IEnumMediaTypes,
     return E_NOINTERFACE;
   }
 
-  STDMETHODIMP_(ULONG) AddRef() override {
+  IFACEMETHODIMP_(ULONG) AddRef() override {
     base::RefCounted<TypeEnumerator>::AddRef();
     return 1;
   }
 
-  STDMETHODIMP_(ULONG) Release() override {
+  IFACEMETHODIMP_(ULONG) Release() override {
     base::RefCounted<TypeEnumerator>::Release();
     return 1;
   }
 
   // Implement IEnumMediaTypes.
-  STDMETHODIMP Next(ULONG count,
-                    AM_MEDIA_TYPE** types,
-                    ULONG* fetched) override {
+  IFACEMETHODIMP Next(ULONG count,
+                      AM_MEDIA_TYPE** types,
+                      ULONG* fetched) override {
     ULONG types_fetched = 0;
 
     while (types_fetched < count) {
@@ -76,17 +76,17 @@ class TypeEnumerator final : public IEnumMediaTypes,
     return types_fetched == count ? S_OK : S_FALSE;
   }
 
-  STDMETHODIMP Skip(ULONG count) override {
+  IFACEMETHODIMP Skip(ULONG count) override {
     index_ += count;
     return S_OK;
   }
 
-  STDMETHODIMP Reset() override {
+  IFACEMETHODIMP Reset() override {
     index_ = 0;
     return S_OK;
   }
 
-  STDMETHODIMP Clone(IEnumMediaTypes** clone) override {
+  IFACEMETHODIMP Clone(IEnumMediaTypes** clone) override {
     TypeEnumerator* type_enum = new TypeEnumerator(pin_.get());
     type_enum->AddRef();
     type_enum->index_ = index_;
@@ -119,8 +119,7 @@ void PinBase::SetOwner(IBaseFilter* owner) {
 
 // Called on an output pin to and establish a
 //   connection.
-STDMETHODIMP PinBase::Connect(IPin* receive_pin,
-                              const AM_MEDIA_TYPE* media_type) {
+HRESULT PinBase::Connect(IPin* receive_pin, const AM_MEDIA_TYPE* media_type) {
   if (!receive_pin || !media_type)
     return E_POINTER;
 
@@ -134,8 +133,8 @@ STDMETHODIMP PinBase::Connect(IPin* receive_pin,
 
 // Called from an output pin on an input pin to and establish a
 // connection.
-STDMETHODIMP PinBase::ReceiveConnection(IPin* connector,
-                                        const AM_MEDIA_TYPE* media_type) {
+HRESULT PinBase::ReceiveConnection(IPin* connector,
+                                   const AM_MEDIA_TYPE* media_type) {
   if (!IsMediaTypeValid(media_type))
     return VFW_E_TYPE_NOT_ACCEPTED;
 
@@ -145,7 +144,7 @@ STDMETHODIMP PinBase::ReceiveConnection(IPin* connector,
   return S_OK;
 }
 
-STDMETHODIMP PinBase::Disconnect() {
+HRESULT PinBase::Disconnect() {
   if (!connected_pin_.Get())
     return S_FALSE;
 
@@ -153,7 +152,7 @@ STDMETHODIMP PinBase::Disconnect() {
   return S_OK;
 }
 
-STDMETHODIMP PinBase::ConnectedTo(IPin** pin) {
+HRESULT PinBase::ConnectedTo(IPin** pin) {
   *pin = connected_pin_.Get();
   if (!connected_pin_.Get())
     return VFW_E_NOT_CONNECTED;
@@ -162,14 +161,14 @@ STDMETHODIMP PinBase::ConnectedTo(IPin** pin) {
   return S_OK;
 }
 
-STDMETHODIMP PinBase::ConnectionMediaType(AM_MEDIA_TYPE* media_type) {
+HRESULT PinBase::ConnectionMediaType(AM_MEDIA_TYPE* media_type) {
   if (!connected_pin_.Get())
     return VFW_E_NOT_CONNECTED;
   *media_type = current_media_type_;
   return S_OK;
 }
 
-STDMETHODIMP PinBase::QueryPinInfo(PIN_INFO* info) {
+HRESULT PinBase::QueryPinInfo(PIN_INFO* info) {
   info->dir = PINDIR_INPUT;
   info->pFilter = owner_;
   if (owner_)
@@ -179,67 +178,65 @@ STDMETHODIMP PinBase::QueryPinInfo(PIN_INFO* info) {
   return S_OK;
 }
 
-STDMETHODIMP PinBase::QueryDirection(PIN_DIRECTION* pin_dir) {
+HRESULT PinBase::QueryDirection(PIN_DIRECTION* pin_dir) {
   *pin_dir = PINDIR_INPUT;
   return S_OK;
 }
 
-STDMETHODIMP PinBase::QueryId(LPWSTR* id) {
+HRESULT PinBase::QueryId(LPWSTR* id) {
   NOTREACHED();
   return E_OUTOFMEMORY;
 }
 
-STDMETHODIMP PinBase::QueryAccept(const AM_MEDIA_TYPE* media_type) {
+HRESULT PinBase::QueryAccept(const AM_MEDIA_TYPE* media_type) {
   return S_FALSE;
 }
 
-STDMETHODIMP PinBase::EnumMediaTypes(IEnumMediaTypes** types) {
+HRESULT PinBase::EnumMediaTypes(IEnumMediaTypes** types) {
   *types = new TypeEnumerator(this);
   (*types)->AddRef();
   return S_OK;
 }
 
-STDMETHODIMP PinBase::QueryInternalConnections(IPin** pins, ULONG* no_pins) {
+HRESULT PinBase::QueryInternalConnections(IPin** pins, ULONG* no_pins) {
   return E_NOTIMPL;
 }
 
-STDMETHODIMP PinBase::EndOfStream() {
+HRESULT PinBase::EndOfStream() {
   return S_OK;
 }
 
-STDMETHODIMP PinBase::BeginFlush() {
+HRESULT PinBase::BeginFlush() {
   return S_OK;
 }
 
-STDMETHODIMP PinBase::EndFlush() {
+HRESULT PinBase::EndFlush() {
   return S_OK;
 }
 
-STDMETHODIMP PinBase::NewSegment(REFERENCE_TIME start,
-                                 REFERENCE_TIME stop,
-                                 double rate) {
+HRESULT PinBase::NewSegment(REFERENCE_TIME start,
+                            REFERENCE_TIME stop,
+                            double rate) {
   NOTREACHED();
   return E_NOTIMPL;
 }
 
 // Inherited from IMemInputPin.
-STDMETHODIMP PinBase::GetAllocator(IMemAllocator** allocator) {
+HRESULT PinBase::GetAllocator(IMemAllocator** allocator) {
   return VFW_E_NO_ALLOCATOR;
 }
 
-STDMETHODIMP PinBase::NotifyAllocator(IMemAllocator* allocator,
-                                      BOOL read_only) {
+HRESULT PinBase::NotifyAllocator(IMemAllocator* allocator, BOOL read_only) {
   return S_OK;
 }
 
-STDMETHODIMP PinBase::GetAllocatorRequirements(
-    ALLOCATOR_PROPERTIES* properties) {
+HRESULT PinBase::GetAllocatorRequirements(ALLOCATOR_PROPERTIES* properties) {
   return E_NOTIMPL;
 }
 
-STDMETHODIMP PinBase::ReceiveMultiple(IMediaSample** samples,
-                                      long sample_count,
-                                      long* processed) {
+HRESULT PinBase::ReceiveMultiple(IMediaSample** samples,
+                                 long sample_count,
+                                 long* processed) {
   DCHECK(samples);
 
   HRESULT hr = S_OK;
@@ -254,12 +251,12 @@ STDMETHODIMP PinBase::ReceiveMultiple(IMediaSample** samples,
   return hr;
 }
 
-STDMETHODIMP PinBase::ReceiveCanBlock() {
+HRESULT PinBase::ReceiveCanBlock() {
   return S_FALSE;
 }
 
 // Inherited from IUnknown.
-STDMETHODIMP PinBase::QueryInterface(REFIID id, void** object_ptr) {
+HRESULT PinBase::QueryInterface(REFIID id, void** object_ptr) {
   if (id == IID_IPin || id == IID_IUnknown) {
     *object_ptr = static_cast<IPin*>(this);
   } else if (id == IID_IMemInputPin) {
@@ -271,12 +268,12 @@ STDMETHODIMP PinBase::QueryInterface(REFIID id, void** object_ptr) {
   return S_OK;
 }
 
-STDMETHODIMP_(ULONG) PinBase::AddRef() {
+ULONG PinBase::AddRef() {
   base::RefCounted<PinBase>::AddRef();
   return 1;
 }
 
-STDMETHODIMP_(ULONG) PinBase::Release() {
+ULONG PinBase::Release() {
   base::RefCounted<PinBase>::Release();
   return 1;
 }

media/capture/video/win/pin_base_win.h

@@ -38,62 +38,62 @@ class PinBase : public IPin,
 
   // Called when new media is received. Note that this is not on the same
   // thread as where the pin is created.
-  STDMETHODIMP Receive(IMediaSample* sample) override = 0;
+  IFACEMETHODIMP Receive(IMediaSample* sample) override = 0;
 
-  STDMETHODIMP Connect(IPin* receive_pin,
-                       const AM_MEDIA_TYPE* media_type) override;
+  IFACEMETHODIMP Connect(IPin* receive_pin,
+                         const AM_MEDIA_TYPE* media_type) override;
 
-  STDMETHODIMP ReceiveConnection(IPin* connector,
-                                 const AM_MEDIA_TYPE* media_type) override;
+  IFACEMETHODIMP ReceiveConnection(IPin* connector,
+                                   const AM_MEDIA_TYPE* media_type) override;
 
-  STDMETHODIMP Disconnect() override;
+  IFACEMETHODIMP Disconnect() override;
 
-  STDMETHODIMP ConnectedTo(IPin** pin) override;
+  IFACEMETHODIMP ConnectedTo(IPin** pin) override;
 
-  STDMETHODIMP ConnectionMediaType(AM_MEDIA_TYPE* media_type) override;
+  IFACEMETHODIMP ConnectionMediaType(AM_MEDIA_TYPE* media_type) override;
 
-  STDMETHODIMP QueryPinInfo(PIN_INFO* info) override;
+  IFACEMETHODIMP QueryPinInfo(PIN_INFO* info) override;
 
-  STDMETHODIMP QueryDirection(PIN_DIRECTION* pin_dir) override;
+  IFACEMETHODIMP QueryDirection(PIN_DIRECTION* pin_dir) override;
 
-  STDMETHODIMP QueryId(LPWSTR* id) override;
+  IFACEMETHODIMP QueryId(LPWSTR* id) override;
 
-  STDMETHODIMP QueryAccept(const AM_MEDIA_TYPE* media_type) override;
+  IFACEMETHODIMP QueryAccept(const AM_MEDIA_TYPE* media_type) override;
 
-  STDMETHODIMP EnumMediaTypes(IEnumMediaTypes** types) override;
+  IFACEMETHODIMP EnumMediaTypes(IEnumMediaTypes** types) override;
 
-  STDMETHODIMP QueryInternalConnections(IPin** pins, ULONG* no_pins) override;
+  IFACEMETHODIMP QueryInternalConnections(IPin** pins, ULONG* no_pins) override;
 
-  STDMETHODIMP EndOfStream() override;
+  IFACEMETHODIMP EndOfStream() override;
 
-  STDMETHODIMP BeginFlush() override;
+  IFACEMETHODIMP BeginFlush() override;
 
-  STDMETHODIMP EndFlush() override;
+  IFACEMETHODIMP EndFlush() override;
 
-  STDMETHODIMP NewSegment(REFERENCE_TIME start,
-                          REFERENCE_TIME stop,
-                          double dRate) override;
+  IFACEMETHODIMP NewSegment(REFERENCE_TIME start,
+                            REFERENCE_TIME stop,
+                            double dRate) override;
 
   // Inherited from IMemInputPin.
-  STDMETHODIMP GetAllocator(IMemAllocator** allocator) override;
+  IFACEMETHODIMP GetAllocator(IMemAllocator** allocator) override;
 
-  STDMETHODIMP NotifyAllocator(IMemAllocator* allocator,
-                               BOOL read_only) override;
+  IFACEMETHODIMP NotifyAllocator(IMemAllocator* allocator,
+                                 BOOL read_only) override;
 
-  STDMETHODIMP GetAllocatorRequirements(
+  IFACEMETHODIMP GetAllocatorRequirements(
       ALLOCATOR_PROPERTIES* properties) override;
 
-  STDMETHODIMP ReceiveMultiple(IMediaSample** samples,
-                               long sample_count,
-                               long* processed) override;
-  STDMETHODIMP ReceiveCanBlock() override;
+  IFACEMETHODIMP ReceiveMultiple(IMediaSample** samples,
+                                 long sample_count,
+                                 long* processed) override;
+  IFACEMETHODIMP ReceiveCanBlock() override;
 
   // Inherited from IUnknown.
-  STDMETHODIMP QueryInterface(REFIID id, void** object_ptr) override;
+  IFACEMETHODIMP QueryInterface(REFIID id, void** object_ptr) override;
 
-  STDMETHODIMP_(ULONG) AddRef() override;
+  IFACEMETHODIMP_(ULONG) AddRef() override;
 
-  STDMETHODIMP_(ULONG) Release() override;
+  IFACEMETHODIMP_(ULONG) Release() override;
 
  protected:
   friend class base::RefCounted<PinBase>;

media/capture/video/win/sink_filter_win.cc

@@ -30,7 +30,7 @@ IPin* SinkFilter::GetPin(int index) {
   return index == 0 ? input_pin_.get() : nullptr;
 }
 
-STDMETHODIMP SinkFilter::GetClassID(CLSID* clsid) {
+HRESULT SinkFilter::GetClassID(CLSID* clsid) {
   *clsid = __uuidof(SinkFilter);
   return S_OK;
 }

media/capture/video/win/sink_filter_win.h

@@ -71,7 +71,7 @@ class __declspec(uuid("88cdbbdc-a73b-4afa-acbf-15d5e2ce12c3")) SinkFilter
   size_t NoOfPins() override;
   IPin* GetPin(int index) override;
 
-  STDMETHODIMP GetClassID(CLSID* clsid) override;
+  IFACEMETHODIMP GetClassID(CLSID* clsid) override;
 
  private:
   ~SinkFilter() override;

media/capture/video/win/sink_input_pin_win.h

@@ -32,7 +32,7 @@ class SinkInputPin : public PinBase {
   bool IsMediaTypeValid(const AM_MEDIA_TYPE* media_type) override;
   bool GetValidMediaType(int index, AM_MEDIA_TYPE* media_type) override;
 
-  STDMETHODIMP Receive(IMediaSample* media_sample) override;
+  IFACEMETHODIMP Receive(IMediaSample* media_sample) override;
 
  private:
   ~SinkInputPin() override;

media/capture/video/win/video_capture_device_mf_win.cc

@@ -42,7 +42,7 @@ class MFPhotoCallback final
                   VideoCaptureFormat format)
       : callback_(std::move(callback)), format_(format) {}
 
-  STDMETHODIMP QueryInterface(REFIID riid, void** object) override {
+  IFACEMETHODIMP QueryInterface(REFIID riid, void** object) override {
     if (riid == IID_IUnknown || riid == IID_IMFCaptureEngineOnSampleCallback) {
       AddRef();
       *object = static_cast<IMFCaptureEngineOnSampleCallback*>(this);
@@ -51,17 +51,17 @@ class MFPhotoCallback final
     return E_NOINTERFACE;
   }
 
-  STDMETHODIMP_(ULONG) AddRef() override {
+  IFACEMETHODIMP_(ULONG) AddRef() override {
     base::RefCountedThreadSafe<MFPhotoCallback>::AddRef();
     return 1U;
   }
 
-  STDMETHODIMP_(ULONG) Release() override {
+  IFACEMETHODIMP_(ULONG) Release() override {
     base::RefCountedThreadSafe<MFPhotoCallback>::Release();
     return 1U;
   }
 
-  STDMETHODIMP OnSample(IMFSample* sample) override {
+  IFACEMETHODIMP OnSample(IMFSample* sample) override {
     if (!sample)
       return S_OK;
 
@@ -354,7 +354,7 @@ class MFVideoCallback final
  public:
   MFVideoCallback(VideoCaptureDeviceMFWin* observer) : observer_(observer) {}
 
-  STDMETHODIMP QueryInterface(REFIID riid, void** object) override {
+  IFACEMETHODIMP QueryInterface(REFIID riid, void** object) override {
     HRESULT hr = E_NOINTERFACE;
     if (riid == IID_IUnknown) {
       *object = this;
@@ -372,22 +372,22 @@ class MFVideoCallback final
     return hr;
   }
 
-  STDMETHODIMP_(ULONG) AddRef() override {
+  IFACEMETHODIMP_(ULONG) AddRef() override {
     base::RefCountedThreadSafe<MFVideoCallback>::AddRef();
     return 1U;
   }
 
-  STDMETHODIMP_(ULONG) Release() override {
+  IFACEMETHODIMP_(ULONG) Release() override {
     base::RefCountedThreadSafe<MFVideoCallback>::Release();
     return 1U;
   }
 
-  STDMETHODIMP OnEvent(IMFMediaEvent* media_event) override {
+  IFACEMETHODIMP OnEvent(IMFMediaEvent* media_event) override {
     observer_->OnEvent(media_event);
     return S_OK;
   }
 
-  STDMETHODIMP OnSample(IMFSample* sample) override {
+  IFACEMETHODIMP OnSample(IMFSample* sample) override {
     if (!sample) {
       observer_->OnFrameDropped(
           VideoCaptureFrameDropReason::kWinMediaFoundationReceivedSampleIsNull);