Revert of cc: Add mailbox support to ResourceProvider write locks.

cc/output/gl_renderer.cc

 // Copyright 2010 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 "cc/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 577 matching lines @@
 }
 
 static sk_sp<SkImage> WrapTexture(
     const ResourceProvider::ScopedReadLockGL& lock,
     GrContext* context) {
   // Wrap a given texture in a Ganesh platform texture.
   GrBackendTextureDesc backend_texture_description;
   GrGLTextureInfo texture_info;
   texture_info.fTarget = lock.target();
   texture_info.fID = lock.texture_id();
-  backend_texture_description.fWidth = lock.size().width();
-  backend_texture_description.fHeight = lock.size().height();
+  backend_texture_description.fWidth = lock.texture_size().width();
+  backend_texture_description.fHeight = lock.texture_size().height();
   backend_texture_description.fConfig = kSkia8888_GrPixelConfig;
   backend_texture_description.fTextureHandle =
       skia::GrGLTextureInfoToGrBackendObject(texture_info);
   backend_texture_description.fOrigin = kBottomLeft_GrSurfaceOrigin;
 
   return SkImage::MakeFromTexture(context, backend_texture_description);
 }
 
 static sk_sp<SkImage> ApplyImageFilter(
     std::unique_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,
@@ skipping 209 matching lines @@
 
 std::unique_ptr<ScopedResource> GLRenderer::GetBackdropTexture(
     const gfx::Rect& bounding_rect) {
   std::unique_ptr<ScopedResource> device_background_texture =
       ScopedResource::Create(resource_provider_);
   // CopyTexImage2D fails when called on a texture having immutable storage.
   device_background_texture->Allocate(
       bounding_rect.size(), ResourceProvider::TEXTURE_HINT_DEFAULT,
       resource_provider_->best_texture_format());
   {
-    ResourceProvider::ScopedWriteLockGL lock(
-        resource_provider_, device_background_texture->id(), false);
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider_,
+                                             device_background_texture->id());
     GetFramebufferTexture(lock.texture_id(), RGBA_8888, bounding_rect);
   }
   return device_background_texture;
 }
 
 sk_sp<SkImage> GLRenderer::ApplyBackgroundFilters(
     DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     ScopedResource* background_texture,
     const gfx::RectF& rect) {
@@ skipping 1611 matching lines @@
     draw_cache_.matrix_location = binding.matrix_location;
     draw_cache_.sampler_location = binding.sampler_location;
   }
 
   // Generate the uv-transform
   Float4 uv_transform = {{0.0f, 0.0f, 1.0f, 1.0f}};
   if (!clip_region)
     uv_transform = UVTransform(quad);
   if (sampler == SAMPLER_TYPE_2D_RECT) {
     // Un-normalize the texture coordiantes for rectangle targets.
-    gfx::Size texture_size = lock.size();
+    gfx::Size texture_size = lock.texture_size();
     uv_transform.data[0] *= texture_size.width();
     uv_transform.data[2] *= texture_size.width();
     uv_transform.data[1] *= texture_size.height();
     uv_transform.data[3] *= texture_size.height();
   }
   draw_cache_.uv_xform_data.push_back(uv_transform);
 
   // Generate the vertex opacity
   const float opacity = quad->shared_quad_state->opacity;
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[0] * opacity);
@@ skipping 243 matching lines @@
   // |swapped_and_acked_overlay_resources_|, and then erases resources from
   // |swapped_and_acked_overlay_resources_| that are no longer in use by the
   // Window Server. On other platforms, since resources are never in use by the
   // Window Server, this is equivalent to just erasing all resources from the
   // first element of |swapping_overlay_resources_|.
   if (settings_->release_overlay_resources_on_swap_complete) {
     // Move resources known to be acked into
     // |swapped_and_acked_overlay_resources_|.
     if (!swapping_overlay_resources_.empty()) {
       for (OverlayResourceLock& lock : swapping_overlay_resources_.front()) {
-        swapped_and_acked_overlay_resources_[lock->resource_id()] =
+        swapped_and_acked_overlay_resources_[lock->GetResourceId()] =
             std::move(lock);
       }
       swapping_overlay_resources_.pop_front();
     }
 
     // Release resources that are no longer in use by the Window Server.
     auto it = swapped_and_acked_overlay_resources_.begin();
     while (it != swapped_and_acked_overlay_resources_.end()) {
-      if (it->second->gpu_memory_buffer() &&
-          it->second->gpu_memory_buffer()->IsInUseByMacOSWindowServer()) {
+      if (it->second->GetGpuMemoryBuffer() &&
+          it->second->GetGpuMemoryBuffer()->IsInUseByMacOSWindowServer()) {
         ++it;
         continue;
       }
 
       it = swapped_and_acked_overlay_resources_.erase(it);
     }
   }
 }
 
 void GLRenderer::EnforceMemoryPolicy() {
@@ skipping 243 matching lines @@
   DCHECK(texture->id());
 
   // Explicitly release lock, otherwise we can crash when try to lock
   // same texture again.
   current_framebuffer_lock_ = nullptr;
 
   SetStencilEnabled(false);
   gl_->BindFramebuffer(GL_FRAMEBUFFER, offscreen_framebuffer_id_);
   current_framebuffer_lock_ =
       base::WrapUnique(new ResourceProvider::ScopedWriteLockGL(
-          resource_provider_, texture->id(), false));
+          resource_provider_, texture->id()));
   unsigned texture_id = current_framebuffer_lock_->texture_id();
   gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                             texture_id, 0);
 
   DCHECK(gl_->CheckFramebufferStatus(GL_FRAMEBUFFER) ==
              GL_FRAMEBUFFER_COMPLETE ||
          IsContextLost());
   return true;
 }
 
@@ skipping 580 matching lines @@
   return gl_->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
 }
 
 void GLRenderer::ScheduleCALayers(DrawingFrame* frame) {
   for (const CALayerOverlay& ca_layer_overlay : frame->ca_layer_overlay_list) {
     unsigned texture_id = 0;
     if (ca_layer_overlay.contents_resource_id) {
       pending_overlay_resources_.push_back(
           base::WrapUnique(new ResourceProvider::ScopedReadLockGpuMemoryBuffer(
               resource_provider_, ca_layer_overlay.contents_resource_id)));
-      texture_id = pending_overlay_resources_.back()->texture_id();
+      texture_id = pending_overlay_resources_.back()->GetTextureId();
     }
     GLfloat contents_rect[4] = {
         ca_layer_overlay.contents_rect.x(), ca_layer_overlay.contents_rect.y(),
         ca_layer_overlay.contents_rect.width(),
         ca_layer_overlay.contents_rect.height(),
     };
     GLfloat bounds_rect[4] = {
         ca_layer_overlay.bounds_rect.x(), ca_layer_overlay.bounds_rect.y(),
         ca_layer_overlay.bounds_rect.width(),
         ca_layer_overlay.bounds_rect.height(),
@@ skipping 22 matching lines @@
   OverlayCandidateList& overlays = frame->overlay_list;
   for (const OverlayCandidate& overlay : overlays) {
     unsigned texture_id = 0;
     if (overlay.use_output_surface_for_resource) {
       texture_id = output_surface_->GetOverlayTextureId();
       DCHECK(texture_id || IsContextLost());
     } else {
       pending_overlay_resources_.push_back(
           base::WrapUnique(new ResourceProvider::ScopedReadLockGpuMemoryBuffer(
               resource_provider_, overlay.resource_id)));
-      texture_id = pending_overlay_resources_.back()->texture_id();
+      texture_id = pending_overlay_resources_.back()->GetTextureId();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
 }  // namespace cc