cc: Fix readback from non-root layers.

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 1789 matching lines @@
     return;
 
   FlushTextureQuadCache();
   GLC(context_, context_->disable(GL_SCISSOR_TEST));
   is_scissor_enabled_ = false;
 }
 
 void GLRenderer::CopyCurrentRenderPassToBitmap(
     DrawingFrame* frame,
     const CopyRenderPassCallback& callback) {
-  GetFramebufferPixelsAsync(frame->current_render_pass->output_rect, callback);
+  GetFramebufferPixelsAsync(frame->current_render_pass->output_rect,
+                            frame->flipped_y,
+                            callback);
 }
 
 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 183 matching lines @@
     return;
 
   output_surface_->EnsureBackbuffer();
   is_backbuffer_discarded_ = false;
 }
 
 void GLRenderer::GetFramebufferPixels(void* pixels, gfx::Rect rect) {
   if (!pixels || rect.IsEmpty())
     return;
 
+  // This function assumes that it is reading the root frame buffer.
+  DCHECK(!current_framebuffer_lock_);
+  bool flipped_y = FlippedFramebuffer();

[piman, 2013/05/07 22:35:02]

nit: this is always true

[danakj, 2013/05/07 22:36:19]

That is true, but I prefer the context so you can see how this relates to
InitializeMatrices?

[piman, 2013/05/07 22:42:35]

I guess it's not trivial because InitializeMatrices gets called from
DirectRenderer, and it's hard to follow from here... Whatever you want.

+
   scoped_ptr<PendingAsyncReadPixels> pending_read(new PendingAsyncReadPixels);
   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())
     return;
   if (rect.IsEmpty()) {
     callback.Run(scoped_ptr<SkBitmap>());
     return;
   }
 
   scoped_ptr<SkBitmap> bitmap(new SkBitmap);
   bitmap->setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
@@ skipping 10 matching lines @@
       base::Passed(&bitmap),
       base::Passed(&lock),
       callback);
 
   scoped_ptr<PendingAsyncReadPixels> pending_read(new PendingAsyncReadPixels);
   pending_read->copy_callback = callback;
   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, cleanup_callback);
