Rename ScopedComPtr::QueryInterface to ScopedComPtr::CopyTo

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 829 matching lines @@
     }
 #endif
     if (!d3d11_device_context_) {
       hr = D3D11CreateDevice(
           NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, flags, feature_levels,
           arraysize(feature_levels), D3D11_SDK_VERSION, d3d11_device_.Receive(),
           &feature_level_out, d3d11_device_context_.Receive());
       RETURN_ON_HR_FAILURE(hr, "Failed to create DX11 device", false);
     }
 
-    hr = d3d11_device_.QueryInterface(video_device_.Receive());
+    hr = d3d11_device_.CopyTo(video_device_.Receive());
     RETURN_ON_HR_FAILURE(hr, "Failed to get video device", false);
 
-    hr = d3d11_device_context_.QueryInterface(video_context_.Receive());
+    hr = d3d11_device_context_.CopyTo(video_context_.Receive());
     RETURN_ON_HR_FAILURE(hr, "Failed to get video context", false);
   }
 
   D3D11_FEATURE_DATA_D3D11_OPTIONS options;
   hr = D3D11Device()->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS, &options,
                                           sizeof(options));
   RETURN_ON_HR_FAILURE(hr, "Failed to retrieve D3D11 options", false);
 
   // Need extended resource sharing so we can share the NV12 texture between
   // ANGLE and the decoder context.
@@ skipping 438 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(IID_PPV_ARGS(&video_device));
+  hr = device.CopyTo(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 1527 matching lines @@
     video_context_->VideoProcessorSetOutputColorSpace(d3d11_processor_.Get(),
                                                       &d3d11_color_space);
 
     video_context_->VideoProcessorSetStreamColorSpace(d3d11_processor_.Get(), 0,
                                                       &d3d11_color_space);
     dx11_converter_output_color_space_ = color_space;
   } else {
     dx11_converter_output_color_space_ = gfx::ColorSpace::CreateSRGB();
     if (use_color_info_ || use_fp16_) {
       base::win::ScopedComPtr<ID3D11VideoContext1> video_context1;
-      HRESULT hr = video_context_.QueryInterface(video_context1.Receive());
+      HRESULT hr = video_context_.CopyTo(video_context1.Receive());
       if (SUCCEEDED(hr)) {
         if (use_fp16_ &&
             base::CommandLine::ForCurrentProcess()->HasSwitch(
                 switches::kEnableHDR) &&
             color_space.IsHDR()) {
           // Note, we only use the SCRGBLinear output color space when
           // the input is PQ, because nvidia drivers will not convert
           // G22 to G10 for some reason.
           dx11_converter_output_color_space_ =
               gfx::ColorSpace::CreateSCRGBLinear();
@@ skipping 146 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