Remove CompositeAndReadback from LayerTreeHost(Impl) and the Proxys.

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 1940 matching lines @@
 
   // Bind the correct texture sampler location.
   GLC(gl_, gl_->Uniform1i(draw_cache_.sampler_location, 0));
 
   // Assume the current active textures is 0.
   ResourceProvider::ScopedReadLockGL locked_quad(resource_provider_,
                                                  draw_cache_.resource_id);
   DCHECK_EQ(GL_TEXTURE0, ResourceProvider::GetActiveTextureUnit(gl_));
   GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, locked_quad.texture_id()));
 
-  COMPILE_ASSERT(sizeof(Float4) == 4 * sizeof(float),  // NOLINT(runtime/sizeof)

[brianderson, 2014/05/10 00:47:53]

Unrelated changes?

[danakj, 2014/05/10 15:30:55]

Yeh.. The linter complained that size of wasn't a valid linter exception
anymore. 

+  COMPILE_ASSERT(sizeof(Float4) == 4 * sizeof(float), struct_is_densely_packed);
+  COMPILE_ASSERT(sizeof(Float16) == 16 * sizeof(float),
                  struct_is_densely_packed);
-  COMPILE_ASSERT(
-      sizeof(Float16) == 16 * sizeof(float),  // NOLINT(runtime/sizeof)
-      struct_is_densely_packed);
 
   // Upload the tranforms for both points and uvs.
   GLC(gl_,
       gl_->UniformMatrix4fv(
           static_cast<int>(draw_cache_.matrix_location),
           static_cast<int>(draw_cache_.matrix_data.size()),
           false,
           reinterpret_cast<float*>(&draw_cache_.matrix_data.front())));
   GLC(gl_,
       gl_->Uniform4fv(
@@ skipping 356 matching lines @@
 }
 
 void GLRenderer::EnsureBackbuffer() {
   if (!is_backbuffer_discarded_)
     return;
 
   output_surface_->EnsureBackbuffer();
   is_backbuffer_discarded_ = false;
 }
 
-void GLRenderer::GetFramebufferPixels(void* pixels, const gfx::Rect& rect) {
-  if (!pixels || rect.IsEmpty())
-    return;
-
-  // This function assumes that it is reading the root frame buffer.
-  DCHECK(!current_framebuffer_lock_);
-
-  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.
-  gfx::Rect window_rect = MoveFromDrawToWindowSpace(rect);
-  DoGetFramebufferPixels(static_cast<uint8*>(pixels),
-                         window_rect,
-                         AsyncGetFramebufferPixelsCleanupCallback());
-}
-
 void GLRenderer::GetFramebufferPixelsAsync(
     const gfx::Rect& rect,
     scoped_ptr<CopyOutputRequest> request) {
   DCHECK(!request->IsEmpty());
   if (request->IsEmpty())
     return;
   if (rect.IsEmpty())
     return;
 
   gfx::Rect window_rect = MoveFromDrawToWindowSpace(rect);
+  DCHECK_GE(window_rect.x(), 0);
+  DCHECK_GE(window_rect.y(), 0);
+  DCHECK_LE(window_rect.right(), current_surface_size_.width());
+  DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
 
   if (!request->force_bitmap_result()) {
     bool own_mailbox = !request->has_texture_mailbox();
 
     GLuint texture_id = 0;
     gl_->GenTextures(1, &texture_id);
 
     gpu::Mailbox mailbox;
     if (own_mailbox) {
       GLC(gl_, gl_->GenMailboxCHROMIUM(mailbox.name));
@@ skipping 37 matching lines @@
       gl_->DeleteTextures(1, &texture_id);
     }
 
     request->SendTextureResult(
         window_rect.size(), texture_mailbox, release_callback.Pass());
     return;
   }
 
   DCHECK(request->force_bitmap_result());
 
-  scoped_ptr<SkBitmap> bitmap(new SkBitmap);
-  bitmap->allocN32Pixels(window_rect.width(), window_rect.height());
-
-  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));
-
   scoped_ptr<PendingAsyncReadPixels> pending_read(new PendingAsyncReadPixels);
   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, window_rect, cleanup_callback);
-}
-
-void GLRenderer::DoGetFramebufferPixels(
-    uint8* dest_pixels,
-    const gfx::Rect& window_rect,
-    const AsyncGetFramebufferPixelsCleanupCallback& cleanup_callback) {
-  DCHECK_GE(window_rect.x(), 0);
-  DCHECK_GE(window_rect.y(), 0);
-  DCHECK_LE(window_rect.right(), current_surface_size_.width());
-  DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
-
-  bool is_async = !cleanup_callback.is_null();
-
   bool do_workaround = NeedsIOSurfaceReadbackWorkaround();
 
   unsigned temporary_texture = 0;
   unsigned temporary_fbo = 0;
 
   if (do_workaround) {
     // On Mac OS X, calling glReadPixels() against an FBO whose color attachment
     // is an IOSurface-backed texture causes corruption of future glReadPixels()
     // calls, even those on different OpenGL contexts. It is believed that this
     // is the root cause of top crasher
@@ skipping 30 matching lines @@
   GLuint buffer = 0;
   gl_->GenBuffers(1, &buffer);
   GLC(gl_, gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, buffer));
   GLC(gl_,
       gl_->BufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                       4 * window_rect.size().GetArea(),
                       NULL,
                       GL_STREAM_READ));
 
   GLuint query = 0;
