Perform glReadPixels with PBOs in the gpu, if PBOs are available.

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 278 matching lines @@
     GLbitfield clear_bits = GL_COLOR_BUFFER_BIT;
     // Only the Skia GPU backend uses the stencil buffer.  No need to clear it
     // otherwise.
     if (CanUseSkiaGPUBackend())
       clear_bits |= GL_STENCIL_BUFFER_BIT;
     context_->clear(clear_bits);
   }
 }
 
 void GLRenderer::BeginDrawingFrame(DrawingFrame* frame) {
-  // FIXME: Remove this once backbuffer is automatically recreated on first use
+  // TODO(hubbe): Remove this once backbuffer is automatically recreated
+  // on first use.
   EnsureBackbuffer();
 
   if (client_->DeviceViewport().IsEmpty())
     return;
 
   TRACE_EVENT0("cc", "GLRenderer::DrawLayers");
 
   MakeContextCurrent();
 
   ReinitializeGLState();
@@ skipping 269 matching lines @@
   // quad since the destination texture has bounds matching the quad's content.
   // 5. Draw the background texture for the contents using the same transform as
   // used to draw the contents itself. This is done without blending to replace
   // the current background pixels with the new filtered background.
   // 6. Draw the contents of the quad over drop of the new background with
   // blending, as per usual. The filtered background pixels will show through
   // any non-opaque pixels in this draws.
   //
   // Pixel copies in this algorithm occur at steps 2, 3, 4, and 5.
 
-  // FIXME: When this algorithm changes, update
+  // TODO(hubbe): When this algorithm changes, update
   // LayerTreeHost::PrioritizeTextures() accordingly.
 
   FilterOperations filters =
       RenderSurfaceFilters::Optimize(quad->background_filters);
   DCHECK(!filters.IsEmpty());
 
-  // FIXME: We only allow background filters on an opaque render surface because
-  // other surfaces may contain translucent pixels, and the contents behind
-  // those translucent pixels wouldn't have the filter applied.
+  // TODO(hubbe): We only allow background filters on an opaque render surface
+  // because other surfaces may contain translucent pixels, and the contents
+  // behind those translucent pixels wouldn't have the filter applied.
   if (frame->current_render_pass->has_transparent_background)
     return scoped_ptr<ScopedResource>();
   DCHECK(!frame->current_texture);
 
-  // FIXME: Do a single readback for both the surface and replica and cache the
-  // filtered results (once filter textures are not reused).
+  // TODO(hubbe): Do a single readback for both the surface and replica and
+  // cache the filtered results (once filter textures are not reused).
   gfx::Rect window_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect(
       contents_device_transform, SharedGeometryQuad().BoundingBox()));
 
   int top, right, bottom, left;
   filters.GetOutsets(&top, &right, &bottom, &left);
   window_rect.Inset(-left, -top, -right, -bottom);
 
   window_rect.Intersect(
       MoveFromDrawToWindowSpace(frame->current_render_pass->output_rect));
 
@@ skipping 100 matching lines @@
     background_texture = DrawBackgroundFilters(
         frame,
         quad,
         contents_device_transform,
         contents_device_transform_inverse);
 
     if (disable_blending)
       SetBlendEnabled(true);
   }
 
