Rename ScopedComPtr::QueryInterface to ScopedComPtr::CopyTo

gpu/ipc/service/direct_composition_surface_win.cc

 // Copyright 2017 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 "gpu/ipc/service/direct_composition_surface_win.h"
 
 #include <d3d11_1.h>
 #include <dcomptypes.h>
 
 #include <deque>
@@ skipping 107 matching lines @@
   // Before Windows 10 Anniversary Update (Redstone 1), overlay planes
   // wouldn't be assigned to non-UWP apps.
   if (base::win::GetVersion() < base::win::VERSION_WIN10_R1)
     return false;
 
   base::win::ScopedComPtr<ID3D11Device> d3d11_device =
       gl::QueryD3D11DeviceObjectFromANGLE();
   DCHECK(d3d11_device);
 
   base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
-  d3d11_device.QueryInterface(dxgi_device.Receive());
+  d3d11_device.CopyTo(dxgi_device.Receive());
   base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
   dxgi_device->GetAdapter(dxgi_adapter.Receive());
 
   unsigned int i = 0;
   while (true) {
     base::win::ScopedComPtr<IDXGIOutput> output;
     if (FAILED(dxgi_adapter->EnumOutputs(i++, output.Receive())))
       break;
     base::win::ScopedComPtr<IDXGIOutput3> output3;
-    if (FAILED(output.QueryInterface(output3.Receive())))
+    if (FAILED(output.CopyTo(output3.Receive())))
       continue;
 
     UINT flags = 0;
     if (FAILED(output3->CheckOverlaySupport(DXGI_FORMAT_YUY2,
                                             d3d11_device.Get(), &flags)))
       continue;
 
     // Direct-only support might be ok in some circumstances, but since the
     // overlay processor isn't set up to try to distinguish, only try to use
     // overlays when scaling's enabled.
@@ skipping 141 matching lines @@
       video_processor_enumerator_;
   base::win::ScopedComPtr<ID3D11VideoDevice> video_device_;
   base::win::ScopedComPtr<ID3D11VideoContext> video_context_;
 
   base::win::ScopedHandle swap_chain_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(SwapChainPresenter);
 };
 
 bool DCLayerTree::Initialize(HWND window) {
-  d3d11_device_.QueryInterface(video_device_.Receive());
+  d3d11_device_.CopyTo(video_device_.Receive());
   base::win::ScopedComPtr<ID3D11DeviceContext> context;
   d3d11_device_->GetImmediateContext(context.Receive());
-  context.QueryInterface(video_context_.Receive());
+  context.CopyTo(video_context_.Receive());
 
   base::win::ScopedComPtr<IDCompositionDesktopDevice> desktop_device;
-  dcomp_device_.QueryInterface(desktop_device.Receive());
+  dcomp_device_.CopyTo(desktop_device.Receive());
 
   HRESULT hr = desktop_device->CreateTargetForHwnd(window, TRUE,
                                                    dcomp_target_.Receive());
   if (FAILED(hr))
     return false;
 
   hr = dcomp_device_->CreateVisual(root_visual_.Receive());
   if (FAILED(hr))
     return false;
 
@@ skipping 35 matching lines @@
 DCLayerTree::GetLayerSwapChainForTesting(size_t index) const {
   if (index >= visual_info_.size())
     return base::win::ScopedComPtr<IDXGISwapChain1>();
   return visual_info_[index].swap_chain;
 }
 
 DCLayerTree::SwapChainPresenter::SwapChainPresenter(
     DCLayerTree* surface,
     base::win::ScopedComPtr<ID3D11Device> d3d11_device)
     : surface_(surface), d3d11_device_(d3d11_device) {
-  d3d11_device_.QueryInterface(video_device_.Receive());
+  d3d11_device_.CopyTo(video_device_.Receive());
   base::win::ScopedComPtr<ID3D11DeviceContext> context;
   d3d11_device_->GetImmediateContext(context.Receive());
-  context.QueryInterface(video_context_.Receive());
+  context.CopyTo(video_context_.Receive());
   HMODULE dcomp = ::GetModuleHandleA("dcomp.dll");
   CHECK(dcomp);
   create_surface_handle_function_ =
       reinterpret_cast<PFN_DCOMPOSITION_CREATE_SURFACE_HANDLE>(
           GetProcAddress(dcomp, "DCompositionCreateSurfaceHandle"));
   CHECK(create_surface_handle_function_);
 }
 
 DCLayerTree::SwapChainPresenter::~SwapChainPresenter() {}
 
@@ skipping 64 matching lines @@
     out_desc.Texture2D.MipSlice = 0;
     HRESULT hr = video_device_->CreateVideoProcessorOutputView(
         texture.Get(), video_processor_enumerator_.Get(), &out_desc,
         out_view_.Receive());
     CHECK(SUCCEEDED(hr));
   }
 
   // TODO(jbauman): Use correct colorspace.
   gfx::ColorSpace src_color_space = gfx::ColorSpace::CreateREC709();
   base::win::ScopedComPtr<ID3D11VideoContext1> context1;