-  if (is_async) {
-    gl_->GenQueriesEXT(1, &query);
-    GLC(gl_, gl_->BeginQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, query));
-  }
+  gl_->GenQueriesEXT(1, &query);
+  GLC(gl_, gl_->BeginQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, query));
 
   GLC(gl_,
       gl_->ReadPixels(window_rect.x(),
                       window_rect.y(),
                       window_rect.width(),
                       window_rect.height(),
                       GL_RGBA,
                       GL_UNSIGNED_BYTE,
                       NULL));
 
   GLC(gl_, gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0));
 
   if (do_workaround) {
     // Clean up.
     GLC(gl_, gl_->BindFramebuffer(GL_FRAMEBUFFER, 0));
     GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, 0));
     GLC(gl_, gl_->DeleteFramebuffers(1, &temporary_fbo));
     GLC(gl_, gl_->DeleteTextures(1, &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);
   base::Closure cancelable_callback =
       pending_async_read_pixels_.front()->
           finished_read_pixels_callback.callback();
 
   // Save the buffer to verify the callbacks happen in the expected order.
   pending_async_read_pixels_.front()->buffer = buffer;
 
-  if (is_async) {
-    GLC(gl_, gl_->EndQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM));
-    context_support_->SignalQuery(query, cancelable_callback);
-  } else {
-    resource_provider_->Finish();
-    finished_callback.Run();
-  }
+  GLC(gl_, gl_->EndQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM));
+  context_support_->SignalQuery(query, cancelable_callback);
 
   EnforceMemoryPolicy();
 }
 
-void GLRenderer::FinishedReadback(
-    const AsyncGetFramebufferPixelsCleanupCallback& cleanup_callback,
-    unsigned source_buffer,
-    unsigned query,
-    uint8* dest_pixels,
-    const gfx::Size& size) {
+void GLRenderer::FinishedReadback(unsigned source_buffer,
+                                  unsigned query,
+                                  const gfx::Size& size) {
   DCHECK(!pending_async_read_pixels_.empty());
 
   if (query != 0) {
     GLC(gl_, gl_->DeleteQueriesEXT(1, &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;
+  scoped_ptr<SkBitmap> bitmap;
 
   if (source_buffer != 0) {
     GLC(gl_,
         gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, source_buffer));
     src_pixels = static_cast<uint8*>(gl_->MapBufferCHROMIUM(
         GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, GL_READ_ONLY));
 
     if (src_pixels) {
+      bitmap.reset(new SkBitmap);
+      bitmap->allocN32Pixels(size.width(), size.height());
+      scoped_ptr<SkAutoLockPixels> lock(new SkAutoLockPixels(*bitmap));
+      uint8* dest_pixels = static_cast<uint8*>(bitmap->getPixels());
+
       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;
         // Swizzle OpenGL -> Skia byte order.
         for (size_t x = 0; x < row_bytes; x += 4) {
           dest_pixels[dest_y + x + SK_R32_SHIFT / 8] =
               src_pixels[src_y + x + 0];
           dest_pixels[dest_y + x + SK_G32_SHIFT / 8] =
               src_pixels[src_y + x + 1];
           dest_pixels[dest_y + x + SK_B32_SHIFT / 8] =
               src_pixels[src_y + x + 2];
           dest_pixels[dest_y + x + SK_A32_SHIFT / 8] =
               src_pixels[src_y + x + 3];
         }
       }
 
       GLC(gl_,
           gl_->UnmapBufferCHROMIUM(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM));
     }
     GLC(gl_, gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0));
     GLC(gl_, gl_->DeleteBuffers(1, &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(current_read->copy_request.Pass(), src_pixels != NULL);
-
+  if (bitmap)
+    current_read->copy_request->SendBitmapResult(bitmap.Pass());
   pending_async_read_pixels_.pop_back();
 }
 
-void GLRenderer::PassOnSkBitmap(scoped_ptr<SkBitmap> bitmap,
-                                scoped_ptr<SkAutoLockPixels> lock,
-                                scoped_ptr<CopyOutputRequest> request,
-                                bool success) {
-  DCHECK(request->force_bitmap_result());
-
-  lock.reset();
-  if (success)
-    request->SendBitmapResult(bitmap.Pass());
-}
-
 void GLRenderer::GetFramebufferTexture(unsigned texture_id,
                                        ResourceFormat texture_format,
                                        const gfx::Rect& window_rect) {
   DCHECK(texture_id);
   DCHECK_GE(window_rect.x(), 0);
   DCHECK_GE(window_rect.y(), 0);
   DCHECK_LE(window_rect.right(), current_surface_size_.width());
   DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
 
   GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, texture_id));
@@ skipping 578 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc