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

gpu/ipc/service/direct_composition_surface_win.cc

 // Copyright 2017 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 "gpu/ipc/service/direct_composition_surface_win.h"
 
 #include <d3d11_1.h>
 #include <dcomptypes.h>
 
 #include <deque>
@@ skipping 248 matching lines @@
 
   HRESULT hr = desktop_device->CreateTargetForHwnd(window, TRUE,
                                                    dcomp_target_.Receive());
   if (FAILED(hr))
     return false;
 
   hr = dcomp_device_->CreateVisual(root_visual_.Receive());
   if (FAILED(hr))
     return false;
 
-  dcomp_target_->SetRoot(root_visual_.get());
+  dcomp_target_->SetRoot(root_visual_.Get());
   return true;
 }
 
 void DCLayerTree::InitializeVideoProcessor(const gfx::Size& input_size,
                                            const gfx::Size& output_size) {
   if (SizeContains(video_input_size_, input_size) &&
       SizeContains(video_output_size_, output_size))
     return;
   video_input_size_ = input_size;
   video_output_size_ = output_size;
 
   video_processor_.Reset();
   video_processor_enumerator_.Receive();
   D3D11_VIDEO_PROCESSOR_CONTENT_DESC desc = {};
   desc.InputFrameFormat = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
   desc.InputFrameRate.Numerator = 60;
   desc.InputFrameRate.Denominator = 1;
   desc.InputWidth = input_size.width();
   desc.InputHeight = input_size.height();
   desc.OutputFrameRate.Numerator = 60;
   desc.OutputFrameRate.Denominator = 1;
   desc.OutputWidth = output_size.width();
   desc.OutputHeight = output_size.height();
   desc.Usage = D3D11_VIDEO_USAGE_PLAYBACK_NORMAL;
   HRESULT hr = video_device_->CreateVideoProcessorEnumerator(
       &desc, video_processor_enumerator_.Receive());
   CHECK(SUCCEEDED(hr));
 
-  hr = video_device_->CreateVideoProcessor(video_processor_enumerator_.get(), 0,
+  hr = video_device_->CreateVideoProcessor(video_processor_enumerator_.Get(), 0,
                                            video_processor_.Receive());
   CHECK(SUCCEEDED(hr));
 }
 
 base::win::ScopedComPtr<IDXGISwapChain1>
 DCLayerTree::GetLayerSwapChainForTesting(size_t index) const {
   if (index >= visual_info_.size())
     return base::win::ScopedComPtr<IDXGISwapChain1>();
   return visual_info_[index].swap_chain;
 }
@@ skipping 75 matching lines @@
 
   last_gl_image_ = image_dxgi;
 
   if (!out_view_) {
     base::win::ScopedComPtr<ID3D11Texture2D> texture;
     swap_chain_->GetBuffer(0, IID_PPV_ARGS(texture.Receive()));
     D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC out_desc = {};
     out_desc.ViewDimension = D3D11_VPOV_DIMENSION_TEXTURE2D;
     out_desc.Texture2D.MipSlice = 0;
     HRESULT hr = video_device_->CreateVideoProcessorOutputView(
-        texture.get(), video_processor_enumerator_.get(), &out_desc,
+        texture.Get(), video_processor_enumerator_.Get(), &out_desc,
         out_view_.Receive());
     CHECK(SUCCEEDED(hr));
   }
 
   // TODO(jbauman): Use correct colorspace.
   gfx::ColorSpace src_color_space = gfx::ColorSpace::CreateREC709();
   base::win::ScopedComPtr<ID3D11VideoContext1> context1;
   if (SUCCEEDED(video_context_.QueryInterface(context1.Receive()))) {
     context1->VideoProcessorSetStreamColorSpace1(
-        video_processor_.get(), 0,
+        video_processor_.Get(), 0,
         gfx::ColorSpaceWin::GetDXGIColorSpace(src_color_space));
   } else {
     // This can't handle as many different types of color spaces, so use it
     // only if ID3D11VideoContext1 isn't available.
     D3D11_VIDEO_PROCESSOR_COLOR_SPACE color_space =
         gfx::ColorSpaceWin::GetD3D11ColorSpace(src_color_space);
-    video_context_->VideoProcessorSetStreamColorSpace(video_processor_.get(), 0,
+    video_context_->VideoProcessorSetStreamColorSpace(video_processor_.Get(), 0,
                                                       &color_space);
   }
 
   gfx::ColorSpace output_color_space =
       is_yuy2_swapchain_ ? src_color_space : gfx::ColorSpace::CreateSRGB();
   if (base::FeatureList::IsEnabled(kFallbackBT709VideoToBT601) &&
       (output_color_space == gfx::ColorSpace::CreateREC709())) {
     output_color_space = gfx::ColorSpace::CreateREC601();
   }
 
   base::win::ScopedComPtr<IDXGISwapChain3> swap_chain3;
   if (SUCCEEDED(swap_chain_.QueryInterface(swap_chain3.Receive()))) {
     DXGI_COLOR_SPACE_TYPE color_space =
         gfx::ColorSpaceWin::GetDXGIColorSpace(output_color_space);
     HRESULT hr = swap_chain3->SetColorSpace1(color_space);
     CHECK(SUCCEEDED(hr));
     if (context1) {
-      context1->VideoProcessorSetOutputColorSpace1(video_processor_.get(),
+      context1->VideoProcessorSetOutputColorSpace1(video_processor_.Get(),
                                                    color_space);
     } else {
       D3D11_VIDEO_PROCESSOR_COLOR_SPACE d3d11_color_space =
           gfx::ColorSpaceWin::GetD3D11ColorSpace(output_color_space);
-      video_context_->VideoProcessorSetOutputColorSpace(video_processor_.get(),
+      video_context_->VideoProcessorSetOutputColorSpace(video_processor_.Get(),
                                                         &d3d11_color_space);
     }
   }
 
   {
     D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC in_desc = {};
     in_desc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
     in_desc.Texture2D.ArraySlice = (UINT)image_dxgi->level();
     base::win::ScopedComPtr<ID3D11VideoProcessorInputView> in_view;
     HRESULT hr = video_device_->CreateVideoProcessorInputView(
-        image_dxgi->texture().get(), video_processor_enumerator_.get(),
+        image_dxgi->texture().Get(), video_processor_enumerator_.Get(),
         &in_desc, in_view.Receive());
     CHECK(SUCCEEDED(hr));
 
     D3D11_VIDEO_PROCESSOR_STREAM stream = {};
     stream.Enable = true;
     stream.OutputIndex = 0;
     stream.InputFrameOrField = 0;
     stream.PastFrames = 0;
     stream.FutureFrames = 0;
-    stream.pInputSurface = in_view.get();
+    stream.pInputSurface = in_view.Get();
     RECT dest_rect = gfx::Rect(swap_chain_size).ToRECT();
-    video_context_->VideoProcessorSetOutputTargetRect(video_processor_.get(),
+    video_context_->VideoProcessorSetOutputTargetRect(video_processor_.Get(),
                                                       TRUE, &dest_rect);
-    video_context_->VideoProcessorSetStreamDestRect(video_processor_.get(), 0,
+    video_context_->VideoProcessorSetStreamDestRect(video_processor_.Get(), 0,
                                                     TRUE, &dest_rect);
     RECT source_rect = gfx::Rect(ceiled_input_size).ToRECT();
-    video_context_->VideoProcessorSetStreamSourceRect(video_processor_.get(), 0,
+    video_context_->VideoProcessorSetStreamSourceRect(video_processor_.Get(), 0,
                                                       TRUE, &source_rect);
 
     video_context_->VideoProcessorSetStreamAutoProcessingMode(
-        video_processor_.get(), 0, FALSE);
+        video_processor_.Get(), 0, FALSE);
 
-    hr = video_context_->VideoProcessorBlt(video_processor_.get(),
-                                           out_view_.get(), 0, 1, &stream);
+    hr = video_context_->VideoProcessorBlt(video_processor_.Get(),
+                                           out_view_.Get(), 0, 1, &stream);
     CHECK(SUCCEEDED(hr));
   }
 
   swap_chain_scale_x_ = bounds_rect.width() * 1.0f / swap_chain_size.width();
   swap_chain_scale_y_ = bounds_rect.height() * 1.0f / swap_chain_size.height();
 
   if (first_present) {
     swap_chain_->Present(0, 0);
 
     // DirectComposition can display black for a swapchain between the first
     // and second time it's presented to - maybe the first Present can get
     // lost somehow and it shows the wrong buffer. In that case copy the
     // buffers so both have the correct contents, which seems to help. The
     // first Present() after this needs to have SyncInterval > 0, or else the
     // workaround doesn't help.
     base::win::ScopedComPtr<ID3D11Texture2D> dest_texture;
     HRESULT hr =
         swap_chain_->GetBuffer(0, IID_PPV_ARGS(dest_texture.Receive()));
     DCHECK(SUCCEEDED(hr));
     base::win::ScopedComPtr<ID3D11Texture2D> src_texture;
     hr = swap_chain_->GetBuffer(1, IID_PPV_ARGS(src_texture.Receive()));
     DCHECK(SUCCEEDED(hr));
     base::win::ScopedComPtr<ID3D11DeviceContext> context;
     d3d11_device_->GetImmediateContext(context.Receive());
-    context->CopyResource(dest_texture.get(), src_texture.get());
+    context->CopyResource(dest_texture.Get(), src_texture.Get());
   }
 
   swap_chain_->Present(1, 0);
 
   UMA_HISTOGRAM_BOOLEAN("GPU.DirectComposition.SwapchainFormat",
                         is_yuy2_swapchain_);
   frames_since_color_space_change_++;
 
   base::win::ScopedComPtr<IDXGISwapChainMedia> swap_chain_media;
   if (SUCCEEDED(swap_chain_.QueryInterface(swap_chain_media.Receive()))) {
@@ skipping 63 matching lines @@
   }
 
   frames_since_color_space_change_ = 0;
 
   is_yuy2_swapchain_ = false;
   // The composition surface handle isn't actually used, but
   // CreateSwapChainForComposition can't create YUY2 swapchains.
   HRESULT hr = E_FAIL;
   if (yuy2) {
     hr = media_factory->CreateSwapChainForCompositionSurfaceHandle(
-        d3d11_device_.get(), swap_chain_handle_.Get(), &desc, nullptr,
+        d3d11_device_.Get(), swap_chain_handle_.Get(), &desc, nullptr,
         swap_chain_.Receive());
     is_yuy2_swapchain_ = SUCCEEDED(hr);
     failed_to_create_yuy2_swapchain_ = !is_yuy2_swapchain_;
   }
 
   if (!is_yuy2_swapchain_) {
     if (yuy2) {
       DLOG(ERROR) << "YUY2 creation failed with " << std::hex << hr
                   << ". Falling back to BGRA";
     }
     desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
     desc.Flags = 0;
     hr = media_factory->CreateSwapChainForCompositionSurfaceHandle(
-        d3d11_device_.get(), swap_chain_handle_.Get(), &desc, nullptr,
+        d3d11_device_.Get(), swap_chain_handle_.Get(), &desc, nullptr,
         swap_chain_.Receive());
     CHECK(SUCCEEDED(hr));
   }
   out_view_.Reset();
 }
 
 void DCLayerTree::InitVisual(size_t i) {
   DCHECK_GT(visual_info_.size(), i);
   VisualInfo* visual_info = &visual_info_[i];
   if (visual_info->content_visual)
     return;
   DCHECK(!visual_info->clip_visual);
   base::win::ScopedComPtr<IDCompositionVisual2> visual;
   dcomp_device_->CreateVisual(visual_info->clip_visual.Receive());
   dcomp_device_->CreateVisual(visual.Receive());
   visual_info->content_visual = visual;
-  visual_info->clip_visual->AddVisual(visual.get(), FALSE, nullptr);
+  visual_info->clip_visual->AddVisual(visual.Get(), FALSE, nullptr);
 
   IDCompositionVisual2* last_visual =
-      (i > 0) ? visual_info_[i - 1].clip_visual.get() : nullptr;
-  root_visual_->AddVisual(visual_info->clip_visual.get(), TRUE, last_visual);
+      (i > 0) ? visual_info_[i - 1].clip_visual.Get() : nullptr;
+  root_visual_->AddVisual(visual_info->clip_visual.Get(), TRUE, last_visual);
 }
 
 void DCLayerTree::UpdateVisualForVideo(
     VisualInfo* visual_info,
     const ui::DCRendererLayerParams& params) {
   base::win::ScopedComPtr<IDCompositionVisual2> dc_visual =
       visual_info->content_visual;
 
   gfx::Rect bounds_rect = params.rect;
   visual_info->surface.Reset();
   if (!visual_info->swap_chain_presenter) {
     visual_info->swap_chain_presenter =
         base::MakeUnique<SwapChainPresenter>(this, d3d11_device_);
   }
   visual_info->swap_chain_presenter->PresentToSwapChain(params);
   if (visual_info->swap_chain !=
       visual_info->swap_chain_presenter->swap_chain()) {
     visual_info->swap_chain = visual_info->swap_chain_presenter->swap_chain();
-    dc_visual->SetContent(visual_info->swap_chain.get());
+    dc_visual->SetContent(visual_info->swap_chain.Get());
   }
 
   if (visual_info->swap_chain_presenter->swap_chain_scale_x() !=
           visual_info->swap_chain_scale_x ||
       visual_info->swap_chain_presenter->swap_chain_scale_y() !=
           visual_info->swap_chain_scale_y ||
       params.transform != visual_info->transform ||
       visual_info->bounds != bounds_rect) {
     visual_info->swap_chain_scale_x =
         visual_info->swap_chain_presenter->swap_chain_scale_x();
@@ skipping 14 matching lines @@
     dc_visual->SetOffsetY(bounds_rect.y());
     base::win::ScopedComPtr<IDCompositionMatrixTransform> dcomp_transform;
     dcomp_device_->CreateMatrixTransform(dcomp_transform.Receive());
     D2D_MATRIX_3X2_F d2d_matrix = {{{final_transform.matrix().get(0, 0),
                                      final_transform.matrix().get(0, 1),
                                      final_transform.matrix().get(1, 0),
                                      final_transform.matrix().get(1, 1),
                                      final_transform.matrix().get(3, 0),
                                      final_transform.matrix().get(3, 1)}}};
     dcomp_transform->SetMatrix(d2d_matrix);
-    dc_visual->SetTransform(dcomp_transform.get());
+    dc_visual->SetTransform(dcomp_transform.Get());
   }
 }
 
 void DCLayerTree::UpdateVisualForBackbuffer(
     VisualInfo* visual_info,
     const ui::DCRendererLayerParams& params) {
   base::win::ScopedComPtr<IDCompositionVisual2> dc_visual =
       visual_info->content_visual;
 
   visual_info->swap_chain_presenter = nullptr;
   if ((visual_info->surface != surface_->dcomp_surface()) ||
       (visual_info->swap_chain != surface_->swap_chain())) {
     visual_info->surface = surface_->dcomp_surface();
     visual_info->swap_chain = surface_->swap_chain();
     if (visual_info->surface) {
-      dc_visual->SetContent(visual_info->surface.get());
+      dc_visual->SetContent(visual_info->surface.Get());
     } else if (visual_info->swap_chain) {
-      dc_visual->SetContent(visual_info->swap_chain.get());
+      dc_visual->SetContent(visual_info->swap_chain.Get());
     } else {
       dc_visual->SetContent(nullptr);
     }
   }
 
   gfx::Rect bounds_rect = params.rect;
   if (visual_info->bounds != bounds_rect ||
       !visual_info->transform.IsIdentity()) {
     dc_visual->SetOffsetX(bounds_rect.x());
     dc_visual->SetOffsetY(bounds_rect.y());
@@ skipping 13 matching lines @@
     visual_info->is_clipped = params.is_clipped;
     visual_info->clip_rect = params.clip_rect;
     if (params.is_clipped) {
       base::win::ScopedComPtr<IDCompositionRectangleClip> clip;
       dcomp_device_->CreateRectangleClip(clip.Receive());
       gfx::Rect offset_clip = params.clip_rect;
       clip->SetLeft(offset_clip.x());
       clip->SetRight(offset_clip.right());
       clip->SetBottom(offset_clip.bottom());
       clip->SetTop(offset_clip.y());
-      visual_info->clip_visual->SetClip(clip.get());
+      visual_info->clip_visual->SetClip(clip.Get());
     } else {
       visual_info->clip_visual->SetClip(nullptr);
     }
   }
 }
 
 bool DCLayerTree::CommitAndClearPendingOverlays() {
   TRACE_EVENT1("gpu", "DCLayerTree::CommitAndClearPendingOverlays", "size",
                pending_overlays_.size());
   UMA_HISTOGRAM_BOOLEAN("GPU.DirectComposition.OverlaysUsed",
                         !pending_overlays_.empty());
   // Add an overlay with z-order 0 representing the main plane.
   gfx::Size surface_size = surface_->GetSize();
   pending_overlays_.push_back(base::MakeUnique<ui::DCRendererLayerParams>(
       false, gfx::Rect(), 0, gfx::Transform(), nullptr,
       gfx::RectF(gfx::SizeF(surface_size)), gfx::Rect(surface_size), 0, 0, 1.0,
       0));
 
   // TODO(jbauman): Reuse swapchains that are switched between overlays and
   // underlays.
   std::sort(pending_overlays_.begin(), pending_overlays_.end(),
             [](const auto& a, const auto& b) -> bool {
               return a->z_order < b->z_order;
             });
 
   while (visual_info_.size() > pending_overlays_.size()) {
     visual_info_.back().clip_visual->RemoveAllVisuals();
-    root_visual_->RemoveVisual(visual_info_.back().clip_visual.get());
+    root_visual_->RemoveVisual(visual_info_.back().clip_visual.Get());
     visual_info_.pop_back();
   }
 
   visual_info_.resize(pending_overlays_.size());
 
   // The overall visual tree has one clip visual for every overlay (including
   // the main plane). The clip visuals are in z_order and are all children of
   // a root visual. Each clip visual has a child visual that has the actual
   // plane content.
 
@@ skipping 162 matching lines @@
     desc.Format = output_format;
     desc.Stereo = FALSE;
     desc.SampleDesc.Count = 1;
     desc.BufferCount = 2;
     desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
     desc.Scaling = DXGI_SCALING_STRETCH;
     desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
     desc.AlphaMode = alpha_mode;
     desc.Flags = 0;
     HRESULT hr = dxgi_factory->CreateSwapChainForComposition(
-        d3d11_device_.get(), &desc, nullptr, swap_chain_.Receive());
+        d3d11_device_.Get(), &desc, nullptr, swap_chain_.Receive());
     has_been_rendered_to_ = false;
     first_swap_ = true;
     CHECK(SUCCEEDED(hr));
   }
 }
 
 void DirectCompositionSurfaceWin::ReleaseDrawTexture(bool will_discard) {
   if (real_surface_) {
     eglDestroySurface(GetDisplay(), real_surface_);
     real_surface_ = nullptr;
@@ skipping 132 matching lines @@
 bool DirectCompositionSurfaceWin::OnMakeCurrent(gl::GLContext* context) {
   if (g_current_surface != dcomp_surface_) {
     if (g_current_surface) {
       HRESULT hr = g_current_surface->SuspendDraw();
       CHECK(SUCCEEDED(hr));
       g_current_surface = nullptr;
     }
     if (draw_texture_) {
       HRESULT hr = dcomp_surface_->ResumeDraw();
       CHECK(SUCCEEDED(hr));
-      g_current_surface = dcomp_surface_.get();
+      g_current_surface = dcomp_surface_.Get();
     }
   }
   return true;
 }
 
 bool DirectCompositionSurfaceWin::SupportsDCLayers() const {
   return true;
 }
 
 bool DirectCompositionSurfaceWin::SetDrawRectangle(const gfx::Rect& rectangle) {
@@ skipping 28 matching lines @@
     CHECK(SUCCEEDED(hr));
   } else {
     HRESULT hr =
         swap_chain_->GetBuffer(0, IID_PPV_ARGS(draw_texture_.Receive()));
     swap_rect_ = rectangle;
     draw_offset_ = gfx::Vector2d();
     CHECK(SUCCEEDED(hr));
   }
   has_been_rendered_to_ = true;
 
-  g_current_surface = dcomp_surface_.get();
+  g_current_surface = dcomp_surface_.Get();
 
   std::vector<EGLint> pbuffer_attribs{
       EGL_WIDTH,
       size_.width(),
       EGL_HEIGHT,
       size_.height(),
       EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE,
       EGL_TRUE,
       EGL_NONE};
 
   EGLClientBuffer buffer =
-      reinterpret_cast<EGLClientBuffer>(draw_texture_.get());
+      reinterpret_cast<EGLClientBuffer>(draw_texture_.Get());
   real_surface_ = eglCreatePbufferFromClientBuffer(
       GetDisplay(), EGL_D3D_TEXTURE_ANGLE, buffer, GetConfig(),
       &pbuffer_attribs[0]);
 
   return true;
 }
 
 gfx::Vector2d DirectCompositionSurfaceWin::GetDrawOffset() const {
   return draw_offset_;
 }
 
 scoped_refptr<base::TaskRunner>
 DirectCompositionSurfaceWin::GetWindowTaskRunnerForTesting() {
   return child_window_.GetTaskRunnerForTesting();
 }
 
 base::win::ScopedComPtr<IDXGISwapChain1>
 DirectCompositionSurfaceWin::GetLayerSwapChainForTesting(size_t index) const {
   return layer_tree_->GetLayerSwapChainForTesting(index);
 }
 
 }  // namespace gpu