cc: Implement overdraw feedback debugging feature.

components/display_compositor/buffer_queue.cc

 // Copyright 2014 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 "components/display_compositor/buffer_queue.h"
 
 #include "base/containers/adapters.h"
 #include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "components/display_compositor/gl_helper.h"
@@ skipping 42 matching lines @@
 
 void BufferQueue::BindFramebuffer() {
   gl_->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
 
   if (!current_surface_)
     current_surface_ = GetNextSurface();
 
   if (current_surface_) {
     gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                               texture_target_, current_surface_->texture, 0);
+    if (current_surface_->stencil) {
+      gl_->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
+                                   GL_RENDERBUFFER, current_surface_->stencil);
+    }
   }
 }
 
 void BufferQueue::CopyBufferDamage(int texture,
                                    int source_texture,
                                    const gfx::Rect& new_damage,
                                    const gfx::Rect& old_damage) {
   gl_helper_->CopySubBufferDamage(texture_target_, texture, source_texture,
                                   SkRegion(gfx::RectToSkIRect(new_damage)),
                                   SkRegion(gfx::RectToSkIRect(old_damage)));
@@ skipping 35 matching lines @@
   }
   UpdateBufferDamage(damage);
   in_flight_surfaces_.push_back(std::move(current_surface_));
   // Some things reset the framebuffer (CopySubBufferDamage, some GLRenderer
   // paths), so ensure we restore it here.
   gl_->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
 }
 
 void BufferQueue::Reshape(const gfx::Size& size,
                           float scale_factor,
-                          const gfx::ColorSpace& color_space) {
-  if (size == size_ && color_space == color_space_)
+                          const gfx::ColorSpace& color_space,
+                          bool use_stencil) {
+  if (size == size_ && color_space == color_space_ &&
+      use_stencil == use_stencil_)
     return;
 #if !defined(OS_MACOSX)
   // TODO(ccameron): This assert is being hit on Mac try jobs. Determine if that
   // is cause for concern or if it is benign.
   // http://crbug.com/524624
   DCHECK(!current_surface_);
 #endif
   size_ = size;
   color_space_ = color_space;
+  use_stencil_ = use_stencil;
 
-  // TODO: add stencil buffer when needed.
   gl_->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
   gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                             texture_target_, 0, 0);
+  gl_->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
+                               GL_RENDERBUFFER, 0);
 
   FreeAllSurfaces();
 }
 
 void BufferQueue::RecreateBuffers() {
   // We need to recreate the buffers, for whatever reason the old ones are not
   // presentable on the device anymore.
   // Unused buffers can be freed directly, they will be re-allocated as needed.
   // Any in flight, current or displayed surface must be replaced.
   available_surfaces_.clear();
@@ skipping 49 matching lines @@
 }
 
 void BufferQueue::FreeSurfaceResources(AllocatedSurface* surface) {
   if (!surface->texture)
     return;
 
   gl_->BindTexture(texture_target_, surface->texture);
   gl_->ReleaseTexImage2DCHROMIUM(texture_target_, surface->image);
   gl_->DeleteTextures(1, &surface->texture);
   gl_->DestroyImageCHROMIUM(surface->image);
+  if (surface->stencil)
+    gl_->DeleteRenderbuffers(1, &surface->stencil);
   surface->buffer.reset();
   allocated_count_--;
 }
 
 std::unique_ptr<BufferQueue::AllocatedSurface> BufferQueue::GetNextSurface() {
   if (!available_surfaces_.empty()) {
     std::unique_ptr<AllocatedSurface> surface =
         std::move(available_surfaces_.back());
     available_surfaces_.pop_back();
     return surface;
   }
 
   GLuint texture;
   gl_->GenTextures(1, &texture);
 
+  GLuint stencil = 0;
+  if (use_stencil_) {
+    gl_->GenRenderbuffers(1, &stencil);
+    gl_->BindRenderbuffer(GL_RENDERBUFFER, stencil);
+    gl_->RenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, size_.width(),
+                             size_.height());
+    gl_->BindRenderbuffer(GL_RENDERBUFFER, 0);
+  }
+
   // We don't want to allow anything more than triple buffering.
   DCHECK_LT(allocated_count_, 4U);
   std::unique_ptr<gfx::GpuMemoryBuffer> buffer(
       gpu_memory_buffer_manager_->CreateGpuMemoryBuffer(
           size_, format_, gfx::BufferUsage::SCANOUT, surface_handle_));
   if (!buffer.get()) {
     gl_->DeleteTextures(1, &texture);
     DLOG(ERROR) << "Failed to allocate GPU memory buffer";
     return nullptr;
   }
   buffer->SetColorSpaceForScanout(color_space_);
 
   uint32_t id =
       gl_->CreateImageCHROMIUM(buffer->AsClientBuffer(), size_.width(),
                                size_.height(), internal_format_);
   if (!id) {
     LOG(ERROR) << "Failed to allocate backing image surface";
     gl_->DeleteTextures(1, &texture);
     return nullptr;
   }
 
   allocated_count_++;
   gl_->BindTexture(texture_target_, texture);
   gl_->BindTexImage2DCHROMIUM(texture_target_, id);
   return base::MakeUnique<AllocatedSurface>(this, std::move(buffer), texture,
-                                            id, gfx::Rect(size_));
+                                            id, stencil, gfx::Rect(size_));
 }
 
 BufferQueue::AllocatedSurface::AllocatedSurface(
     BufferQueue* buffer_queue,
     std::unique_ptr<gfx::GpuMemoryBuffer> buffer,
     uint32_t texture,
     uint32_t image,
+    uint32_t stencil,
     const gfx::Rect& rect)
     : buffer_queue(buffer_queue),
       buffer(buffer.release()),
       texture(texture),
       image(image),
+      stencil(stencil),
       damage(rect) {}
 
 BufferQueue::AllocatedSurface::~AllocatedSurface() {
   buffer_queue->FreeSurfaceResources(this);
 }
 
 }  // namespace display_compositor