Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

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 112 matching lines @@
 
   base::win::ScopedComPtr<ID3D11Device> d3d11_device =
       gl::QueryD3D11DeviceObjectFromANGLE();
   if (!d3d11_device) {
     DLOG(ERROR) << "Failing to create overlay swapchain because couldn't "
                    "retrieve D3D11 device from ANGLE.";
     return false;
   }
 
   base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
-  d3d11_device.CopyTo(dxgi_device.Receive());
+  d3d11_device.CopyTo(dxgi_device.GetAddressOf());
   base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
-  dxgi_device->GetAdapter(dxgi_adapter.Receive());
+  dxgi_device->GetAdapter(dxgi_adapter.GetAddressOf());
 
   unsigned int i = 0;
   while (true) {
     base::win::ScopedComPtr<IDXGIOutput> output;
-    if (FAILED(dxgi_adapter->EnumOutputs(i++, output.Receive())))
+    if (FAILED(dxgi_adapter->EnumOutputs(i++, output.GetAddressOf())))
       break;
     base::win::ScopedComPtr<IDXGIOutput3> output3;
-    if (FAILED(output.CopyTo(output3.Receive())))
+    if (FAILED(output.CopyTo(output3.GetAddressOf())))
       continue;
 
     UINT flags = 0;
     if (FAILED(output3->CheckOverlaySupport(DXGI_FORMAT_YUY2,
                                             d3d11_device.Get(), &flags)))
       continue;
 
     UMA_HISTOGRAM_SPARSE_SLOWLY("GPU.DirectComposition.OverlaySupportFlags",
                                 flags);
 
@@ skipping 152 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_.CopyTo(video_device_.Receive());
+  d3d11_device_.CopyTo(video_device_.GetAddressOf());
   base::win::ScopedComPtr<ID3D11DeviceContext> context;
-  d3d11_device_->GetImmediateContext(context.Receive());
-  context.CopyTo(video_context_.Receive());
+  d3d11_device_->GetImmediateContext(context.GetAddressOf());
+  context.CopyTo(video_context_.GetAddressOf());
 
   base::win::ScopedComPtr<IDCompositionDesktopDevice> desktop_device;
-  dcomp_device_.CopyTo(desktop_device.Receive());
+  dcomp_device_.CopyTo(desktop_device.GetAddressOf());
 
-  HRESULT hr = desktop_device->CreateTargetForHwnd(window, TRUE,
-                                                   dcomp_target_.Receive());
+  HRESULT hr = desktop_device->CreateTargetForHwnd(
+      window, TRUE, dcomp_target_.GetAddressOf());
   if (FAILED(hr))
     return false;
 
-  hr = dcomp_device_->CreateVisual(root_visual_.Receive());
+  hr = dcomp_device_->CreateVisual(root_visual_.GetAddressOf());
   if (FAILED(hr))
     return false;
 
   dcomp_target_->SetRoot(root_visual_.Get());
   return true;
 }
 
 void DCLayerTree::InitializeVideoProcessor(const gfx::Size& input_size,
                                            const gfx::Size& output_size) {
   if (SizeContains(video_input_size_, input_size) &&
       SizeContains(video_output_size_, output_size))
     return;
   video_input_size_ = input_size;
   video_output_size_ = output_size;
 
   video_processor_.Reset();
   video_processor_enumerator_.Reset();
   D3D11_VIDEO_PROCESSOR_CONTENT_DESC desc = {};
   desc.InputFrameFormat = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
   desc.InputFrameRate.Numerator = 60;
   desc.InputFrameRate.Denominator = 1;
   desc.InputWidth = input_size.width();
   desc.InputHeight = input_size.height();
   desc.OutputFrameRate.Numerator = 60;
   desc.OutputFrameRate.Denominator = 1;
   desc.OutputWidth = output_size.width();
   desc.OutputHeight = output_size.height();
   desc.Usage = D3D11_VIDEO_USAGE_PLAYBACK_NORMAL;
   HRESULT hr = video_device_->CreateVideoProcessorEnumerator(
-      &desc, video_processor_enumerator_.Receive());
+      &desc, video_processor_enumerator_.GetAddressOf());
   CHECK(SUCCEEDED(hr));
 
   hr = video_device_->CreateVideoProcessor(video_processor_enumerator_.Get(), 0,
-                                           video_processor_.Receive());
+                                           video_processor_.GetAddressOf());
   CHECK(SUCCEEDED(hr));
 }
 
 base::win::ScopedComPtr<IDXGISwapChain1>
 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_.CopyTo(video_device_.Receive());
+  d3d11_device_.CopyTo(video_device_.GetAddressOf());
   base::win::ScopedComPtr<ID3D11DeviceContext> context;
-  d3d11_device_->GetImmediateContext(context.Receive());
-  context.CopyTo(video_context_.Receive());
+  d3d11_device_->GetImmediateContext(context.GetAddressOf());
+  context.CopyTo(video_context_.GetAddressOf());
   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 40 matching lines @@
     desc.Usage = D3D11_USAGE_DYNAMIC;
 
     // This isn't actually bound to a decoder, but dynamic textures need
     // BindFlags to be nonzero and D3D11_BIND_DECODER also works when creating
     // a VideoProcessorInputView.
     desc.BindFlags = D3D11_BIND_DECODER;
     desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
     desc.MiscFlags = 0;
     desc.SampleDesc.Count = 1;
     base::win::ScopedComPtr<ID3D11Texture2D> texture;
-    HRESULT hr = d3d11_device_->CreateTexture2D(&desc, nullptr,
-                                                staging_texture_.Receive());
+    HRESULT hr = d3d11_device_->CreateTexture2D(
+        &desc, nullptr, staging_texture_.GetAddressOf());
     CHECK(SUCCEEDED(hr)) << "Creating D3D11 video upload texture failed: "
                          << std::hex << hr;
     staging_texture_size_ = texture_size;
   }
   base::win::ScopedComPtr<ID3D11DeviceContext> context;
-  d3d11_device_->GetImmediateContext(context.Receive());
+  d3d11_device_->GetImmediateContext(context.GetAddressOf());
   D3D11_MAPPED_SUBRESOURCE mapped_resource;
   HRESULT hr = context->Map(staging_texture_.Get(), 0, D3D11_MAP_WRITE_DISCARD,
                             0, &mapped_resource);
   CHECK(SUCCEEDED(hr)) << "Mapping D3D11 video upload texture failed: "
                        << std::hex << hr;
 
   size_t dest_stride = mapped_resource.RowPitch;
   for (int y = 0; y < texture_size.height(); y++) {
     const uint8_t* y_source =
         y_image_memory->memory() + y * y_image_memory->stride();
@@ skipping 77 matching lines @@
     DCHECK(uv_image_memory);
     if (!UploadVideoImages(y_image_memory, uv_image_memory))
       return;
     DCHECK(staging_texture_);
     input_texture = staging_texture_;
     input_level = 0;
   }
 
   if (!out_view_) {
     base::win::ScopedComPtr<ID3D11Texture2D> texture;
-    swap_chain_->GetBuffer(0, IID_PPV_ARGS(texture.Receive()));
+    swap_chain_->GetBuffer(0, IID_PPV_ARGS(texture.GetAddressOf()));
     D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC out_desc = {};
     out_desc.ViewDimension = D3D11_VPOV_DIMENSION_TEXTURE2D;
     out_desc.Texture2D.MipSlice = 0;
     HRESULT hr = video_device_->CreateVideoProcessorOutputView(
         texture.Get(), video_processor_enumerator_.Get(), &out_desc,
-        out_view_.Receive());
+        out_view_.GetAddressOf());
     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_.CopyTo(context1.Receive()))) {
+  if (SUCCEEDED(video_context_.CopyTo(context1.GetAddressOf()))) {
     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_.CopyTo(swap_chain3.Receive()))) {
+  if (SUCCEEDED(swap_chain_.CopyTo(swap_chain3.GetAddressOf()))) {
     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);
       video_context_->VideoProcessorSetOutputColorSpace(video_processor_.Get(),
                                                         &d3d11_color_space);
     }
   }
 
   {
     D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC in_desc = {};
     in_desc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
     in_desc.Texture2D.ArraySlice = input_level;
     base::win::ScopedComPtr<ID3D11VideoProcessorInputView> in_view;
     HRESULT hr = video_device_->CreateVideoProcessorInputView(
         input_texture.Get(), video_processor_enumerator_.Get(), &in_desc,
-        in_view.Receive());
+        in_view.GetAddressOf());
     CHECK(SUCCEEDED(hr));
 
     D3D11_VIDEO_PROCESSOR_STREAM stream = {};
     stream.Enable = true;
     stream.OutputIndex = 0;
     stream.InputFrameOrField = 0;
     stream.PastFrames = 0;
     stream.FutureFrames = 0;
     stream.pInputSurface = in_view.Get();
     RECT dest_rect = gfx::Rect(swap_chain_size).ToRECT();
