Rename ScopedComPtr::Release() to ScopedComPtr::Reset()

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 "base/memory/ptr_util.h"
@@ skipping 214 matching lines @@
 }
 
 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_.Release();
+  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();
@@ skipping 52 matching lines @@
   // YUY2 surfaces must have an even width.
   if (swap_chain_size.width() % 2 == 1)
     swap_chain_size.set_width(swap_chain_size.width() + 1);
 
   InitializeVideoProcessor(ceiled_input_size, swap_chain_size);
 
   bool first_present = false;
   if (!swap_chain_ || swap_chain_size_ != swap_chain_size) {
     first_present = true;
     swap_chain_size_ = swap_chain_size;
-    swap_chain_.Release();
+    swap_chain_.Reset();
     ReallocateSwapChain();
   } else if (last_gl_image_ == image_dxgi) {
     // The swap chain is presenting the same image as last swap, which means
     // that the image was never returned to the video decoder and should have
     // the same contents as last time. It shouldn't need to be redrawn.
     return;
   }
 
   last_gl_image_ = image_dxgi;
 
@@ skipping 64 matching lines @@
       SizeContains(processor_output_size_, out_size))
     return false;
   processor_input_size_ = in_size;
   processor_output_size_ = out_size;
   surface_->InitializeVideoProcessor(in_size, out_size);
 
   video_processor_enumerator_ = surface_->video_processor_enumerator();
   video_processor_ = surface_->video_processor();
   // out_view_ depends on video_processor_enumerator_, so ensure it's
   // recreated if the enumerator is.
-  out_view_.Release();
+  out_view_.Reset();
   return true;
 }
 
 void DCLayerTree::SwapChainPresenter::ReallocateSwapChain() {
   TRACE_EVENT0("gpu", "DCLayerTree::SwapChainPresenter::ReallocateSwapChain");
   DCHECK(!swap_chain_);
 
   base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
   d3d11_device_.QueryInterface(dxgi_device.Receive());
   base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
@@ skipping 41 matching lines @@
     CHECK(SUCCEEDED(hr));
   } else {
     // This is a sensible default colorspace for most videos.
     // TODO(jbauman): Use correct colorspace.
     base::win::ScopedComPtr<IDXGISwapChain3> swap_chain3;
     swap_chain_.QueryInterface(swap_chain3.Receive());
     hr = swap_chain3->SetColorSpace1(
         DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709);
     CHECK(SUCCEEDED(hr));
   }
-  out_view_.Release();
+  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);
 
   IDCompositionVisual2* 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.Release();
+  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());
   }
@@ skipping 245 matching lines @@
   pbuffer_attribs.push_back(EGL_NONE);
   default_surface_ =
       eglCreatePbufferSurface(display, GetConfig(), &pbuffer_attribs[0]);
   CHECK(!!default_surface_);
 
   return true;
 }
 
 void DirectCompositionSurfaceWin::ReleaseCurrentSurface() {
   ReleaseDrawTexture(true);
-  dcomp_surface_.Release();
-  swap_chain_.Release();
+  dcomp_surface_.Reset();
+  swap_chain_.Reset();
 }
 
 void DirectCompositionSurfaceWin::InitializeSurface() {
   TRACE_EVENT1("gpu", "DirectCompositionSurfaceWin::InitializeSurface()",
                "enable_dc_layers_", enable_dc_layers_);
   DCHECK(!dcomp_surface_);
   DCHECK(!swap_chain_);
   DXGI_FORMAT output_format =
       base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableHDR)
           ? DXGI_FORMAT_R16G16B16A16_FLOAT
@@ skipping 35 matching lines @@
     CHECK(SUCCEEDED(hr));
   }
 }
 
 void DirectCompositionSurfaceWin::ReleaseDrawTexture(bool will_discard) {
   if (real_surface_) {
     eglDestroySurface(GetDisplay(), real_surface_);
     real_surface_ = nullptr;
   }
   if (draw_texture_) {
-    draw_texture_.Release();
+    draw_texture_.Reset();
     if (dcomp_surface_) {
       HRESULT hr = dcomp_surface_->EndDraw();
       CHECK(SUCCEEDED(hr));
     } else if (!will_discard) {
       DXGI_PRESENT_PARAMETERS params = {};
       RECT dirty_rect = swap_rect_.ToRECT();
       params.DirtyRectsCount = 1;
       params.pDirtyRects = &dirty_rect;
       swap_chain_->Present1(first_swap_ ? 0 : 1, 0, &params);
       if (first_swap_) {
@@ skipping 29 matching lines @@
       DLOG(ERROR) << "eglDestroySurface failed with error "
                   << ui::GetLastEGLErrorString();
     }
     real_surface_ = nullptr;
   }
   if (dcomp_surface_ && (dcomp_surface_ == g_current_surface)) {
     HRESULT hr = dcomp_surface_->EndDraw();
     CHECK(SUCCEEDED(hr));
     g_current_surface = nullptr;
   }
-  draw_texture_.Release();
-  dcomp_surface_.Release();
+  draw_texture_.Reset();
+  dcomp_surface_.Reset();
 }
 
 gfx::Size DirectCompositionSurfaceWin::GetSize() {
   return size_;
 }
 
 bool DirectCompositionSurfaceWin::IsOffscreen() {
   return false;
 }
 
@@ skipping 152 matching lines @@
 DirectCompositionSurfaceWin::GetWindowTaskRunnerForTesting() {
   return child_window_.GetTaskRunnerForTesting();
 }
 
 base::win::ScopedComPtr<IDXGISwapChain1>
 DirectCompositionSurfaceWin::GetLayerSwapChainForTesting(size_t index) const {
   return layer_tree_->GetLayerSwapChainForTesting(index);
 }
 
 }  // namespace gpu