-  if (SUCCEEDED(video_context_.QueryInterface(context1.Receive()))) {
+  if (SUCCEEDED(video_context_.CopyTo(context1.Receive()))) {
     context1->VideoProcessorSetStreamColorSpace1(
         video_processor_.Get(), 0,
         gfx::ColorSpaceWin::GetDXGIColorSpace(src_color_space));
   } else {
     // This can't handle as many different types of color spaces, so use it
     // only if ID3D11VideoContext1 isn't available.
     D3D11_VIDEO_PROCESSOR_COLOR_SPACE color_space =
         gfx::ColorSpaceWin::GetD3D11ColorSpace(src_color_space);
     video_context_->VideoProcessorSetStreamColorSpace(video_processor_.Get(), 0,
                                                       &color_space);
   }
 
   gfx::ColorSpace output_color_space =
       is_yuy2_swapchain_ ? src_color_space : gfx::ColorSpace::CreateSRGB();
   if (base::FeatureList::IsEnabled(kFallbackBT709VideoToBT601) &&
       (output_color_space == gfx::ColorSpace::CreateREC709())) {
     output_color_space = gfx::ColorSpace::CreateREC601();
   }
 
   base::win::ScopedComPtr<IDXGISwapChain3> swap_chain3;
-  if (SUCCEEDED(swap_chain_.QueryInterface(swap_chain3.Receive()))) {
+  if (SUCCEEDED(swap_chain_.CopyTo(swap_chain3.Receive()))) {
     DXGI_COLOR_SPACE_TYPE color_space =
         gfx::ColorSpaceWin::GetDXGIColorSpace(output_color_space);
     HRESULT hr = swap_chain3->SetColorSpace1(color_space);
     CHECK(SUCCEEDED(hr));
     if (context1) {
       context1->VideoProcessorSetOutputColorSpace1(video_processor_.Get(),
                                                    color_space);
     } else {
       D3D11_VIDEO_PROCESSOR_COLOR_SPACE d3d11_color_space =
           gfx::ColorSpaceWin::GetD3D11ColorSpace(output_color_space);
@@ skipping 60 matching lines @@
     context->CopyResource(dest_texture.Get(), src_texture.Get());
   }
 
   swap_chain_->Present(1, 0);
 
   UMA_HISTOGRAM_BOOLEAN("GPU.DirectComposition.SwapchainFormat",
                         is_yuy2_swapchain_);
   frames_since_color_space_change_++;
 
   base::win::ScopedComPtr<IDXGISwapChainMedia> swap_chain_media;
-  if (SUCCEEDED(swap_chain_.QueryInterface(swap_chain_media.Receive()))) {
+  if (SUCCEEDED(swap_chain_.CopyTo(swap_chain_media.Receive()))) {
     DXGI_FRAME_STATISTICS_MEDIA stats = {};
     if (SUCCEEDED(swap_chain_media->GetFrameStatisticsMedia(&stats))) {
       UMA_HISTOGRAM_SPARSE_SLOWLY("GPU.DirectComposition.CompositionMode",
                                   stats.CompositionMode);
       presentation_history_.AddSample(stats.CompositionMode);
     }
   }
 }
 
 bool DCLayerTree::SwapChainPresenter::InitializeVideoProcessor(
@@ skipping 12 matching lines @@
   // recreated if the enumerator is.
   out_view_.Reset();
   return true;
 }
 
 void DCLayerTree::SwapChainPresenter::ReallocateSwapChain(bool yuy2) {
   TRACE_EVENT0("gpu", "DCLayerTree::SwapChainPresenter::ReallocateSwapChain");
   DCHECK(!swap_chain_);
 
   base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
-  d3d11_device_.QueryInterface(dxgi_device.Receive());
+  d3d11_device_.CopyTo(dxgi_device.Receive());
   base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
   dxgi_device->GetAdapter(dxgi_adapter.Receive());
   base::win::ScopedComPtr<IDXGIFactory2> dxgi_factory;
   dxgi_adapter->GetParent(IID_PPV_ARGS(dxgi_factory.Receive()));
 
   base::win::ScopedComPtr<IDXGIFactoryMedia> media_factory;
-  dxgi_factory.QueryInterface(media_factory.Receive());
+  dxgi_factory.CopyTo(media_factory.Receive());
   DXGI_SWAP_CHAIN_DESC1 desc = {};
   desc.Width = swap_chain_size_.width();
   desc.Height = swap_chain_size_.height();
   desc.Format = DXGI_FORMAT_YUY2;
   desc.Stereo = FALSE;
   desc.SampleDesc.Count = 1;
   desc.BufferCount = 2;
   desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
   desc.Scaling = DXGI_SCALING_STRETCH;
   desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
@@ skipping 311 matching lines @@
     // become transparent.
     HRESULT hr = dcomp_device_->CreateSurface(
         size_.width(), size_.height(), output_format,
         DXGI_ALPHA_MODE_PREMULTIPLIED, dcomp_surface_.Receive());
     has_been_rendered_to_ = false;
     CHECK(SUCCEEDED(hr));
   } else {
     DXGI_ALPHA_MODE alpha_mode =
         has_alpha_ ? DXGI_ALPHA_MODE_PREMULTIPLIED : DXGI_ALPHA_MODE_IGNORE;
     base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
-    d3d11_device_.QueryInterface(dxgi_device.Receive());
+    d3d11_device_.CopyTo(dxgi_device.Receive());
     base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
     dxgi_device->GetAdapter(dxgi_adapter.Receive());
     base::win::ScopedComPtr<IDXGIFactory2> dxgi_factory;
     dxgi_adapter->GetParent(IID_PPV_ARGS(dxgi_factory.Receive()));
 
     DXGI_SWAP_CHAIN_DESC1 desc = {};
     desc.Width = size_.width();
     desc.Height = size_.height();
     desc.Format = output_format;
     desc.Stereo = FALSE;
@@ skipping 26 matching lines @@
       DXGI_PRESENT_PARAMETERS params = {};
       RECT dirty_rect = swap_rect_.ToRECT();
       params.DirtyRectsCount = 1;
       params.pDirtyRects = &dirty_rect;
       swap_chain_->Present1(first_swap_ ? 0 : 1, 0, &params);
       if (first_swap_) {
         // Wait for the GPU to finish executing its commands before
         // committing the DirectComposition tree, or else the swapchain
         // may flicker black when it's first presented.
         base::win::ScopedComPtr<IDXGIDevice2> dxgi_device2;
-        HRESULT hr = d3d11_device_.QueryInterface(dxgi_device2.Receive());
+        HRESULT hr = d3d11_device_.CopyTo(dxgi_device2.Receive());
         DCHECK(SUCCEEDED(hr));
         base::WaitableEvent event(
             base::WaitableEvent::ResetPolicy::AUTOMATIC,
             base::WaitableEvent::InitialState::NOT_SIGNALED);
         dxgi_device2->EnqueueSetEvent(event.handle());
         event.Wait();
         first_swap_ = false;
       }
     }
   }
@@ skipping 188 matching lines @@
 DirectCompositionSurfaceWin::GetWindowTaskRunnerForTesting() {
   return child_window_.GetTaskRunnerForTesting();
 }
 
 base::win::ScopedComPtr<IDXGISwapChain1>
 DirectCompositionSurfaceWin::GetLayerSwapChainForTesting(size_t index) const {
   return layer_tree_->GetLayerSwapChainForTesting(index);
 }
 
 }  // namespace gpu