@@ skipping 20 matching lines @@
     swap_chain_->Present(0, 0);
 
     // DirectComposition can display black for a swapchain between the first
     // and second time it's presented to - maybe the first Present can get
     // lost somehow and it shows the wrong buffer. In that case copy the
     // buffers so both have the correct contents, which seems to help. The
     // first Present() after this needs to have SyncInterval > 0, or else the
     // workaround doesn't help.
     base::win::ScopedComPtr<ID3D11Texture2D> dest_texture;
     HRESULT hr =
-        swap_chain_->GetBuffer(0, IID_PPV_ARGS(dest_texture.Receive()));
+        swap_chain_->GetBuffer(0, IID_PPV_ARGS(dest_texture.GetAddressOf()));
     DCHECK(SUCCEEDED(hr));
     base::win::ScopedComPtr<ID3D11Texture2D> src_texture;
-    hr = swap_chain_->GetBuffer(1, IID_PPV_ARGS(src_texture.Receive()));
+    hr = swap_chain_->GetBuffer(1, IID_PPV_ARGS(src_texture.GetAddressOf()));
     DCHECK(SUCCEEDED(hr));
     base::win::ScopedComPtr<ID3D11DeviceContext> context;
-    d3d11_device_->GetImmediateContext(context.Receive());
+    d3d11_device_->GetImmediateContext(context.GetAddressOf());
     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_.CopyTo(swap_chain_media.Receive()))) {
+  if (SUCCEEDED(swap_chain_.CopyTo(swap_chain_media.GetAddressOf()))) {
     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_.CopyTo(dxgi_device.Receive());
+  d3d11_device_.CopyTo(dxgi_device.GetAddressOf());
   base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
-  dxgi_device->GetAdapter(dxgi_adapter.Receive());
+  dxgi_device->GetAdapter(dxgi_adapter.GetAddressOf());
   base::win::ScopedComPtr<IDXGIFactory2> dxgi_factory;
-  dxgi_adapter->GetParent(IID_PPV_ARGS(dxgi_factory.Receive()));
+  dxgi_adapter->GetParent(IID_PPV_ARGS(dxgi_factory.GetAddressOf()));
 
   base::win::ScopedComPtr<IDXGIFactoryMedia> media_factory;
-  dxgi_factory.CopyTo(media_factory.Receive());
+  dxgi_factory.CopyTo(media_factory.GetAddressOf());
   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 14 matching lines @@
 
   frames_since_color_space_change_ = 0;
 
   is_yuy2_swapchain_ = false;
   // The composition surface handle isn't actually used, but
   // CreateSwapChainForComposition can't create YUY2 swapchains.
   HRESULT hr = E_FAIL;
   if (yuy2) {
     hr = media_factory->CreateSwapChainForCompositionSurfaceHandle(
         d3d11_device_.Get(), swap_chain_handle_.Get(), &desc, nullptr,
-        swap_chain_.Receive());
+        swap_chain_.GetAddressOf());
     is_yuy2_swapchain_ = SUCCEEDED(hr);
     failed_to_create_yuy2_swapchain_ = !is_yuy2_swapchain_;
   }
 
   if (!is_yuy2_swapchain_) {
     if (yuy2) {
       DLOG(ERROR) << "YUY2 creation failed with " << std::hex << hr
                   << ". Falling back to BGRA";
     }
     desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
     desc.Flags = 0;
     hr = media_factory->CreateSwapChainForCompositionSurfaceHandle(
         d3d11_device_.Get(), swap_chain_handle_.Get(), &desc, nullptr,
-        swap_chain_.Receive());
+        swap_chain_.GetAddressOf());
     CHECK(SUCCEEDED(hr));
   }
   out_view_.Reset();
 }
 
 void DCLayerTree::InitVisual(size_t i) {
   DCHECK_GT(visual_info_.size(), i);
   VisualInfo* visual_info = &visual_info_[i];
   if (visual_info->content_visual)
     return;
   DCHECK(!visual_info->clip_visual);
   base::win::ScopedComPtr<IDCompositionVisual2> visual;
-  dcomp_device_->CreateVisual(visual_info->clip_visual.Receive());
-  dcomp_device_->CreateVisual(visual.Receive());
+  dcomp_device_->CreateVisual(visual_info->clip_visual.GetAddressOf());
+  dcomp_device_->CreateVisual(visual.GetAddressOf());
   visual_info->content_visual = visual;
   visual_info->clip_visual->AddVisual(visual.Get(), FALSE, nullptr);
 
   IDCompositionVisual2* last_visual =
       (i > 0) ? visual_info_[i - 1].clip_visual.Get() : nullptr;
   root_visual_->AddVisual(visual_info->clip_visual.Get(), TRUE, last_visual);
 }
 
 void DCLayerTree::UpdateVisualForVideo(
     VisualInfo* visual_info,
@@ skipping 31 matching lines @@
     gfx::Transform scale_transform;
     scale_transform.Scale(
         visual_info->swap_chain_presenter->swap_chain_scale_x(),
         visual_info->swap_chain_presenter->swap_chain_scale_y());
     final_transform.PreconcatTransform(scale_transform);
     final_transform.Transpose();
 
     dc_visual->SetOffsetX(bounds_rect.x());
     dc_visual->SetOffsetY(bounds_rect.y());
     base::win::ScopedComPtr<IDCompositionMatrixTransform> dcomp_transform;
-    dcomp_device_->CreateMatrixTransform(dcomp_transform.Receive());
+    dcomp_device_->CreateMatrixTransform(dcomp_transform.GetAddressOf());
     D2D_MATRIX_3X2_F d2d_matrix = {{{final_transform.matrix().get(0, 0),
                                      final_transform.matrix().get(0, 1),
                                      final_transform.matrix().get(1, 0),
                                      final_transform.matrix().get(1, 1),
                                      final_transform.matrix().get(3, 0),
                                      final_transform.matrix().get(3, 1)}}};
     dcomp_transform->SetMatrix(d2d_matrix);
     dc_visual->SetTransform(dcomp_transform.Get());
   }
 }
@@ skipping 33 matching lines @@
                                    const ui::DCRendererLayerParams& params) {
   if (params.is_clipped != visual_info->is_clipped ||
       params.clip_rect != visual_info->clip_rect) {
     // DirectComposition clips happen in the pre-transform visual
     // space, while cc/ clips happen post-transform. So the clip needs
     // to go on a separate parent visual that's untransformed.
     visual_info->is_clipped = params.is_clipped;
     visual_info->clip_rect = params.clip_rect;
     if (params.is_clipped) {
       base::win::ScopedComPtr<IDCompositionRectangleClip> clip;
-      dcomp_device_->CreateRectangleClip(clip.Receive());
+      dcomp_device_->CreateRectangleClip(clip.GetAddressOf());
       gfx::Rect offset_clip = params.clip_rect;
       clip->SetLeft(offset_clip.x());
       clip->SetRight(offset_clip.right());
       clip->SetBottom(offset_clip.bottom());
       clip->SetTop(offset_clip.y());
       visual_info->clip_visual->SetClip(clip.Get());
     } else {
       visual_info->clip_visual->SetClip(nullptr);
     }
   }
@@ skipping 135 matching lines @@
   DCHECK(!swap_chain_);
   DXGI_FORMAT output_format =
       base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableHDR)
           ? DXGI_FORMAT_R16G16B16A16_FLOAT
           : DXGI_FORMAT_B8G8R8A8_UNORM;
   if (enable_dc_layers_) {
     // Always treat as premultiplied, because an underlay could cause it to
     // become transparent.
     HRESULT hr = dcomp_device_->CreateSurface(
         size_.width(), size_.height(), output_format,
-        DXGI_ALPHA_MODE_PREMULTIPLIED, dcomp_surface_.Receive());
+        DXGI_ALPHA_MODE_PREMULTIPLIED, dcomp_surface_.GetAddressOf());
     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_.CopyTo(dxgi_device.Receive());
+    d3d11_device_.CopyTo(dxgi_device.GetAddressOf());
     base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
-    dxgi_device->GetAdapter(dxgi_adapter.Receive());
+    dxgi_device->GetAdapter(dxgi_adapter.GetAddressOf());
     base::win::ScopedComPtr<IDXGIFactory2> dxgi_factory;
-    dxgi_adapter->GetParent(IID_PPV_ARGS(dxgi_factory.Receive()));
+    dxgi_adapter->GetParent(IID_PPV_ARGS(dxgi_factory.GetAddressOf()));
 
     DXGI_SWAP_CHAIN_DESC1 desc = {};
     desc.Width = size_.width();
     desc.Height = size_.height();
     desc.Format = output_format;
     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;
     desc.AlphaMode = alpha_mode;
     desc.Flags = 0;
     HRESULT hr = dxgi_factory->CreateSwapChainForComposition(
-        d3d11_device_.Get(), &desc, nullptr, swap_chain_.Receive());
+        d3d11_device_.Get(), &desc, nullptr, swap_chain_.GetAddressOf());
     has_been_rendered_to_ = false;
     first_swap_ = true;
     CHECK(SUCCEEDED(hr));
   }
 }
 
 void DirectCompositionSurfaceWin::ReleaseDrawTexture(bool will_discard) {
   if (real_surface_) {
     eglDestroySurface(GetDisplay(), real_surface_);
     real_surface_ = nullptr;
   }
   if (draw_texture_) {
     draw_texture_.Reset();
     if (dcomp_surface_) {
       HRESULT hr = dcomp_surface_->EndDraw();
       CHECK(SUCCEEDED(hr));
     } else if (!will_discard) {
       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_.CopyTo(dxgi_device2.Receive());
+        HRESULT hr = d3d11_device_.CopyTo(dxgi_device2.GetAddressOf());
         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 141 matching lines @@
     DLOG(ERROR) << "First draw to surface must draw to everything";
     return false;
   }
 
   CHECK(!g_current_surface);
 
   RECT rect = rectangle.ToRECT();
   if (dcomp_surface_) {
     POINT update_offset;
     HRESULT hr = dcomp_surface_->BeginDraw(
-        &rect, IID_PPV_ARGS(draw_texture_.Receive()), &update_offset);
+        &rect, IID_PPV_ARGS(draw_texture_.GetAddressOf()), &update_offset);
     draw_offset_ = gfx::Point(update_offset) - gfx::Rect(rect).origin();
     CHECK(SUCCEEDED(hr));
   } else {
     HRESULT hr =
-        swap_chain_->GetBuffer(0, IID_PPV_ARGS(draw_texture_.Receive()));
+        swap_chain_->GetBuffer(0, IID_PPV_ARGS(draw_texture_.GetAddressOf()));
     swap_rect_ = rectangle;
     draw_offset_ = gfx::Vector2d();
     CHECK(SUCCEEDED(hr));
   }
   has_been_rendered_to_ = true;
 
   g_current_surface = dcomp_surface_.Get();
 
   std::vector<EGLint> pbuffer_attribs{
       EGL_WIDTH,
@@ skipping 21 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