Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

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 273 matching lines @@
     uint32_t min_size,
     int alignment) {
   CHECK(stream);
   CHECK_GT(size, 0U);
   base::win::ScopedComPtr<IMFSample> sample;
   sample = mf::CreateEmptySampleWithBuffer(std::max(min_size, size), alignment);
   RETURN_ON_FAILURE(sample.Get(), "Failed to create empty sample",
                     base::win::ScopedComPtr<IMFSample>());
 
   base::win::ScopedComPtr<IMFMediaBuffer> buffer;
-  HRESULT hr = sample->GetBufferByIndex(0, buffer.Receive());
+  HRESULT hr = sample->GetBufferByIndex(0, buffer.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from sample",
                        base::win::ScopedComPtr<IMFSample>());
 
   DWORD max_length = 0;
   DWORD current_length = 0;
   uint8_t* destination = NULL;
   hr = buffer->Lock(&destination, &max_length, &current_length);
   RETURN_ON_HR_FAILURE(hr, "Failed to lock buffer",
                        base::win::ScopedComPtr<IMFSample>());
 
@@ skipping 344 matching lines @@
 }
 
 bool DXVAVideoDecodeAccelerator::CreateD3DDevManager() {
   TRACE_EVENT0("gpu", "DXVAVideoDecodeAccelerator_CreateD3DDevManager");
   // The device may exist if the last state was a config change.
   if (d3d9_.Get())
     return true;
 
   HRESULT hr = E_FAIL;
 
-  hr = Direct3DCreate9Ex(D3D_SDK_VERSION, d3d9_.Receive());
+  hr = Direct3DCreate9Ex(D3D_SDK_VERSION, d3d9_.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "Direct3DCreate9Ex failed", false);
 
   hr = d3d9_->CheckDeviceFormatConversion(
       D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
       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();
@@ skipping 15 matching lines @@
     present_params.hDeviceWindow = NULL;
     present_params.Windowed = TRUE;
     present_params.Flags = D3DPRESENTFLAG_VIDEO;
     present_params.FullScreen_RefreshRateInHz = 0;
     present_params.PresentationInterval = 0;
 
     hr = d3d9_->CreateDeviceEx(
         D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL,
         D3DCREATE_FPU_PRESERVE | D3DCREATE_MIXED_VERTEXPROCESSING |
             D3DCREATE_MULTITHREADED,
-        &present_params, NULL, d3d9_device_ex_.Receive());
+        &present_params, NULL, d3d9_device_ex_.GetAddressOf());
     RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device", false);
   }
 
   hr = DXVA2CreateDirect3DDeviceManager9(&dev_manager_reset_token_,
-                                         device_manager_.Receive());
+                                         device_manager_.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "DXVA2CreateDirect3DDeviceManager9 failed", false);
 
   hr = device_manager_->ResetDevice(d3d9_device_ex_.Get(),
                                     dev_manager_reset_token_);
   RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
 
-  hr = d3d9_device_ex_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
+  hr = d3d9_device_ex_->CreateQuery(D3DQUERYTYPE_EVENT, query_.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device query", false);
   // Ensure query_ API works (to avoid an infinite loop later in
   // CopyOutputSampleDataToPictureBuffer).
   hr = query_->Issue(D3DISSUE_END);
   RETURN_ON_HR_FAILURE(hr, "Failed to issue END test query", false);
 
   CreateVideoProcessor();
   return true;
 }
 
@@ skipping 53 matching lines @@
     for (f = 0; f < format_count; f++) {
       if (formats[f] == D3DFMT_X8R8G8B8) {
         break;
       }
     }
     if (f == format_count)
       continue;
 
     // Create video processor
     hr = video_processor_service_->CreateVideoProcessor(
-        guids[g], &inputDesc, D3DFMT_X8R8G8B8, 0, processor_.Receive());
+        guids[g], &inputDesc, D3DFMT_X8R8G8B8, 0, processor_.GetAddressOf());
     if (hr)
       continue;
 
     DXVA2_ValueRange range;
     processor_->GetProcAmpRange(DXVA2_ProcAmp_Brightness, &range);
     default_procamp_values_.Brightness = range.DefaultValue;
     processor_->GetProcAmpRange(DXVA2_ProcAmp_Contrast, &range);
     default_procamp_values_.Contrast = range.DefaultValue;
     processor_->GetProcAmpRange(DXVA2_ProcAmp_Hue, &range);
     default_procamp_values_.Hue = range.DefaultValue;
     processor_->GetProcAmpRange(DXVA2_ProcAmp_Saturation, &range);
     default_procamp_values_.Saturation = range.DefaultValue;
 
     return true;
   }
   return false;
 }
 
 bool DXVAVideoDecodeAccelerator::CreateDX11DevManager() {
   // The device may exist if the last state was a config change.
   if (D3D11Device())
     return true;
-  HRESULT hr = create_dxgi_device_manager_(&dx11_dev_manager_reset_token_,
-                                           d3d11_device_manager_.Receive());
+  HRESULT hr = create_dxgi_device_manager_(
+      &dx11_dev_manager_reset_token_, d3d11_device_manager_.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "MFCreateDXGIDeviceManager failed", false);
 
   angle_device_ = gl::QueryD3D11DeviceObjectFromANGLE();
   if (!angle_device_)
     copy_nv12_textures_ = false;
   if (share_nv12_textures_) {
     RETURN_ON_FAILURE(angle_device_.Get(), "Failed to get d3d11 device", false);
 
     using_angle_device_ = true;
   }
 
   if (use_fp16_ || !share_nv12_textures_) {
     // This array defines the set of DirectX hardware feature levels we support.
     // The ordering MUST be preserved. All applications are assumed to support
     // 9.1 unless otherwise stated by the application.
     D3D_FEATURE_LEVEL feature_levels[] = {
         D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1,
         D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_3,  D3D_FEATURE_LEVEL_9_2,
         D3D_FEATURE_LEVEL_9_1};
 
     UINT flags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
 
     D3D_FEATURE_LEVEL feature_level_out = D3D_FEATURE_LEVEL_11_0;
 #if defined _DEBUG
     flags |= D3D11_CREATE_DEVICE_DEBUG;
 
     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());
+                           D3D11_SDK_VERSION, d3d11_device_.GetAddressOf(),
+                           &feature_level_out,
+                           d3d11_device_context_.GetAddressOf());
     if (hr == DXGI_ERROR_SDK_COMPONENT_MISSING) {
       LOG(ERROR)
           << "Debug DXGI device creation failed, falling back to release.";
       flags &= ~D3D11_CREATE_DEVICE_DEBUG;
     } else {
       RETURN_ON_HR_FAILURE(hr, "Failed to create debug DX11 device", false);
     }
 #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());
+      hr = D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, flags,
+                             feature_levels, arraysize(feature_levels),
+                             D3D11_SDK_VERSION, d3d11_device_.GetAddressOf(),
+                             &feature_level_out,
+                             d3d11_device_context_.GetAddressOf());
       RETURN_ON_HR_FAILURE(hr, "Failed to create DX11 device", false);
     }
 
-    hr = d3d11_device_.CopyTo(video_device_.Receive());
+    hr = d3d11_device_.CopyTo(video_device_.GetAddressOf());
     RETURN_ON_HR_FAILURE(hr, "Failed to get video device", false);
 
-    hr = d3d11_device_context_.CopyTo(video_context_.Receive());
+    hr = d3d11_device_context_.CopyTo(video_context_.GetAddressOf());
     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 23 matching lines @@
   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;
-  hr = D3D11Device()->CreateQuery(&query_desc, d3d11_query_.Receive());
+  hr = D3D11Device()->CreateQuery(&query_desc, d3d11_query_.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "Failed to create DX11 device query", false);
 
   return true;
 }
 
 void DXVAVideoDecodeAccelerator::Decode(
     const BitstreamBuffer& bitstream_buffer) {
   TRACE_EVENT0("media", "DXVAVideoDecodeAccelerator::Decode");
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
@@ skipping 459 matching lines @@
       if (FAILED(hr) || config_count == 0)
         return max_resolution;
 
       D3D11_VIDEO_DECODER_CONFIG config = {};
       hr = video_device->GetVideoDecoderConfig(&desc, 0, &config);
       if (FAILED(hr))
         return max_resolution;
 
       base::win::ScopedComPtr<ID3D11VideoDecoder> video_decoder;
       hr = video_device->CreateVideoDecoder(&desc, &config,
-                                            video_decoder.Receive());
+                                            video_decoder.GetAddressOf());
       if (!video_decoder.Get())
         return max_resolution;
 
       max_resolution = resolution_array[res_idx];
     }
   }
   return max_resolution;
 }
 
 // static
@@ skipping 10 matching lines @@
     return legacy_gpu;
 
   legacy_gpu_determined = true;
 
   base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
   HRESULT hr = dxgi_device.QueryFrom(device);
   if (FAILED(hr))
     return legacy_gpu;
 
   base::win::ScopedComPtr<IDXGIAdapter> adapter;
-  hr = dxgi_device->GetAdapter(adapter.Receive());
+  hr = dxgi_device->GetAdapter(adapter.GetAddressOf());
   if (FAILED(hr))
     return legacy_gpu;
 
   DXGI_ADAPTER_DESC adapter_desc = {};
   hr = adapter->GetDesc(&adapter_desc);
   if (FAILED(hr))
     return legacy_gpu;
 
   // We check if the device is an Intel or an AMD device and whether it is in
   // the global list defined by the g_AMDUVD3GPUList and g_IntelLegacyGPUList
@@ skipping 169 matching lines @@
     // TODO(hubbe): Share/copy P010/P016 textures.
     share_nv12_textures_ = false;
     copy_nv12_textures_ = false;
   }
 
   return SetDecoderMediaTypes();
 }
 
 bool DXVAVideoDecodeAccelerator::CheckDecoderDxvaSupport() {
   base::win::ScopedComPtr<IMFAttributes> attributes;
-  HRESULT hr = decoder_->GetAttributes(attributes.Receive());
+  HRESULT hr = decoder_->GetAttributes(attributes.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "Failed to get decoder attributes", false);
 
   UINT32 dxva = 0;
   hr = attributes->GetUINT32(MF_SA_D3D_AWARE, &dxva);
   RETURN_ON_HR_FAILURE(hr, "Failed to check if decoder supports DXVA", false);
 
   if (codec_ == kCodecH264) {
     hr = attributes->SetUINT32(CODECAPI_AVDecVideoAcceleration_H264, TRUE);
     RETURN_ON_HR_FAILURE(hr, "Failed to enable DXVA H/W decoding", false);
   }
@@ skipping 46 matching lines @@
 bool DXVAVideoDecodeAccelerator::SetDecoderMediaTypes() {
   RETURN_ON_FAILURE(SetDecoderInputMediaType(),
                     "Failed to set decoder input media type", false);
   return SetDecoderOutputMediaType(MFVideoFormat_NV12) ||
          SetDecoderOutputMediaType(MFVideoFormat_P010) ||
          SetDecoderOutputMediaType(MFVideoFormat_P016);
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderInputMediaType() {
   base::win::ScopedComPtr<IMFMediaType> media_type;
-  HRESULT hr = MFCreateMediaType(media_type.Receive());
+  HRESULT hr = MFCreateMediaType(media_type.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "MFCreateMediaType failed", false);
 
   hr = media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
   RETURN_ON_HR_FAILURE(hr, "Failed to set major input type", false);
 
   if (codec_ == kCodecH264) {
     hr = media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_H264);
   } else if (codec_ == kCodecVP8) {
     hr = media_type->SetGUID(MF_MT_SUBTYPE, MEDIASUBTYPE_VP80);
   } else if (codec_ == kCodecVP9) {
@@ skipping 26 matching lines @@
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderOutputMediaType(
     const GUID& subtype) {
   bool result = SetTransformOutputType(decoder_.Get(), subtype, 0, 0);
 
   if (share_nv12_textures_) {
     base::win::ScopedComPtr<IMFAttributes> out_attributes;
     HRESULT hr =
-        decoder_->GetOutputStreamAttributes(0, out_attributes.Receive());
+        decoder_->GetOutputStreamAttributes(0, out_attributes.GetAddressOf());
     RETURN_ON_HR_FAILURE(hr, "Failed to get stream attributes", false);
     out_attributes->SetUINT32(MF_SA_D3D11_BINDFLAGS,
                               D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_DECODER);
     // For some reason newer Intel drivers need D3D11_BIND_DECODER textures to
     // be created with a share handle or they'll crash in
     // CreateShaderResourceView.  Technically MF_SA_D3D11_SHARED_WITHOUT_MUTEX
     // is only honored by the sample allocator, not by the media foundation
     // transform, but Microsoft's h.264 transform happens to pass it through.
     out_attributes->SetUINT32(MF_SA_D3D11_SHARED_WITHOUT_MUTEX, TRUE);
   }
@@ skipping 216 matching lines @@
             FROM_HERE,
             base::Bind(&DXVAVideoDecodeAccelerator::BindPictureBufferToSample,
                        weak_ptr_, pending_sample->output_sample,
                        pending_sample->picture_buffer_id,
                        pending_sample->input_buffer_id));
         continue;
       }
 
       base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
       HRESULT hr = pending_sample->output_sample->GetBufferByIndex(
-          0, output_buffer.Receive());
+          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());
         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.Receive()));
+            reinterpret_cast<void**>(d3d11_texture.GetAddressOf()));
       } else {
         hr = MFGetService(output_buffer.Get(), MR_BUFFER_SERVICE,
-                          IID_PPV_ARGS(surface.Receive()));
+                          IID_PPV_ARGS(surface.GetAddressOf()));
       }
       RETURN_AND_NOTIFY_ON_HR_FAILURE(
           hr, "Failed to get surface from output sample", PLATFORM_FAILURE, );
 
       RETURN_AND_NOTIFY_ON_FAILURE(
           index->second->CopyOutputSampleDataToPictureBuffer(
               this, surface.Get(), d3d11_texture.Get(),
               pending_sample->input_buffer_id),
           "Failed to copy output sample", PLATFORM_FAILURE, );
     }
@@ skipping 700 matching lines @@
 
   if (dest_keyed_mutex) {
     HRESULT hr =
         dest_keyed_mutex->AcquireSync(keyed_mutex_value, kAcquireSyncWaitMs);
     RETURN_AND_NOTIFY_ON_FAILURE(
         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.Receive());
+  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());
   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.Receive()));
+  hr = dxgi_buffer->GetResource(
+      IID_PPV_ARGS(dx11_decoding_texture.GetAddressOf()));
   RETURN_AND_NOTIFY_ON_HR_FAILURE(
       hr, "Failed to get resource from output sample", PLATFORM_FAILURE, );
 
   D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC output_view_desc = {
       D3D11_VPOV_DIMENSION_TEXTURE2D};
   output_view_desc.Texture2D.MipSlice = 0;
   base::win::ScopedComPtr<ID3D11VideoProcessorOutputView> output_view;
   hr = video_device_->CreateVideoProcessorOutputView(
       dest_texture, enumerator_.Get(), &output_view_desc,
-      output_view.Receive());
+      output_view.GetAddressOf());
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to get output view",
                                   PLATFORM_FAILURE, );
 
   D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC input_view_desc = {0};
   input_view_desc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
   input_view_desc.Texture2D.ArraySlice = index;
   input_view_desc.Texture2D.MipSlice = 0;
   base::win::ScopedComPtr<ID3D11VideoProcessorInputView> input_view;
   hr = video_device_->CreateVideoProcessorInputView(
       dx11_decoding_texture.Get(), enumerator_.Get(), &input_view_desc,
-      input_view.Receive());
+      input_view.GetAddressOf());
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to get input view",
                                   PLATFORM_FAILURE, );
 
   D3D11_VIDEO_PROCESSOR_STREAM streams = {0};
   streams.Enable = TRUE;
   streams.pInputSurface = input_view.Get();
 
   hr = video_context_->VideoProcessorBlt(d3d11_processor_.Get(),
                                          output_view.Get(), 0, 1, &streams);
 
@@ skipping 87 matching lines @@
     desc.InputFrameRate.Denominator = 1;
     desc.InputWidth = width;
     desc.InputHeight = height;
     desc.OutputFrameRate.Numerator = 60;
     desc.OutputFrameRate.Denominator = 1;
     desc.OutputWidth = width;
     desc.OutputHeight = height;
     desc.Usage = D3D11_VIDEO_USAGE_PLAYBACK_NORMAL;
 
     HRESULT hr = video_device_->CreateVideoProcessorEnumerator(
-        &desc, enumerator_.Receive());
+        &desc, enumerator_.GetAddressOf());
     RETURN_ON_HR_FAILURE(hr, "Failed to enumerate video processors", false);
 
     // TODO(Hubbe): Find correct index
     hr = video_device_->CreateVideoProcessor(enumerator_.Get(), 0,
-                                             d3d11_processor_.Receive());
+                                             d3d11_processor_.GetAddressOf());
     RETURN_ON_HR_FAILURE(hr, "Failed to create video processor.", false);
     processor_width_ = width;
     processor_height_ = height;
 
     video_context_->VideoProcessorSetStreamAutoProcessingMode(
         d3d11_processor_.Get(), 0, false);
   }
 
   if (copy_nv12_textures_) {
     // If we're copying NV12 textures, make sure we set the same
     // color space on input and output.
     D3D11_VIDEO_PROCESSOR_COLOR_SPACE d3d11_color_space = {0};
     d3d11_color_space.RGB_Range = 1;
     d3d11_color_space.Nominal_Range = D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_0_255;
 
     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_.CopyTo(video_context1.Receive());
+      HRESULT hr = video_context_.CopyTo(video_context1.GetAddressOf());
       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 41 matching lines @@
       }
     }
   }
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::GetVideoFrameDimensions(IMFSample* sample,
                                                          int* width,
                                                          int* height) {
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
-  HRESULT hr = sample->GetBufferByIndex(0, output_buffer.Receive());
+  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());
     RETURN_ON_HR_FAILURE(hr, "Failed to get DXGIBuffer from output sample",
                          false);
     hr = dxgi_buffer->GetResource(
         __uuidof(ID3D11Texture2D),
-        reinterpret_cast<void**>(d3d11_texture.Receive()));
+        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;
     *height = d3d11_texture_desc.Height;
     output_array_size_ = d3d11_texture_desc.ArraySize;
   } else {
     base::win::ScopedComPtr<IDirect3DSurface9> surface;
     hr = MFGetService(output_buffer.Get(), MR_BUFFER_SERVICE,
-                      IID_PPV_ARGS(surface.Receive()));
+                      IID_PPV_ARGS(surface.GetAddressOf()));
     RETURN_ON_HR_FAILURE(hr, "Failed to get D3D surface from output sample",
                          false);
     D3DSURFACE_DESC surface_desc;
     hr = surface->GetDesc(&surface_desc);
     RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
     *width = surface_desc.Width;
     *height = surface_desc.Height;
   }
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::SetTransformOutputType(IMFTransform* transform,
                                                         const GUID& output_type,
                                                         int width,
                                                         int height) {
   HRESULT hr = E_FAIL;
   base::win::ScopedComPtr<IMFMediaType> media_type;
 
-  for (uint32_t i = 0;
-       SUCCEEDED(transform->GetOutputAvailableType(0, i, media_type.Receive()));
+  for (uint32_t i = 0; SUCCEEDED(
+           transform->GetOutputAvailableType(0, i, media_type.GetAddressOf()));
        ++i) {
     GUID out_subtype = {0};
     hr = media_type->GetGUID(MF_MT_SUBTYPE, &out_subtype);
     RETURN_ON_HR_FAILURE(hr, "Failed to get output major type", false);
 
     if (out_subtype == output_type) {
       if (width && height) {
         hr = MFSetAttributeSize(media_type.Get(), MF_MT_FRAME_SIZE, width,
                                 height);
         RETURN_ON_HR_FAILURE(hr, "Failed to set media type attributes", false);
       }
       hr = transform->SetOutputType(0, media_type.Get(), 0);  // No flags
       RETURN_ON_HR_FAILURE(hr, "Failed to set output type", false);
       return true;
     }
     media_type.Reset();
   }
   return false;
 }
 
 HRESULT DXVAVideoDecodeAccelerator::CheckConfigChanged(IMFSample* sample,
                                                        bool* config_changed) {
   if (codec_ != kCodecH264)
     return S_FALSE;
 
   base::win::ScopedComPtr<IMFMediaBuffer> buffer;
-  HRESULT hr = sample->GetBufferByIndex(0, buffer.Receive());
+  HRESULT hr = sample->GetBufferByIndex(0, buffer.GetAddressOf());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from input sample", hr);
 
   mf::MediaBufferScopedPointer scoped_media_buffer(buffer.Get());
 
   if (!config_change_detector_->DetectConfig(
           scoped_media_buffer.get(), scoped_media_buffer.current_length())) {
     RETURN_ON_HR_FAILURE(E_FAIL, "Failed to detect H.264 stream config",
                          E_FAIL);
   }
   *config_changed = config_change_detector_->config_changed();
@@ skipping 15 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