Add WebGraphicsContext support for readbacks from any framebuffer.

content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.cc

 // Copyright (c) 2011 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.
 
 #if defined(ENABLE_GPU)
 
 #include "content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.h"
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
@@ skipping 235 matching lines @@
     // creation attributes.
     memcpy(scanline, row_b, row_bytes);
     memcpy(row_b, row_a, row_bytes);
     memcpy(row_a, scanline, row_bytes);
   }
 }
 #endif
 
 bool WebGraphicsContext3DCommandBufferImpl::readBackFramebuffer(
     unsigned char* pixels,
-    size_t buffer_size) {
-  if (buffer_size != static_cast<size_t>(4 * width() * height())) {
+    int width,
+    int height,
+    size_t buffer_size,
+    WebGLId buffer) {
+  if (buffer_size != static_cast<size_t>(4 * width * height)) {
     return false;
   }
 
   // Earlier versions of this code used the GPU to flip the
   // framebuffer vertically before reading it back for compositing
   // via software. This code was quite complicated, used a lot of
   // GPU memory, and didn't provide an obvious speedup. Since this
   // vertical flip is only a temporary solution anyway until Chrome
   // is fully GPU composited, it wasn't worth the complexity.
 
-  bool mustRestoreFBO = (bound_fbo_ != 0);
+  bool mustRestoreFBO = (bound_fbo_ != buffer);
   if (mustRestoreFBO) {
-    gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
+    gl_->BindFramebuffer(GL_FRAMEBUFFER, buffer);
   }

[Ken Russell (switch to Gerrit), 2011/08/04 22:55:07]

Do you think we might want or need checks about the completeness of the FBO
given that it's now coming from outside code?

[jbauman, 2011/08/04 23:20:21]

Those can be expensive, so I'd rather avoid them (even if they aren't as
expensive as the actual readpixels). I'll let the calling code take care of
that, so they'll be done less often.

-   gl_->ReadPixels(0, 0, cached_width_, cached_height_,
+   gl_->ReadPixels(0, 0, width, height,
                    GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
   // Swizzle red and blue channels
   // TODO(kbr): expose GL_BGRA as extension
   for (size_t i = 0; i < buffer_size; i += 4) {
     std::swap(pixels[i], pixels[i + 2]);
   }
 
   if (mustRestoreFBO) {
     gl_->BindFramebuffer(GL_FRAMEBUFFER, bound_fbo_);
   }
 
 #ifdef FLIP_FRAMEBUFFER_VERTICALLY
   if (pixels) {
-    FlipVertically(pixels, cached_width_, cached_height_);
+    FlipVertically(pixels, width, height);
   }
 #endif
 
   return true;
 }
 
+bool WebGraphicsContext3DCommandBufferImpl::readBackFramebuffer(
+    unsigned char* pixels,
+    size_t buffer_size) {
+  return readBackFramebuffer(pixels, width(), height(), buffer_size, 0);
+}
+
 void WebGraphicsContext3DCommandBufferImpl::synthesizeGLError(
     WGC3Denum error) {
   if (find(synthetic_errors_.begin(), synthetic_errors_.end(), error) ==
       synthetic_errors_.end()) {
     synthetic_errors_.push_back(error);
   }
 }
 
 void* WebGraphicsContext3DCommandBufferImpl::mapBufferSubDataCHROMIUM(
     WGC3Denum target,
@@ skipping 724 matching lines @@
     context_lost_callback_->onContextLost();
   }
 
   RenderView* renderview =
       web_view_ ? RenderView::FromWebView(web_view_) : NULL;
   if (renderview)
     renderview->OnViewContextSwapBuffersAborted();
 }
 
 #endif  // defined(ENABLE_GPU)