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

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 222 matching lines @@
     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());
     RETURN_ON_HR_FAILURE(hr, "Failed to create texture", false);
     if (decoder.use_keyed_mutex_) {
-      hr = dx11_keyed_mutex_.QueryFrom(dx11_decoding_texture_.get());
+      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());
+    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,
@@ skipping 20 matching lines @@
     ID3D11Texture2D* dx11_texture,
     int input_buffer_id) {
   DCHECK_EQ(BOUND, state_);
   state_ = COPYING;
   DCHECK(dest_surface || dx11_texture);
   if (dx11_texture) {
     // Grab a reference on the decoder texture. This reference will be released
     // when we receive a notification that the copy was completed or when the
     // DXVAPictureBuffer instance is destroyed.
     decoder_dx11_texture_ = dx11_texture;
-    decoder->CopyTexture(dx11_texture, dx11_decoding_texture_.get(),
+    decoder->CopyTexture(dx11_texture, dx11_decoding_texture_.Get(),
                          dx11_keyed_mutex_, keyed_mutex_value_, id(),
                          input_buffer_id, color_space_);
     return true;
   }
   D3DSURFACE_DESC surface_desc;
   HRESULT hr = dest_surface->GetDesc(&surface_desc);
   RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
 
   D3DSURFACE_DESC texture_desc;
   decoding_texture_->GetLevelDesc(0, &texture_desc);
@@ skipping 16 matching lines @@
 
   // 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());
   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(),
+  decoder->CopySurface(decoder_surface_.Get(), target_surface_.Get(), id(),
                        input_buffer_id, color_space_);
   color_space_ = gfx::ColorSpace();
   return true;
 }
 
 gl::GLFence* PbufferPictureBuffer::reuse_fence() {
   return reuse_fence_.get();
 }
 
 bool PbufferPictureBuffer::CopySurfaceComplete(
     IDirect3DSurface9* src_surface,
     IDirect3DSurface9* dest_surface) {
   DCHECK_EQ(COPYING, state_);
   state_ = IN_CLIENT;
 
   GLint current_texture = 0;
   glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
 
   glBindTexture(GL_TEXTURE_2D, picture_buffer_.service_texture_ids()[0]);
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 
   if (src_surface && dest_surface) {
-    DCHECK_EQ(src_surface, decoder_surface_.get());
-    DCHECK_EQ(dest_surface, target_surface_.get());
+    DCHECK_EQ(src_surface, decoder_surface_.Get());
+    DCHECK_EQ(dest_surface, target_surface_.Get());
     decoder_surface_.Reset();
     target_surface_.Reset();
   } else {
-    DCHECK(decoder_dx11_texture_.get());
+    DCHECK(decoder_dx11_texture_.Get());
     decoder_dx11_texture_.Reset();
   }
   if (egl_keyed_mutex_) {
     keyed_mutex_value_++;
     HRESULT result =
         egl_keyed_mutex_->AcquireSync(keyed_mutex_value_, kAcquireSyncWaitMs);
     RETURN_ON_FAILURE(result == S_OK, "Could not acquire sync mutex", false);
   }
 
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
@@ skipping 113 matching lines @@
 
   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());
   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());
+  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()));
   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()),
+      egl_display, stream_, static_cast<void*>(dx11_decoding_texture_.Get()),
       frame_attributes);
   RETURN_ON_FAILURE(result, "Could not post texture", false);
   result = eglStreamConsumerAcquireKHR(egl_display, stream_);
   RETURN_ON_FAILURE(result, "Could not post acquire stream", false);
   gl::GLImageDXGI* gl_image_dxgi =
       gl::GLImageDXGI::FromGLImage(gl_image_.get());
   DCHECK(gl_image_dxgi);
 
   gl_image_dxgi->SetTexture(dx11_decoding_texture_, subresource);
   return true;
@@ skipping 68 matching lines @@
   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());
   RETURN_ON_HR_FAILURE(hr, "Failed to create texture", false);
   DCHECK(decoder.use_keyed_mutex_);
-  hr = dx11_keyed_mutex_.QueryFrom(decoder_copy_texture_.get());
+  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());
+  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()));
   RETURN_ON_HR_FAILURE(hr, "Failed to open shared resource", false);
-  hr = egl_keyed_mutex_.QueryFrom(angle_copy_texture_.get());
+  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,
     int input_buffer_id) {
   DCHECK_EQ(BOUND, state_);
   state_ = COPYING;
   DCHECK(dx11_texture);
   // Grab a reference on the decoder texture. This reference will be released
   // when we receive a notification that the copy was completed or when the
   // DXVAPictureBuffer instance is destroyed.
   dx11_decoding_texture_ = dx11_texture;
-  decoder->CopyTexture(dx11_texture, decoder_copy_texture_.get(),
+  decoder->CopyTexture(dx11_texture, decoder_copy_texture_.Get(),
                        dx11_keyed_mutex_, keyed_mutex_value_, id(),
                        input_buffer_id, color_space_);
   // The texture copy will acquire the current keyed mutex value and release
   // with the value + 1.
   keyed_mutex_value_++;
   return true;
 }
 
 bool EGLStreamCopyPictureBuffer::CopySurfaceComplete(
     IDirect3DSurface9* src_surface,
     IDirect3DSurface9* dest_surface) {
   DCHECK(!src_surface);
   DCHECK(!dest_surface);
   DCHECK_EQ(COPYING, state_);
   state_ = IN_CLIENT;
 
   dx11_decoding_texture_.Reset();
 
   HRESULT hr =
       egl_keyed_mutex_->AcquireSync(keyed_mutex_value_, kAcquireSyncWaitMs);
   RETURN_ON_FAILURE(hr == S_OK, "Could not acquire sync mutex", false);
 
   EGLAttrib frame_attributes[] = {
       EGL_D3D_TEXTURE_SUBRESOURCE_ID_ANGLE, 0, EGL_NONE,
   };
 
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
 
   EGLBoolean result = eglStreamPostD3DTextureNV12ANGLE(
-      egl_display, stream_, static_cast<void*>(angle_copy_texture_.get()),
+      egl_display, stream_, static_cast<void*>(angle_copy_texture_.Get()),
       frame_attributes);
   RETURN_ON_FAILURE(result, "Could not post stream", false);
   result = eglStreamConsumerAcquireKHR(egl_display, stream_);
   RETURN_ON_FAILURE(result, "Could not post acquire stream", false);
   gl::GLImageDXGI* gl_image_dxgi =
       gl::GLImageDXGI::FromGLImage(gl_image_.get());
   DCHECK(gl_image_dxgi);
 
   gl_image_dxgi->SetTexture(angle_copy_texture_, 0);
 
@@ skipping 15 matching lines @@
     RETURN_ON_FAILURE(result, "Could not release stream", false);
   }
   return true;
 }
 
 bool EGLStreamCopyPictureBuffer::AllowOverlay() const {
   return true;
 }
 
 }  // namespace media