-  // FIXME: Cache this value so that we don't have to do it for both the surface
-  // and its replica.  Apply filters to the contents texture.
+  // TODO(hubbe): Cache this value so that we don't have to do it for both the
+  // surface and its replica.  Apply filters to the contents texture.
   SkBitmap filter_bitmap;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
   if (quad->filter) {
     SkColorFilter* cf;
     if ((quad->filter->asColorFilter(&cf)) && cf->asColorMatrix(color_matrix) &&
         !quad->filter->getInput(0)) {
       // We have a single color matrix as a filter; apply it locally
       // in the compositor.
       use_color_matrix = true;
@@ skipping 50 matching lines @@
   }
 
   scoped_ptr<ResourceProvider::ScopedReadLockGL> mask_resource_lock;
   unsigned mask_texture_id = 0;
   if (quad->mask_resource_id) {
     mask_resource_lock.reset(new ResourceProvider::ScopedReadLockGL(
         resource_provider_, quad->mask_resource_id));
     mask_texture_id = mask_resource_lock->texture_id();
   }
 
-  // FIXME: use the background_texture and blend the background in with this
-  // draw instead of having a separate copy of the background texture.
+  // TODO(hubbe): use the background_texture and blend the background
+  // in with this draw instead of having a separate copy of the background
+  // texture.
 
   scoped_ptr<ResourceProvider::ScopedReadLockGL> contents_resource_lock;
   if (filter_bitmap.getTexture()) {
     GrTexture* texture =
         reinterpret_cast<GrTexture*>(filter_bitmap.getTexture());
     Context()->bindTexture(GL_TEXTURE_2D, texture->getTextureHandle());
   } else {
     contents_resource_lock = make_scoped_ptr(
         new ResourceProvider::ScopedSamplerGL(resource_provider_,
                                               contents_texture->id(),
@@ skipping 1494 matching lines @@
   }
 
   unsigned buffer = context_->createBuffer();
   GLC(context_, context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                                      buffer));
   GLC(context_, context_->bufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                                      4 * window_rect.size().GetArea(),
                                      NULL,
                                      GL_STREAM_READ));
 
+  WebKit::WebGLId query = 0;
+  if (is_async) {
+    query = context_->createQueryEXT();
+    GLC(context_, context_->beginQueryEXT(
+        GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM,
+        query));
+  }
+
   GLC(context_,
       context_->readPixels(window_rect.x(),
                            window_rect.y(),
                            window_rect.width(),
                            window_rect.height(),
                            GL_RGBA,
                            GL_UNSIGNED_BYTE,
                            NULL));
 
   GLC(context_, context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                                      0));
 
   if (do_workaround) {
     // Clean up.
     GLC(context_, context_->bindFramebuffer(GL_FRAMEBUFFER, 0));
     GLC(context_, context_->bindTexture(GL_TEXTURE_2D, 0));
     GLC(context_, context_->deleteFramebuffer(temporary_fbo));
     GLC(context_, context_->deleteTexture(temporary_texture));
   }
 
   base::Closure finished_callback =
       base::Bind(&GLRenderer::FinishedReadback,
                  base::Unretained(this),
                  cleanup_callback,
                  buffer,
+                 query,
                  dest_pixels,
                  window_rect.size());
   // Save the finished_callback so it can be cancelled.
   pending_async_read_pixels_.front()->finished_read_pixels_callback.Reset(
       finished_callback);
 
   // Save the buffer to verify the callbacks happen in the expected order.
   pending_async_read_pixels_.front()->buffer = buffer;
 
   if (is_async) {
-    unsigned sync_point = context_->insertSyncPoint();
-    SyncPointHelper::SignalSyncPoint(
+    GLC(context_, context_->endQueryEXT(
+        GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM));
+    SyncPointHelper::SignalQuery(
         context_,
-        sync_point,
+        query,
         finished_callback);
   } else {
     resource_provider_->Finish();
     finished_callback.Run();
   }
 
   EnforceMemoryPolicy();
 }
 
 void GLRenderer::FinishedReadback(
     const AsyncGetFramebufferPixelsCleanupCallback& cleanup_callback,
     unsigned source_buffer,
+    unsigned query,
     uint8* dest_pixels,
     gfx::Size size) {
   DCHECK(!pending_async_read_pixels_.empty());
 
+  if (query != 0) {
+    GLC(context_, context_->deleteQueryEXT(query));
+  }
+
   PendingAsyncReadPixels* current_read = pending_async_read_pixels_.back();
   // Make sure we service the readbacks in order.
   DCHECK_EQ(source_buffer, current_read->buffer);
 
   uint8* src_pixels = NULL;
 
   if (source_buffer != 0) {
     GLC(context_, context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                                        source_buffer));
     src_pixels = static_cast<uint8*>(
@@ skipping 659 matching lines @@
   // The Skia GPU backend requires a stencil buffer.  See ReinitializeGrCanvas
   // implementation.
   return gr_context_ && context_->getContextAttributes().stencil;
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc