Migrate IID Coupled Uses of ScopedComPtr::ReceiveVoid() to IID_PPV_ARGS

media/gpu/dxva_video_decode_accelerator_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/gpu/dxva_video_decode_accelerator_win.h"
 
 #include <memory>
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif  // !defined(OS_WIN)
 
 #include <codecapi.h>
 #include <dxgi1_2.h>
 #include <ks.h>
 #include <mfapi.h>
 #include <mferror.h>
 #include <ntverp.h>
+#include <objbase.h>
 #include <stddef.h>
 #include <string.h>
 #include <wmcodecdsp.h>
 
 #include "base/atomicops.h"
 #include "base/base_paths_win.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 300 matching lines @@
 
   using GetClassObject =
       HRESULT(WINAPI*)(const CLSID& clsid, const IID& iid, void** object);
 
   GetClassObject get_class_object = reinterpret_cast<GetClassObject>(
       GetProcAddress(dll, "DllGetClassObject"));
   RETURN_ON_FAILURE(get_class_object, "Failed to get DllGetClassObject pointer",
                     E_FAIL);
 
   base::win::ScopedComPtr<IClassFactory> factory;
-  HRESULT hr =
-      get_class_object(clsid, __uuidof(IClassFactory), factory.ReceiveVoid());
+  HRESULT hr = get_class_object(clsid, IID_PPV_ARGS(&factory));
   RETURN_ON_HR_FAILURE(hr, "DllGetClassObject failed", hr);
 
   hr = factory->CreateInstance(NULL, iid, object);
   return hr;
 }
 
 H264ConfigChangeDetector::H264ConfigChangeDetector()
     : last_sps_id_(0),
       last_pps_id_(0),
       config_changed_(false),
@@ skipping 363 matching lines @@
 }
 
 bool DXVAVideoDecodeAccelerator::CreateVideoProcessor() {
   if (!use_color_info_)
     return false;
 
   // TODO(Hubbe): Don't try again if we tried and failed already.
   if (video_processor_service_.Get())
     return true;
   HRESULT hr = DXVA2CreateVideoService(d3d9_device_ex_.Get(),
-                                       IID_IDirectXVideoProcessorService,
-                                       video_processor_service_.ReceiveVoid());
+                                       IID_PPV_ARGS(&video_processor_service_));
   RETURN_ON_HR_FAILURE(hr, "DXVA2CreateVideoService failed", false);
 
   // TODO(Hubbe): Use actual video settings.
   DXVA2_VideoDesc inputDesc;
   inputDesc.SampleWidth = 1920;
   inputDesc.SampleHeight = 1080;
   inputDesc.SampleFormat.VideoChromaSubsampling =
       DXVA2_VideoChromaSubsampling_MPEG2;
   inputDesc.SampleFormat.NominalRange = DXVA2_NominalRange_16_235;
   inputDesc.SampleFormat.VideoTransferMatrix = DXVA2_VideoTransferMatrix_BT709;
@@ skipping 566 matching lines @@
   {
     TRACE_EVENT0("gpu,startup",
                  "GetMaxH264Resolution. QueryDeviceObjectFromANGLE");
 
     device = gl::QueryD3D11DeviceObjectFromANGLE();
     if (!device.Get())
       return max_resolution;
   }
 
   base::win::ScopedComPtr<ID3D11VideoDevice> video_device;
-  hr = device.QueryInterface(__uuidof(ID3D11VideoDevice),
-                             video_device.ReceiveVoid());
+  hr = device.QueryInterface(IID_PPV_ARGS(&video_device));
   if (FAILED(hr))
     return max_resolution;
 
   GUID decoder_guid = {};
 
   {
     TRACE_EVENT0("gpu,startup",
                  "GetMaxH264Resolution. H.264 guid search begin");
     // Enumerate supported video profiles and look for the H264 profile.
     bool found = false;
@@ skipping 178 matching lines @@
         decoder_dll = ::LoadLibraryEx(dll_path.value().data(), NULL,
                                       LOAD_WITH_ALTERED_SEARCH_PATH);
       }
     }
   }
 
   if (!decoder_dll) {
     RETURN_ON_FAILURE(false, "Unsupported codec.", false);
   }
 
-  HRESULT hr = CreateCOMObjectFromDll(
-      decoder_dll, clsid, __uuidof(IMFTransform), decoder_.ReceiveVoid());
+  HRESULT hr = CreateCOMObjectFromDll(decoder_dll, clsid,
+                                      IID_PPV_ARGS(&decoder_));
   RETURN_ON_HR_FAILURE(hr, "Failed to create decoder instance", false);
 
   RETURN_ON_FAILURE(CheckDecoderDxvaSupport(),
                     "Failed to check decoder DXVA support", false);
 
   ULONG_PTR device_manager_to_use = NULL;
   if (use_dx11_) {
     CHECK(create_dxgi_device_manager_);
     RETURN_AND_NOTIFY_ON_FAILURE(CreateDX11DevManager(),
                                  "Failed to initialize DX11 device and manager",
@@ skipping 1462 matching lines @@
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 uint32_t DXVAVideoDecodeAccelerator::GetTextureTarget() const {
   bool provide_nv12_textures = share_nv12_textures_ || copy_nv12_textures_;
   return provide_nv12_textures ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
 }
 
 }  // namespace media