Rename ScopedComPtr::get() to ScopedComPtr::Get()

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 268 matching lines @@
 // the decoder for input). If no alignment is required, provide 0.
 static base::win::ScopedComPtr<IMFSample> CreateInputSample(
     const uint8_t* stream,
     uint32_t size,
     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",
+  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());
   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;
@@ skipping 342 matching lines @@
   config_change_detector_.reset(new H264ConfigChangeDetector);
 
   SetState(kNormal);
 
   return StartDecoderThread();
 }
 
 bool DXVAVideoDecodeAccelerator::CreateD3DDevManager() {
   TRACE_EVENT0("gpu", "DXVAVideoDecodeAccelerator_CreateD3DDevManager");
   // The device may exist if the last state was a config change.
-  if (d3d9_.get())
+  if (d3d9_.Get())
     return true;
 
   HRESULT hr = E_FAIL;
 
   hr = Direct3DCreate9Ex(D3D_SDK_VERSION, d3d9_.Receive());
   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();
-  if (angle_device.get())
+  if (angle_device.Get())
     using_angle_device_ = true;
 
   if (using_angle_device_) {
-    hr = d3d9_device_ex_.QueryFrom(angle_device.get());
+    hr = d3d9_device_ex_.QueryFrom(angle_device.Get());
     RETURN_ON_HR_FAILURE(
         hr, "QueryInterface for IDirect3DDevice9Ex from angle device failed",
         false);
   } else {
     D3DPRESENT_PARAMETERS present_params = {0};
     present_params.BackBufferWidth = 1;
     present_params.BackBufferHeight = 1;
     present_params.BackBufferFormat = D3DFMT_UNKNOWN;
     present_params.BackBufferCount = 1;
     present_params.SwapEffect = D3DSWAPEFFECT_DISCARD;
     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());
     RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device", false);
   }
 
   hr = DXVA2CreateDirect3DDeviceManager9(&dev_manager_reset_token_,
                                          device_manager_.Receive());
   RETURN_ON_HR_FAILURE(hr, "DXVA2CreateDirect3DDeviceManager9 failed", false);
 
-  hr = device_manager_->ResetDevice(d3d9_device_ex_.get(),
+  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());
   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;
 }
 
 bool DXVAVideoDecodeAccelerator::CreateVideoProcessor() {
   if (!use_color_info_)
     return false;
 
   // TODO(Hubbe): Don't try again if we tried and failed already.
-  if (video_processor_service_.get())
+  if (video_processor_service_.Get())
     return true;
-  HRESULT hr = DXVA2CreateVideoService(d3d9_device_ex_.get(),
+  HRESULT hr = DXVA2CreateVideoService(d3d9_device_ex_.Get(),
                                        IID_IDirectXVideoProcessorService,
                                        video_processor_service_.ReceiveVoid());
   RETURN_ON_HR_FAILURE(hr, "DXVA2CreateVideoService failed", false);
 
   // TODO(Hubbe): Use actual video settings.
   DXVA2_VideoDesc inputDesc;
   inputDesc.SampleWidth = 1920;
   inputDesc.SampleHeight = 1080;
   inputDesc.SampleFormat.VideoChromaSubsampling =
       DXVA2_VideoChromaSubsampling_MPEG2;
@@ skipping 57 matching lines @@
     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 (d3d11_device_.get())
+  if (d3d11_device_.Get())
     return true;
   HRESULT hr = create_dxgi_device_manager_(&dx11_dev_manager_reset_token_,
                                            d3d11_device_manager_.Receive());
   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);
+    RETURN_ON_FAILURE(angle_device_.Get(), "Failed to get d3d11 device", false);
 
     using_angle_device_ = true;
     d3d11_device_ = angle_device_;
   } else {
     // 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,
@@ skipping 54 matching lines @@
   hr = d3d11_device_->CheckFormatSupport(DXGI_FORMAT_R16G16B16A16_FLOAT,
                                          &fp16_format_support);
   if (FAILED(hr) ||
       !(fp16_format_support & D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_OUTPUT))
     use_fp16_ = false;
 
   // Enable multithreaded mode on the device. This ensures that accesses to
   // context are synchronized across threads. We have multiple threads
   // accessing the context, the media foundation decoder threads and the
   // decoder thread via the video format conversion transform.
-  hr = multi_threaded_.QueryFrom(d3d11_device_.get());
+  hr = multi_threaded_.QueryFrom(d3d11_device_.Get());
   RETURN_ON_HR_FAILURE(hr, "Failed to query ID3D10Multithread", false);
   multi_threaded_->SetMultithreadProtected(TRUE);
 
-  hr = d3d11_device_manager_->ResetDevice(d3d11_device_.get(),
+  hr = d3d11_device_manager_->ResetDevice(d3d11_device_.Get(),
                                           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 = d3d11_device_->CreateQuery(&query_desc, d3d11_query_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to create DX11 device query", false);
 
   return true;
@@ skipping 25 matching lines @@
 
   base::win::ScopedComPtr<IMFSample> sample;
   RETURN_AND_NOTIFY_ON_FAILURE(shm.Map(bitstream_buffer.size()),
                                "Failed in base::SharedMemory::Map",
                                PLATFORM_FAILURE, );
 
   sample = CreateInputSample(
       reinterpret_cast<const uint8_t*>(shm.memory()), bitstream_buffer.size(),
       std::min<uint32_t>(bitstream_buffer.size(), input_stream_info_.cbSize),
       input_stream_info_.cbAlignment);
-  RETURN_AND_NOTIFY_ON_FAILURE(sample.get(), "Failed to create input sample",
+  RETURN_AND_NOTIFY_ON_FAILURE(sample.Get(), "Failed to create input sample",
                                PLATFORM_FAILURE, );
 
   RETURN_AND_NOTIFY_ON_HR_FAILURE(
       sample->SetSampleTime(bitstream_buffer.id()),
       "Failed to associate input buffer id with sample", PLATFORM_FAILURE, );
 
   decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::DecodeInternal,
                             base::Unretained(this), sample));
 }
@@ skipping 350 matching lines @@
   // a DXVA decoder instance for that resolution and profile. If that succeeds
   // we assume that the driver supports H/W H.264 decoding for that resolution.
   HRESULT hr = E_FAIL;
   base::win::ScopedComPtr<ID3D11Device> device;
 
   {
     TRACE_EVENT0("gpu,startup",
                  "GetMaxH264Resolution. QueryDeviceObjectFromANGLE");
 
     device = gl::QueryD3D11DeviceObjectFromANGLE();
-    if (!device.get())
+    if (!device.Get())
       return max_resolution;
   }
 
   base::win::ScopedComPtr<ID3D11VideoDevice> video_device;
   hr = device.QueryInterface(__uuidof(ID3D11VideoDevice),
                              video_device.ReceiveVoid());
   if (FAILED(hr))
     return max_resolution;
 
   GUID decoder_guid = {};
@@ skipping 13 matching lines @@
         found = true;
         break;
       }
     }
     if (!found)
       return max_resolution;
   }
 
   // Legacy AMD drivers with UVD3 or earlier and some Intel GPU's crash while
   // creating surfaces larger than 1920 x 1088.
-  if (IsLegacyGPU(device.get()))
+  if (IsLegacyGPU(device.Get()))
     return max_resolution;
 
   // We look for the following resolutions in the driver.
   // TODO(ananta)
   // Look into whether this list needs to be expanded.
   static std::pair<int, int> resolution_array[] = {
       // Use 1088 to account for 16x16 macroblocks.
       std::make_pair(1920, 1088), std::make_pair(2560, 1440),
       std::make_pair(3840, 2160), std::make_pair(4096, 2160),
       std::make_pair(4096, 2304),
@@ skipping 15 matching lines @@
         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());
