Remove ScopedComPtr::QueryFrom()

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.
@@ skipping 653 matching lines @@
       static_cast<D3DFORMAT>(MAKEFOURCC('N', 'V', '1', '2')), D3DFMT_X8R8G8B8);
   RETURN_ON_HR_FAILURE(hr, "D3D9 driver does not support H/W format conversion",
                        false);
 
   base::win::ScopedComPtr<IDirect3DDevice9> angle_device =
       gl::QueryD3D9DeviceObjectFromANGLE();
   if (angle_device.Get())
     using_angle_device_ = true;
 
   if (using_angle_device_) {
-    hr = d3d9_device_ex_.QueryFrom(angle_device.Get());
+    hr = angle_device.CopyTo(d3d9_device_ex_.GetAddressOf());
     RETURN_ON_HR_FAILURE(
         hr, "QueryInterface for IDirect3DDevice9Ex from angle device failed",
         false);
   } else {
     D3DPRESENT_PARAMETERS present_params = {0};
     present_params.BackBufferWidth = 1;
     present_params.BackBufferHeight = 1;
     present_params.BackBufferFormat = D3DFMT_UNKNOWN;
     present_params.BackBufferCount = 1;
     present_params.SwapEffect = D3DSWAPEFFECT_DISCARD;
@@ skipping 195 matching lines @@
   hr = D3D11Device()->CheckFormatSupport(DXGI_FORMAT_R16G16B16A16_FLOAT,
                                          &fp16_format_support);
   if (FAILED(hr) ||
       !(fp16_format_support & D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_OUTPUT))
     use_fp16_ = false;
 
   // Enable multithreaded mode on the device. This ensures that accesses to
   // context are synchronized across threads. We have multiple threads
   // accessing the context, the media foundation decoder threads and the
   // decoder thread via the video format conversion transform.
-  hr = multi_threaded_.QueryFrom(D3D11Device());
+  hr = D3D11Device()->QueryInterface(IID_PPV_ARGS(&multi_threaded_));
   RETURN_ON_HR_FAILURE(hr, "Failed to query ID3D10Multithread", false);
   multi_threaded_->SetMultithreadProtected(TRUE);
 
   hr = d3d11_device_manager_->ResetDevice(D3D11Device(),
                                           dx11_dev_manager_reset_token_);
   RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
 
   D3D11_QUERY_DESC query_desc;
   query_desc.Query = D3D11_QUERY_EVENT;
   query_desc.MiscFlags = 0;
@@ skipping 496 matching lines @@
   static bool legacy_gpu = true;
   // This flag ensures that we determine the GPU type once.
   static bool legacy_gpu_determined = false;
 
   if (legacy_gpu_determined)
     return legacy_gpu;
 
   legacy_gpu_determined = true;
 
   base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
-  HRESULT hr = dxgi_device.QueryFrom(device);
+  HRESULT hr = device->QueryInterface(IID_PPV_ARGS(&dxgi_device));
   if (FAILED(hr))
     return legacy_gpu;
 
   base::win::ScopedComPtr<IDXGIAdapter> adapter;
   hr = dxgi_device->GetAdapter(adapter.GetAddressOf());
   if (FAILED(hr))
     return legacy_gpu;
 
   DXGI_ADAPTER_DESC adapter_desc = {};
   hr = adapter->GetDesc(&adapter_desc);
@@ skipping 534 matching lines @@
       HRESULT hr = pending_sample->output_sample->GetBufferByIndex(
           0, output_buffer.GetAddressOf());
       RETURN_AND_NOTIFY_ON_HR_FAILURE(
           hr, "Failed to get buffer from output sample", PLATFORM_FAILURE, );
 
       base::win::ScopedComPtr<IDirect3DSurface9> surface;
       base::win::ScopedComPtr<ID3D11Texture2D> d3d11_texture;
 
       if (use_dx11_) {
         base::win::ScopedComPtr<IMFDXGIBuffer> dxgi_buffer;
-        hr = dxgi_buffer.QueryFrom(output_buffer.Get());
+        hr = output_buffer.CopyTo(dxgi_buffer.GetAddressOf());
         RETURN_AND_NOTIFY_ON_HR_FAILURE(
             hr, "Failed to get DXGIBuffer from output sample",
             PLATFORM_FAILURE, );
         hr = dxgi_buffer->GetResource(
             __uuidof(ID3D11Texture2D),
             reinterpret_cast<void**>(d3d11_texture.GetAddressOf()));
       } else {
         hr = MFGetService(output_buffer.Get(), MR_BUFFER_SERVICE,
                           IID_PPV_ARGS(surface.GetAddressOf()));
       }
@@ skipping 714 matching lines @@
         hr == S_OK, "D3D11 failed to acquire keyed mutex for texture.",
         PLATFORM_FAILURE, );
   }
 
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   hr = input_sample->GetBufferByIndex(0, output_buffer.GetAddressOf());
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to get buffer from output sample",
                                   PLATFORM_FAILURE, );
 
   base::win::ScopedComPtr<IMFDXGIBuffer> dxgi_buffer;
-  hr = dxgi_buffer.QueryFrom(output_buffer.Get());
+  hr = output_buffer.CopyTo(dxgi_buffer.GetAddressOf());
   RETURN_AND_NOTIFY_ON_HR_FAILURE(
       hr, "Failed to get DXGIBuffer from output sample", PLATFORM_FAILURE, );
   UINT index = 0;
   hr = dxgi_buffer->GetSubresourceIndex(&index);
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to get resource index",
                                   PLATFORM_FAILURE, );
 
   base::win::ScopedComPtr<ID3D11Texture2D> dx11_decoding_texture;
   hr = dxgi_buffer->GetResource(
       IID_PPV_ARGS(dx11_decoding_texture.GetAddressOf()));
@@ skipping 217 matching lines @@
 bool DXVAVideoDecodeAccelerator::GetVideoFrameDimensions(IMFSample* sample,
                                                          int* width,
                                                          int* height) {
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   HRESULT hr = sample->GetBufferByIndex(0, output_buffer.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from output sample", false);
 
   if (use_dx11_) {
     base::win::ScopedComPtr<IMFDXGIBuffer> dxgi_buffer;
     base::win::ScopedComPtr<ID3D11Texture2D> d3d11_texture;
-    hr = dxgi_buffer.QueryFrom(output_buffer.Get());
+    hr = output_buffer.CopyTo(dxgi_buffer.GetAddressOf());
     RETURN_ON_HR_FAILURE(hr, "Failed to get DXGIBuffer from output sample",
                          false);
     hr = dxgi_buffer->GetResource(
         __uuidof(ID3D11Texture2D),
         reinterpret_cast<void**>(d3d11_texture.GetAddressOf()));
     RETURN_ON_HR_FAILURE(hr, "Failed to get D3D11Texture from output buffer",
                          false);
     D3D11_TEXTURE2D_DESC d3d11_texture_desc;
     d3d11_texture->GetDesc(&d3d11_texture_desc);
     *width = d3d11_texture_desc.Width;
@@ skipping 78 matching lines @@
 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;
 }
 
 ID3D11Device* DXVAVideoDecodeAccelerator::D3D11Device() const {
   return share_nv12_textures_ ? angle_device_.Get() : d3d11_device_.Get();
 }
 
 }  // namespace media