cc: Add CopyAsBitmapRequest class to hold the readback callback.

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>
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/strings/string_split.h"
 #include "build/build_config.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/video_layer_impl.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/context_provider.h"
+#include "cc/output/copy_output_request.h"
 #include "cc/output/geometry_binding.h"
 #include "cc/output/gl_frame_data.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/render_surface_filters.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/layer_quad.h"
 #include "cc/resources/priority_calculator.h"
@@ skipping 54 matching lines @@
 
 // Smallest unit that impact anti-aliasing output. We use this to
 // determine when anti-aliasing is unnecessary.
 const float kAntiAliasingEpsilon = 1.0f / 1024.0f;
 
 }  // anonymous namespace
 
 struct GLRenderer::PendingAsyncReadPixels {
   PendingAsyncReadPixels() : buffer(0) {}
 
-  CopyRenderPassCallback copy_callback;
+  scoped_ptr<CopyOutputRequest> copy_request;
   base::CancelableClosure finished_read_pixels_callback;
   unsigned buffer;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PendingAsyncReadPixels);
 };
 
 scoped_ptr<GLRenderer> GLRenderer::Create(RendererClient* client,
                                           OutputSurface* output_surface,
                                           ResourceProvider* resource_provider,
@@ skipping 108 matching lines @@
     return;
 
   gr_context_ = skia::AdoptRef(GrContext::Create(
       kOpenGL_GrBackend,
       reinterpret_cast<GrBackendContext>(interface.get())));
   ReinitializeGrCanvas();
 }
 
 GLRenderer::~GLRenderer() {
   while (!pending_async_read_pixels_.empty()) {
-    pending_async_read_pixels_.back()->finished_read_pixels_callback.Cancel();
-    pending_async_read_pixels_.back()->copy_callback.Run(
-        scoped_ptr<SkBitmap>());
+    PendingAsyncReadPixels* pending_read = pending_async_read_pixels_.back();
+    pending_read->finished_read_pixels_callback.Cancel();
     pending_async_read_pixels_.pop_back();
   }
 
   context_->setMemoryAllocationChangedCallbackCHROMIUM(NULL);
   CleanupSharedObjects();
 }
 
 const RendererCapabilities& GLRenderer::Capabilities() const {
   return capabilities_;
 }
@@ skipping 1623 matching lines @@
   if (!is_scissor_enabled_)
     return;
 
   FlushTextureQuadCache();
   GLC(context_, context_->disable(GL_SCISSOR_TEST));
   is_scissor_enabled_ = false;
 }
 
 void GLRenderer::CopyCurrentRenderPassToBitmap(
     DrawingFrame* frame,
-    const CopyRenderPassCallback& callback) {
+    scoped_ptr<CopyOutputRequest> request) {
   GetFramebufferPixelsAsync(frame->current_render_pass->output_rect,
                             frame->flipped_y,
-                            callback);
+                            request.Pass());
 }
 
 void GLRenderer::ToGLMatrix(float* gl_matrix, const gfx::Transform& transform) {
   transform.matrix().asColMajorf(gl_matrix);
 }
 
 void GLRenderer::SetShaderQuadF(const gfx::QuadF& quad, int quad_location) {
   if (quad_location == -1)
     return;
 
@@ skipping 198 matching lines @@
   pending_async_read_pixels_.insert(pending_async_read_pixels_.begin(),
                                     pending_read.Pass());
 
   // This is a syncronous call since the callback is null.
   DoGetFramebufferPixels(static_cast<uint8*>(pixels),
                          rect,
                          flipped_y,
                          AsyncGetFramebufferPixelsCleanupCallback());
 }
 
-void GLRenderer::GetFramebufferPixelsAsync(gfx::Rect rect,
-                                           bool flipped_y,
-                                           CopyRenderPassCallback callback) {
-  if (callback.is_null())
+void GLRenderer::GetFramebufferPixelsAsync(
+    gfx::Rect rect, bool flipped_y, scoped_ptr<CopyOutputRequest> request) {
+  DCHECK(!request->IsEmpty());
+  if (request->IsEmpty())
     return;
-  if (rect.IsEmpty()) {
-    callback.Run(scoped_ptr<SkBitmap>());
+  if (rect.IsEmpty())
     return;
-  }
 
   scoped_ptr<SkBitmap> bitmap(new SkBitmap);
   bitmap->setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
   bitmap->allocPixels();
 
   scoped_ptr<SkAutoLockPixels> lock(new SkAutoLockPixels(*bitmap));
 
   // Save a pointer to the pixels, the bitmap is owned by the cleanup_callback.
   uint8* pixels = static_cast<uint8*>(bitmap->getPixels());
 
   AsyncGetFramebufferPixelsCleanupCallback cleanup_callback = base::Bind(
       &GLRenderer::PassOnSkBitmap,
       base::Unretained(this),
       base::Passed(&bitmap),
-      base::Passed(&lock),
-      callback);
+      base::Passed(&lock));
 
   scoped_ptr<PendingAsyncReadPixels> pending_read(new PendingAsyncReadPixels);
-  pending_read->copy_callback = callback;
+  pending_read->copy_request = request.Pass();
   pending_async_read_pixels_.insert(pending_async_read_pixels_.begin(),
                                     pending_read.Pass());
 
   // This is an asyncronous call since the callback is not null.
   DoGetFramebufferPixels(pixels, rect, flipped_y, cleanup_callback);
 }
 
 void GLRenderer::DoGetFramebufferPixels(
     uint8* dest_pixels,
     gfx::Rect rect,
@@ skipping 114 matching lines @@
   EnforceMemoryPolicy();
 }
 
 void GLRenderer::FinishedReadback(
     const AsyncGetFramebufferPixelsCleanupCallback& cleanup_callback,
     unsigned source_buffer,
     uint8* dest_pixels,
     gfx::Size size,
     bool flipped_y) {
   DCHECK(!pending_async_read_pixels_.empty());
-  DCHECK_EQ(source_buffer, pending_async_read_pixels_.back()->buffer);
+
+  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*>(
         context_->mapBufferCHROMIUM(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                                     GL_READ_ONLY));
 
@@ skipping 18 matching lines @@
           GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM));
     }
     GLC(context_, context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                                        0));
     GLC(context_, context_->deleteBuffer(source_buffer));
   }
 
   // TODO(danakj): This can go away when synchronous readback is no more and its
   // contents can just move here.
   if (!cleanup_callback.is_null())
-    cleanup_callback.Run(src_pixels != NULL);
+    cleanup_callback.Run(current_read->copy_request.Pass(), src_pixels != NULL);
 
   pending_async_read_pixels_.pop_back();
 }
 
 void GLRenderer::PassOnSkBitmap(
     scoped_ptr<SkBitmap> bitmap,
     scoped_ptr<SkAutoLockPixels> lock,
-    const CopyRenderPassCallback& callback,
+    scoped_ptr<CopyOutputRequest> request,
     bool success) {
-  DCHECK(callback.Equals(pending_async_read_pixels_.back()->copy_callback));
+  DCHECK(request->HasBitmapRequest());
 
   lock.reset();
   if (success)
-    callback.Run(bitmap.Pass());
-  else
-    callback.Run(scoped_ptr<SkBitmap>());
+    request->SendBitmapResult(bitmap.Pass());
 }
 
 bool GLRenderer::GetFramebufferTexture(ScopedResource* texture,
                                        gfx::Rect device_rect) {
   DCHECK(!texture->id() || (texture->size() == device_rect.size() &&
                             texture->format() == GL_RGB));
 
   if (!texture->id() && !texture->Allocate(device_rect.size(),
                                            GL_RGB,
                                            ResourceProvider::TextureUsageAny))
@@ skipping 586 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