-      if (!video_decoder.get())
+      if (!video_decoder.Get())
         return max_resolution;
 
       max_resolution = resolution_array[res_idx];
     }
   }
   return max_resolution;
 }
 
 // static
 bool DXVAVideoDecodeAccelerator::IsLegacyGPU(ID3D11Device* device) {
@@ skipping 128 matching lines @@
   RETURN_ON_FAILURE(CheckDecoderDxvaSupport(),
                     "Failed to check decoder DXVA support", false);
 
   ULONG_PTR device_manager_to_use = NULL;
   if (use_dx11_) {
     CHECK(create_dxgi_device_manager_);
     RETURN_AND_NOTIFY_ON_FAILURE(CreateDX11DevManager(),
                                  "Failed to initialize DX11 device and manager",
                                  PLATFORM_FAILURE, false);
     device_manager_to_use =
-        reinterpret_cast<ULONG_PTR>(d3d11_device_manager_.get());
+        reinterpret_cast<ULONG_PTR>(d3d11_device_manager_.Get());
   } else {
     RETURN_AND_NOTIFY_ON_FAILURE(CreateD3DDevManager(),
                                  "Failed to initialize D3D device and manager",
                                  PLATFORM_FAILURE, false);
-    device_manager_to_use = reinterpret_cast<ULONG_PTR>(device_manager_.get());
+    device_manager_to_use = reinterpret_cast<ULONG_PTR>(device_manager_.Get());
   }
 
   hr = decoder_->ProcessMessage(MFT_MESSAGE_SET_D3D_MANAGER,
                                 device_manager_to_use);
   if (use_dx11_) {
     RETURN_ON_HR_FAILURE(hr, "Failed to pass DX11 manager to decoder", false);
   } else {
     RETURN_ON_HR_FAILURE(hr, "Failed to pass D3D manager to decoder", false);
   }
 
@@ skipping 114 matching lines @@
     hr = media_type->SetGUID(MF_MT_SUBTYPE, MEDIASUBTYPE_VP80);
   } else if (codec_ == kCodecVP9) {
     hr = media_type->SetGUID(MF_MT_SUBTYPE, MEDIASUBTYPE_VP90);
   } else {
     NOTREACHED();
     RETURN_ON_FAILURE(false, "Unsupported codec on input media type.", false);
   }
   RETURN_ON_HR_FAILURE(hr, "Failed to set subtype", false);
 
   if (using_ms_vp9_mft_) {
-    hr = MFSetAttributeSize(media_type.get(), MF_MT_FRAME_SIZE,
+    hr = MFSetAttributeSize(media_type.Get(), MF_MT_FRAME_SIZE,
                             config_.initial_expected_coded_size.width(),
                             config_.initial_expected_coded_size.height());
     RETURN_ON_HR_FAILURE(hr, "Failed to set attribute size", false);
 
     hr = media_type->SetUINT32(MF_MT_INTERLACE_MODE,
                                MFVideoInterlace_Progressive);
     RETURN_ON_HR_FAILURE(hr, "Failed to set interlace mode", false);
   } else {
     // Not sure about this. msdn recommends setting this value on the input
     // media type.
     hr = media_type->SetUINT32(MF_MT_INTERLACE_MODE,
                                MFVideoInterlace_MixedInterlaceOrProgressive);
     RETURN_ON_HR_FAILURE(hr, "Failed to set interlace mode", false);
   }
 
-  hr = decoder_->SetInputType(0, media_type.get(), 0);  // No flags
+  hr = decoder_->SetInputType(0, media_type.Get(), 0);  // No flags
   RETURN_ON_HR_FAILURE(hr, "Failed to set decoder input type", false);
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderOutputMediaType(
     const GUID& subtype) {
-  bool result = SetTransformOutputType(decoder_.get(), subtype, 0, 0);
+  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());
     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
@@ skipping 139 matching lines @@
     DVLOG(1) << "Waiting for picture slots from the client.";
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::ProcessPendingSamples,
                    weak_ptr_));
     return true;
   }
 
   int width = 0;
   int height = 0;
-  if (!GetVideoFrameDimensions(sample.get(), &width, &height)) {
+  if (!GetVideoFrameDimensions(sample.Get(), &width, &height)) {
     RETURN_ON_FAILURE(false, "Failed to get D3D surface from output sample",
                       false);
   }
 
   // Go ahead and request picture buffers.
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::RequestPictureBuffers,
                             weak_ptr_, width, height));
 
   pictures_requested_ = true;