+  DoGetFramebufferPixels(pixels, rect, flipped_y, cleanup_callback);
 }
 
 void GLRenderer::DoGetFramebufferPixels(
     uint8* dest_pixels,
     gfx::Rect rect,
+    bool flipped_y,
     const AsyncGetFramebufferPixelsCleanupCallback& cleanup_callback) {
   DCHECK(rect.right() <= ViewportWidth());
   DCHECK(rect.bottom() <= ViewportHeight());
 
   bool is_async = !cleanup_callback.is_null();
 
   MakeContextCurrent();
 
   bool do_workaround = NeedsIOSurfaceReadbackWorkaround();
 
@@ skipping 22 matching lines @@
         context_->texParameteri(
             GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
     // Copy the contents of the current (IOSurface-backed) framebuffer into a
     // temporary texture.
     GLC(context_,
         context_->copyTexImage2D(GL_TEXTURE_2D,
                                  0,
                                  GL_RGBA,
                                  0,
                                  0,
-                                 ViewportSize().width(),
-                                 ViewportSize().height(),
+                                 current_framebuffer_size_.width(),
+                                 current_framebuffer_size_.height(),
                                  0));
     temporary_fbo = context_->createFramebuffer();
     // Attach this texture to an FBO, and perform the readback from that FBO.
     GLC(context_, context_->bindFramebuffer(GL_FRAMEBUFFER, temporary_fbo));
     GLC(context_,
         context_->framebufferTexture2D(GL_FRAMEBUFFER,
                                        GL_COLOR_ATTACHMENT0,
                                        GL_TEXTURE_2D,
                                        temporary_texture,
                                        0));
 
     DCHECK(context_->checkFramebufferStatus(GL_FRAMEBUFFER) ==
            GL_FRAMEBUFFER_COMPLETE);
   }
 
   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 * rect.size().GetArea(),
                                      NULL,
                                      GL_STREAM_READ));
 
   GLC(context_,
       context_->readPixels(rect.x(),
-                           ViewportSize().height() - rect.bottom(),
+                           current_framebuffer_size_.height() - rect.bottom(),
                            rect.width(),
                            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,
                  dest_pixels,
-                 rect.size());
+                 rect.size(),
+                 flipped_y);
   // 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(
         context_,
         sync_point,
         finished_callback);
   } else {
     resource_provider_->Finish();
     finished_callback.Run();
   }
 
   EnforceMemoryPolicy();
 }
 
 void GLRenderer::FinishedReadback(
     const AsyncGetFramebufferPixelsCleanupCallback& cleanup_callback,
     unsigned source_buffer,
     uint8* dest_pixels,
-    gfx::Size size) {
+    gfx::Size size,
+    bool flipped_y) {
   DCHECK(!pending_async_read_pixels_.empty());
   DCHECK_EQ(source_buffer, pending_async_read_pixels_.back()->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));
 
     if (src_pixels) {
       size_t row_bytes = size.width() * 4;
       int num_rows = size.height();
       size_t total_bytes = num_rows * row_bytes;
       for (size_t dest_y = 0; dest_y < total_bytes; dest_y += row_bytes) {
         // Flip Y axis.
-        size_t src_y = total_bytes - dest_y - row_bytes;
+        size_t src_y = flipped_y ? total_bytes - dest_y - row_bytes
+                                 : dest_y;
         // Swizzle BGRA -> RGBA.
         for (size_t x = 0; x < row_bytes; x += 4) {
           dest_pixels[dest_y + (x + 0)] = src_pixels[src_y + (x + 2)];
           dest_pixels[dest_y + (x + 1)] = src_pixels[src_y + (x + 1)];
           dest_pixels[dest_y + (x + 2)] = src_pixels[src_y + (x + 0)];
           dest_pixels[dest_y + (x + 3)] = src_pixels[src_y + (x + 3)];
         }
       }
 
       GLC(context_, context_->unmapBufferCHROMIUM(
@@ skipping 56 matching lines @@
   DCHECK(texture->id());
   frame->current_render_pass = NULL;
   frame->current_texture = texture;
 
   return BindFramebufferToTexture(frame, texture, viewport_rect);
 }
 
 void GLRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
   current_framebuffer_lock_.reset();
   output_surface_->BindFramebuffer();
+  SetDrawViewportSize(ViewportSize());

[piman, 2013/05/07 22:35:02]

This should already be done by DirectRenderer::UseRenderPass which is the only
caller of BindFramebufferToOutputSurface AFAICT

[danakj, 2013/05/07 22:36:19]

oh right, i was wondering where it was.

 }
 
 bool GLRenderer::BindFramebufferToTexture(DrawingFrame* frame,
                                           const ScopedResource* texture,
                                           gfx::Rect framebuffer_rect) {
   DCHECK(texture->id());
 
   GLC(context_,
       context_->bindFramebuffer(GL_FRAMEBUFFER, offscreen_framebuffer_id_));
   current_framebuffer_lock_ =
@@ skipping 24 matching lines @@
   scissor_rect_ = scissor_rect;
   FlushTextureQuadCache();
   GLC(context_,
       context_->scissor(scissor_rect.x(),
                         scissor_rect.y(),
                         scissor_rect.width(),
                         scissor_rect.height()));
 }
 
 void GLRenderer::SetDrawViewportSize(gfx::Size viewport_size) {
+  current_framebuffer_size_ = viewport_size;
   GLC(context_,
       context_->viewport(0, 0, viewport_size.width(), viewport_size.height()));
 }
 
 bool GLRenderer::MakeContextCurrent() { return context_->makeContextCurrent(); }
 
 bool GLRenderer::InitializeSharedObjects() {
   TRACE_EVENT0("cc", "GLRenderer::InitializeSharedObjects");
   MakeContextCurrent();
 
@@ skipping 455 matching lines @@
     resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
 
   ReleaseRenderPassTextures();
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc