Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

media/gpu/d3d11_video_decode_accelerator_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.
 
 // This is defined here to ensure the D3D11, D3D9, and DXVA includes through
 // this header have their GUIDs intialized.
 #define INITGUID
 #include "media/gpu/d3d11_video_decode_accelerator_win.h"
 #undef INITGUID
 
@@ skipping 30 matching lines @@
       make_context_current_cb_(make_context_current_cb) {}
 
 D3D11VideoDecodeAccelerator::~D3D11VideoDecodeAccelerator() {}
 
 bool D3D11VideoDecodeAccelerator::Initialize(const Config& config,
                                              Client* client) {
   client_ = client;
   make_context_current_cb_.Run();
 
   device_ = gl::QueryD3D11DeviceObjectFromANGLE();
-  device_->GetImmediateContext(device_context_.Receive());
+  device_->GetImmediateContext(device_context_.GetAddressOf());
 
-  HRESULT hr = device_context_.CopyTo(video_context_.Receive());
+  HRESULT hr = device_context_.CopyTo(video_context_.GetAddressOf());
   CHECK(SUCCEEDED(hr));
 
-  hr = device_.CopyTo(video_device_.Receive());
+  hr = device_.CopyTo(video_device_.GetAddressOf());
   CHECK(SUCCEEDED(hr));
 
   bool is_h264 =
       config.profile >= H264PROFILE_MIN && config.profile <= H264PROFILE_MAX;
   if (!is_h264)
     return false;
 
   GUID needed_guid;
   memcpy(&needed_guid, &D3D11_DECODER_PROFILE_H264_VLD_NOFGT,
          sizeof(needed_guid));
@@ skipping 30 matching lines @@
     hr = video_device_->GetVideoDecoderConfig(&desc, i, &dec_config);
     if (FAILED(hr))
       CHECK(false);
     if (dec_config.ConfigBitstreamRaw == 2)
       break;
   }
   memcpy(&decoder_guid_, &decoder_guid, sizeof decoder_guid_);
 
   base::win::ScopedComPtr<ID3D11VideoDecoder> video_decoder;
   hr = video_device_->CreateVideoDecoder(&desc, &dec_config,
-                                         video_decoder.Receive());
+                                         video_decoder.GetAddressOf());
   CHECK(video_decoder.Get());
 
   h264_accelerator_.reset(new D3D11H264Accelerator(
       this, video_decoder, video_device_, video_context_));
   decoder_.reset(new media::H264Decoder(h264_accelerator_.get()));
 
   return true;
 }
 
 void D3D11VideoDecodeAccelerator::Decode(
@@ skipping 53 matching lines @@
   texture_desc.Height = decoder_->GetPicSize().height();
   texture_desc.MipLevels = 1;
   texture_desc.ArraySize = buffers.size();
   texture_desc.Format = DXGI_FORMAT_NV12;
   texture_desc.SampleDesc.Count = 1;
   texture_desc.Usage = D3D11_USAGE_DEFAULT;
   texture_desc.BindFlags = D3D11_BIND_DECODER | D3D11_BIND_SHADER_RESOURCE;
   texture_desc.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
 
   base::win::ScopedComPtr<ID3D11Texture2D> out_texture;
-  HRESULT hr =
-      device_->CreateTexture2D(&texture_desc, nullptr, out_texture.Receive());
+  HRESULT hr = device_->CreateTexture2D(&texture_desc, nullptr,
+                                        out_texture.GetAddressOf());
   CHECK(SUCCEEDED(hr));
 
   make_context_current_cb_.Run();
   picture_buffers_.clear();
 
   for (size_t i = 0; i < buffers.size(); i++) {
     picture_buffers_.push_back(
         base::MakeUnique<D3D11PictureBuffer>(buffers[i], i));
     picture_buffers_[i]->Init(video_device_, out_texture, decoder_guid_);
   }
@@ skipping 49 matching lines @@
 }
 
 void D3D11VideoDecodeAccelerator::OutputResult(D3D11PictureBuffer* buffer,
                                                size_t input_buffer_id) {
   buffer->set_in_client_use(true);
   Picture picture(buffer->picture_buffer().id(), input_buffer_id,
                   gfx::Rect(0, 0), gfx::ColorSpace(), false);
   client_->PictureReady(picture);
 }
 }  // namespace media