@@ skipping 21 matching lines @@
       {
         base::AutoLock lock(decoder_lock_);
         PendingSampleInfo& sample_info = pending_output_samples_.front();
         if (sample_info.picture_buffer_id != -1)
           continue;
         pending_sample = &sample_info;
       }
 
       int width = 0;
       int height = 0;
-      if (!GetVideoFrameDimensions(pending_sample->output_sample.get(), &width,
+      if (!GetVideoFrameDimensions(pending_sample->output_sample.Get(), &width,
                                    &height)) {
         RETURN_AND_NOTIFY_ON_FAILURE(
             false, "Failed to get D3D surface from output sample",
             PLATFORM_FAILURE, );
       }
 
       if (width != index->second->size().width() ||
           height != index->second->size().height()) {
         HandleResolutionChanged(width, height);
         return;
@@ skipping 17 matching lines @@
       HRESULT hr = pending_sample->output_sample->GetBufferByIndex(
           0, output_buffer.Receive());
       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());
+        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()));
       } else {
-        hr = MFGetService(output_buffer.get(), MR_BUFFER_SERVICE,
+        hr = MFGetService(output_buffer.Get(), MR_BUFFER_SERVICE,
                           IID_PPV_ARGS(surface.Receive()));
       }
       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(),
+              this, surface.Get(), d3d11_texture.Get(),
               pending_sample->input_buffer_id),
           "Failed to copy output sample", PLATFORM_FAILURE, );
     }
   }
 }
 
 void DXVAVideoDecodeAccelerator::StopOnError(
     VideoDecodeAccelerator::Error error) {
   if (!main_thread_task_runner_->BelongsToCurrentThread()) {
     main_thread_task_runner_->PostTask(
@@ skipping 251 matching lines @@
 
   if (OutputSamplesPresent() || !pending_input_buffers_.empty()) {
     pending_input_buffers_.push_back(sample);
     return;
   }
 
   // Check if the resolution, bit rate, etc changed in the stream. If yes we
   // reinitialize the decoder to ensure that the stream decodes correctly.
   bool config_changed = false;
 
-  HRESULT hr = CheckConfigChanged(sample.get(), &config_changed);
+  HRESULT hr = CheckConfigChanged(sample.Get(), &config_changed);
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to check video stream config",
                                   PLATFORM_FAILURE, );
 
   processing_config_changed_ = config_changed;
 
   if (config_changed) {
     pending_input_buffers_.push_back(sample);
     FlushInternal();
     return;
   }
 
   VideoColorSpace color_space = config_change_detector_->current_color_space();
   if (color_space == VideoColorSpace())
     color_space = config_.color_space;
 
   if (!inputs_before_decode_) {
     TRACE_EVENT_ASYNC_BEGIN0("gpu", "DXVAVideoDecodeAccelerator.Decoding",
                              this);
   }
   inputs_before_decode_++;
   {
     ScopedExceptionCatcher catcher(using_ms_vp9_mft_);
-    hr = decoder_->ProcessInput(0, sample.get(), 0);
+    hr = decoder_->ProcessInput(0, sample.Get(), 0);
   }
   // As per msdn if the decoder returns MF_E_NOTACCEPTING then it means that it
   // has enough data to produce one or more output samples. In this case the
   // recommended options are to
   // 1. Generate new output by calling IMFTransform::ProcessOutput until it
   //    returns MF_E_TRANSFORM_NEED_MORE_INPUT.
   // 2. Flush the input data
   // We implement the first option, i.e to retrieve the output sample and then
   // process the input again. Failure in either of these steps is treated as a
   // decoder failure.
   if (hr == MF_E_NOTACCEPTING) {
     DoDecode(color_space.ToGfxColorSpace());
     // If the DoDecode call resulted in an output frame then we should not
     // process any more input until that frame is copied to the target surface.
     if (!OutputSamplesPresent()) {
       State state = GetState();
       RETURN_AND_NOTIFY_ON_FAILURE(
           (state == kStopped || state == kNormal || state == kFlushing),
           "Failed to process output. Unexpected decoder state: " << state,
           PLATFORM_FAILURE, );
-      hr = decoder_->ProcessInput(0, sample.get(), 0);
+      hr = decoder_->ProcessInput(0, sample.Get(), 0);
     }
     // If we continue to get the MF_E_NOTACCEPTING error we do the following:-
     // 1. Add the input sample to the pending queue.
     // 2. If we don't have any output samples we post the
     //    DecodePendingInputBuffers task to process the pending input samples.
     //    If we have an output sample then the above task is posted when the
     //    output samples are sent to the client.
     // This is because we only support 1 pending output sample at any
     // given time due to the limitation with the Microsoft media foundation
     // decoder where it recycles the output Decoder surfaces.
@@ skipping 366 matching lines @@
     base::win::ScopedComPtr<IMFSample> input_sample,
     int picture_buffer_id,
     int input_buffer_id) {
   TRACE_EVENT0("media",
                "DXVAVideoDecodeAccelerator::CopyTextureOnDecoderThread");
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   HRESULT hr = E_FAIL;
 
   DCHECK(use_dx11_);
   DCHECK(!!input_sample);
-  DCHECK(d3d11_processor_.get());
+  DCHECK(d3d11_processor_.Get());
 
   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());
   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());
+  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()));
   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,
+      dest_texture, enumerator_.Get(), &output_view_desc,
       output_view.Receive());
   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,
+      dx11_decoding_texture.Get(), enumerator_.Get(), &input_view_desc,
       input_view.Receive());
   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();
+  streams.pInputSurface = input_view.Get();
 
-  hr = video_context_->VideoProcessorBlt(d3d11_processor_.get(),
-                                         output_view.get(), 0, 1, &streams);
+  hr = video_context_->VideoProcessorBlt(d3d11_processor_.Get(),
+                                         output_view.Get(), 0, 1, &streams);
 
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "VideoProcessBlit failed",
                                   PLATFORM_FAILURE, );
 
   if (dest_keyed_mutex) {
     HRESULT hr = dest_keyed_mutex->ReleaseSync(keyed_mutex_value + 1);
     RETURN_AND_NOTIFY_ON_FAILURE(hr == S_OK, "Failed to release keyed mutex.",
                                  PLATFORM_FAILURE, );
 
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::CopySurfaceComplete, weak_ptr_,
                    nullptr, nullptr, picture_buffer_id, input_buffer_id));
   } else {
     d3d11_device_context_->Flush();
-    d3d11_device_context_->End(d3d11_query_.get());
+    d3d11_device_context_->End(d3d11_query_.Get());
 
     decoder_thread_task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushDecoder,
                               base::Unretained(this), 0,
                               reinterpret_cast<IDirect3DSurface9*>(NULL),
                               reinterpret_cast<IDirect3DSurface9*>(NULL),
                               picture_buffer_id, input_buffer_id),
         base::TimeDelta::FromMilliseconds(kFlushDecoderSurfaceTimeoutMs));
   }
 }
@@ skipping 16 matching lines @@
   // We need to do this in a loop and call flush multiple times.
   // We have seen the GetData call for flushing the command buffer fail to
   // return success occassionally on multi core machines, leading to an
   // infinite loop.
   // Workaround is to have an upper limit of 4 on the number of iterations to
   // wait for the Flush to finish.
 
   HRESULT hr = E_FAIL;
   if (use_dx11_) {
     BOOL query_data = 0;
-    hr = d3d11_device_context_->GetData(d3d11_query_.get(), &query_data,
+    hr = d3d11_device_context_->GetData(d3d11_query_.Get(), &query_data,
                                         sizeof(BOOL), 0);
     if (FAILED(hr))
       DCHECK(false);
   } else {
     hr = query_->GetData(NULL, 0, D3DGETDATA_FLUSH);
   }
 
   if ((hr == S_FALSE) && (++iterations < kMaxIterationsForD3DFlush)) {
     decoder_thread_task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushDecoder,
@@ skipping 29 matching lines @@
     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());
     RETURN_ON_HR_FAILURE(hr, "Failed to enumerate video processors", false);
 
     // TODO(Hubbe): Find correct index
-    hr = video_device_->CreateVideoProcessor(enumerator_.get(), 0,
+    hr = video_device_->CreateVideoProcessor(enumerator_.Get(), 0,
                                              d3d11_processor_.Receive());
     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);
+        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(),
+    video_context_->VideoProcessorSetOutputColorSpace(d3d11_processor_.Get(),
                                                       &d3d11_color_space);
 
-    video_context_->VideoProcessorSetStreamColorSpace(d3d11_processor_.get(), 0,
+    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_.QueryInterface(video_context1.Receive());
       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();
         }
         // Since the video processor doesn't support HLG, let's just do the
         // YUV->RGB conversion and let the output color space be HLG.
         // This won't work well unless color management is on, but if color
         // management is off we don't support HLG anyways.
         if (color_space ==
             gfx::ColorSpace(gfx::ColorSpace::PrimaryID::BT2020,
                             gfx::ColorSpace::TransferID::ARIB_STD_B67,
                             gfx::ColorSpace::MatrixID::BT709,
                             gfx::ColorSpace::RangeID::LIMITED)) {
           video_context1->VideoProcessorSetStreamColorSpace1(
-              d3d11_processor_.get(), 0,
+              d3d11_processor_.Get(), 0,
               DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020);
           video_context1->VideoProcessorSetOutputColorSpace1(
-              d3d11_processor_.get(),
+              d3d11_processor_.Get(),
               DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020);
           dx11_converter_output_color_space_ = color_space.GetAsFullRangeRGB();
         } else {
           DVLOG(2) << "input color space: " << color_space
                    << " DXGIColorSpace: "
                    << gfx::ColorSpaceWin::GetDXGIColorSpace(color_space);
           DVLOG(2) << "output color space:"
                    << dx11_converter_output_color_space_ << " DXGIColorSpace: "
                    << gfx::ColorSpaceWin::GetDXGIColorSpace(
                           dx11_converter_output_color_space_);
           video_context1->VideoProcessorSetStreamColorSpace1(
-              d3d11_processor_.get(), 0,
+              d3d11_processor_.Get(), 0,
               gfx::ColorSpaceWin::GetDXGIColorSpace(color_space));
           video_context1->VideoProcessorSetOutputColorSpace1(
-              d3d11_processor_.get(), gfx::ColorSpaceWin::GetDXGIColorSpace(
+              d3d11_processor_.Get(), gfx::ColorSpaceWin::GetDXGIColorSpace(
                                           dx11_converter_output_color_space_));
         }
       } else {
         D3D11_VIDEO_PROCESSOR_COLOR_SPACE d3d11_color_space =
             gfx::ColorSpaceWin::GetD3D11ColorSpace(color_space);
         video_context_->VideoProcessorSetStreamColorSpace(
-            d3d11_processor_.get(), 0, &d3d11_color_space);
+            d3d11_processor_.Get(), 0, &d3d11_color_space);
         d3d11_color_space = gfx::ColorSpaceWin::GetD3D11ColorSpace(
             dx11_converter_output_color_space_);
         video_context_->VideoProcessorSetOutputColorSpace(
-            d3d11_processor_.get(), &d3d11_color_space);
+            d3d11_processor_.Get(), &d3d11_color_space);
       }
     }
   }
   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());
   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());
+    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()));
     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,
+    hr = MFGetService(output_buffer.Get(), MR_BUFFER_SERVICE,
                       IID_PPV_ARGS(surface.Receive()));
     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()));
        ++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,
+        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
+      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());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from input sample", hr);
 
-  mf::MediaBufferScopedPointer scoped_media_buffer(buffer.get());
+  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();
   return S_OK;
 }
 
 void DXVAVideoDecodeAccelerator::ConfigChanged(const Config& config) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   SetState(kConfigChange);
   Invalidate();
   Initialize(config_, client_);
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 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;
 }
 
 }  // namespace media