Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

media/gpu/dxva_picture_buffer_win.cc

 // Copyright 2016 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_picture_buffer_win.h"
 
 #include "media/gpu/dxva_video_decode_accelerator_win.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gl/gl_bindings.h"
@@ skipping 219 matching lines @@
     desc.SampleDesc.Count = 1;
     desc.SampleDesc.Quality = 0;
     desc.Usage = D3D11_USAGE_DEFAULT;
     desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
     desc.CPUAccessFlags = 0;
     desc.MiscFlags = decoder.use_keyed_mutex_
                          ? D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX
                          : D3D11_RESOURCE_MISC_SHARED;
 
     HRESULT hr = decoder.d3d11_device_->CreateTexture2D(
-        &desc, nullptr, dx11_decoding_texture_.Receive());
+        &desc, nullptr, dx11_decoding_texture_.GetAddressOf());
     RETURN_ON_HR_FAILURE(hr, "Failed to create texture", false);
     if (decoder.use_keyed_mutex_) {
       hr = dx11_keyed_mutex_.QueryFrom(dx11_decoding_texture_.Get());
       RETURN_ON_HR_FAILURE(hr, "Failed to get keyed mutex", false);
     }
 
     base::win::ScopedComPtr<IDXGIResource> resource;
     hr = resource.QueryFrom(dx11_decoding_texture_.Get());
     DCHECK(SUCCEEDED(hr));
     hr = resource->GetSharedHandle(&texture_share_handle_);
     RETURN_ON_FAILURE(SUCCEEDED(hr) && texture_share_handle_,
                       "Failed to query shared handle", false);
 
   } else {
     HRESULT hr = E_FAIL;
     hr = decoder.d3d9_device_ex_->CreateTexture(
         picture_buffer_.size().width(), picture_buffer_.size().height(), 1,
         D3DUSAGE_RENDERTARGET, use_rgb ? D3DFMT_X8R8G8B8 : D3DFMT_A8R8G8B8,
-        D3DPOOL_DEFAULT, decoding_texture_.Receive(), &texture_share_handle_);
+        D3DPOOL_DEFAULT, decoding_texture_.GetAddressOf(),
+        &texture_share_handle_);
     RETURN_ON_HR_FAILURE(hr, "Failed to create texture", false);
     RETURN_ON_FAILURE(texture_share_handle_, "Failed to query shared handle",
                       false);
   }
   return true;
 }
 
 void PbufferPictureBuffer::ResetReuseFence() {
   DCHECK_EQ(IN_CLIENT, state_);
   if (!reuse_fence_ || !reuse_fence_->ResetSupported())
@@ skipping 41 matching lines @@
 
   // The same picture buffer can be reused for a different frame. Release the
   // target surface and the decoder references here.
   target_surface_.Reset();
   decoder_surface_.Reset();
 
   // Grab a reference on the decoder surface and the target surface. These
   // references will be released when we receive a notification that the
   // copy was completed or when the DXVAPictureBuffer instance is destroyed.
   // We hold references here as it is easier to manage their lifetimes.
-  hr = decoding_texture_->GetSurfaceLevel(0, target_surface_.Receive());
+  hr = decoding_texture_->GetSurfaceLevel(0, target_surface_.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "Failed to get surface from texture", false);
 
   decoder_surface_ = dest_surface;
 
   decoder->CopySurface(decoder_surface_.Get(), target_surface_.Get(), id(),
                        input_buffer_id, color_space_);
   color_space_ = gfx::ColorSpace();
   return true;
 }
 
@@ skipping 143 matching lines @@
 bool EGLStreamPictureBuffer::BindSampleToTexture(
     base::win::ScopedComPtr<IMFSample> sample) {
   DCHECK_EQ(BOUND, state_);
   state_ = IN_CLIENT;
 
   current_d3d_sample_ = sample;
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
 
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   HRESULT hr =
-      current_d3d_sample_->GetBufferByIndex(0, output_buffer.Receive());
+      current_d3d_sample_->GetBufferByIndex(0, output_buffer.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from output sample", false);
 
   base::win::ScopedComPtr<IMFDXGIBuffer> dxgi_buffer;
   hr = dxgi_buffer.QueryFrom(output_buffer.Get());
   RETURN_ON_HR_FAILURE(hr, "Failed to get DXGIBuffer from output sample",
                        false);
-  hr = dxgi_buffer->GetResource(IID_PPV_ARGS(dx11_decoding_texture_.Receive()));
+  hr = dxgi_buffer->GetResource(
+      IID_PPV_ARGS(dx11_decoding_texture_.GetAddressOf()));
   RETURN_ON_HR_FAILURE(hr, "Failed to get texture from output sample", false);
   UINT subresource;
   dxgi_buffer->GetSubresourceIndex(&subresource);
 
   EGLAttrib frame_attributes[] = {
       EGL_D3D_TEXTURE_SUBRESOURCE_ID_ANGLE, subresource, EGL_NONE,
   };
 
   EGLBoolean result = eglStreamPostD3DTextureNV12ANGLE(
       egl_display, stream_, static_cast<void*>(dx11_decoding_texture_.Get()),
@@ skipping 75 matching lines @@
   desc.ArraySize = 1;
   desc.Format = DXGI_FORMAT_NV12;
   desc.SampleDesc.Count = 1;
   desc.SampleDesc.Quality = 0;
   desc.Usage = D3D11_USAGE_DEFAULT;
   desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
   desc.CPUAccessFlags = 0;
   desc.MiscFlags = D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;
 
   HRESULT hr = decoder.d3d11_device_->CreateTexture2D(
-      &desc, nullptr, decoder_copy_texture_.Receive());
+      &desc, nullptr, decoder_copy_texture_.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "Failed to create texture", false);
   DCHECK(decoder.use_keyed_mutex_);
   hr = dx11_keyed_mutex_.QueryFrom(decoder_copy_texture_.Get());
   RETURN_ON_HR_FAILURE(hr, "Failed to get keyed mutex", false);
 
   base::win::ScopedComPtr<IDXGIResource> resource;
   hr = resource.QueryFrom(decoder_copy_texture_.Get());
   DCHECK(SUCCEEDED(hr));
   hr = resource->GetSharedHandle(&texture_share_handle_);
   RETURN_ON_FAILURE(SUCCEEDED(hr) && texture_share_handle_,
                     "Failed to query shared handle", false);
 
   hr = decoder.angle_device_->OpenSharedResource(
-      texture_share_handle_, IID_PPV_ARGS(angle_copy_texture_.Receive()));
+      texture_share_handle_, IID_PPV_ARGS(angle_copy_texture_.GetAddressOf()));
   RETURN_ON_HR_FAILURE(hr, "Failed to open shared resource", false);
   hr = egl_keyed_mutex_.QueryFrom(angle_copy_texture_.Get());
   RETURN_ON_HR_FAILURE(hr, "Failed to get ANGLE mutex", false);
   return true;
 }
 
 bool EGLStreamCopyPictureBuffer::CopyOutputSampleDataToPictureBuffer(
     DXVAVideoDecodeAccelerator* decoder,
     IDirect3DSurface9* dest_surface,
     ID3D11Texture2D* dx11_texture,
@@ skipping 64 matching lines @@
     RETURN_ON_FAILURE(result, "Could not release stream", false);
   }
   return true;
 }
 
 bool EGLStreamCopyPictureBuffer::AllowOverlay() const {
   return true;
 }
 
 }  // namespace media