cc: Add CopyAsBitmapRequest class to hold the readback callback.

cc/layers/layer.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/layers/layer.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/thread.h"
 #include "cc/layers/layer_impl.h"
+#include "cc/output/copy_output_request.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebAnimationDelegate.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebLayerScrollClient.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
 static int s_next_layer_id = 1;
@@ skipping 35 matching lines @@
 
   layer_animation_controller_ = LayerAnimationController::Create(layer_id_);
   layer_animation_controller_->AddValueObserver(this);
 }
 
 Layer::~Layer() {
   // Our parent should be holding a reference to us so there should be no
   // way for us to be destroyed while we still have a parent.
   DCHECK(!parent());
 
-  for (size_t i = 0; i < request_copy_callbacks_.size(); ++i)
-    request_copy_callbacks_[i].Run(scoped_ptr<SkBitmap>());
-
   layer_animation_controller_->RemoveValueObserver(this);
 
   // Remove the parent reference from all children and dependents.
   RemoveAllChildren();
   if (mask_layer_) {
     DCHECK_EQ(this, mask_layer_->parent());
     mask_layer_->RemoveFromParent();
   }
   if (replica_layer_) {
     DCHECK_EQ(this, replica_layer_->parent());
@@ skipping 221 matching lines @@
 void Layer::SetChildren(const LayerList& children) {
   DCHECK(IsPropertyChangeAllowed());
   if (children == children_)
     return;
 
   RemoveAllChildren();
   for (size_t i = 0; i < children.size(); ++i)
     AddChild(children[i]);
 }
 
-void Layer::RequestCopyAsBitmap(RequestCopyAsBitmapCallback callback) {
+void Layer::RequestCopyOfOutput(
+    scoped_ptr<CopyOutputRequest> request) {
   DCHECK(IsPropertyChangeAllowed());
-  if (callback.is_null())
+  if (request->IsEmpty())
     return;
-  request_copy_callbacks_.push_back(callback);
+  copy_requests_.push_back(request.Pass());
   SetNeedsCommit();
 }
 
 void Layer::SetAnchorPoint(gfx::PointF anchor_point) {
   DCHECK(IsPropertyChangeAllowed());
   if (anchor_point_ == anchor_point)
     return;
   anchor_point_ = anchor_point;
   SetNeedsCommit();
 }
@@ skipping 286 matching lines @@
 }
 
 void Layer::SetPositionConstraint(const LayerPositionConstraint& constraint) {
   DCHECK(IsPropertyChangeAllowed());
   if (position_constraint_ == constraint)
     return;
   position_constraint_ = constraint;
   SetNeedsCommit();
 }
 
-static void RunCopyCallbackOnMainThread(
-    const Layer::RequestCopyAsBitmapCallback& callback,
-    scoped_ptr<SkBitmap> bitmap) {
-  callback.Run(bitmap.Pass());
+static void RunCopyCallbackOnMainThread(scoped_ptr<CopyOutputRequest> request,
+                                        scoped_ptr<SkBitmap> bitmap) {
+  if (request->HasBitmapRequest())
+    request->SendBitmapResult(bitmap.Pass());
 }
 
-static void PostCopyCallbackToMainThread(
-    Thread* main_thread,
-    const Layer::RequestCopyAsBitmapCallback& callback,
-    scoped_ptr<SkBitmap> bitmap) {
+static void PostCopyCallbackToMainThread(Thread* main_thread,
+                                         scoped_ptr<CopyOutputRequest> request,
+                                         scoped_ptr<SkBitmap> bitmap) {
   main_thread->PostTask(base::Bind(&RunCopyCallbackOnMainThread,
-                                   callback,
+                                   base::Passed(&request),
                                    base::Passed(&bitmap)));
 }
 
 void Layer::PushPropertiesTo(LayerImpl* layer) {
   layer->SetAnchorPoint(anchor_point_);
   layer->SetAnchorPointZ(anchor_point_z_);
   layer->SetBackgroundColor(background_color_);
   layer->SetBounds(paint_properties_.bounds);
   layer->SetContentBounds(content_bounds());
   layer->SetContentsScale(contents_scale_x(), contents_scale_y());
@@ skipping 24 matching lines @@
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   layer->SetSublayerTransform(sublayer_transform_);
   if (!layer->TransformIsAnimatingOnImplOnly() && !TransformIsAnimating())
     layer->SetTransform(transform_);
   DCHECK(!(TransformIsAnimating() && layer->TransformIsAnimatingOnImplOnly()));
 
   layer->SetScrollable(scrollable_);
   layer->SetScrollOffset(scroll_offset_);
   layer->SetMaxScrollOffset(max_scroll_offset_);
 
-  // Wrap the request_copy_callbacks_ in a PostTask to the main thread.
-  std::vector<RequestCopyAsBitmapCallback> main_thread_request_copy_callbacks;
-  for (size_t i = 0; i < request_copy_callbacks_.size(); ++i) {
-    main_thread_request_copy_callbacks.push_back(
-        base::Bind(&PostCopyCallbackToMainThread,
-                   layer_tree_host()->proxy()->MainThread(),
-                   request_copy_callbacks_[i]));
+  // Wrap the copy_requests_ in a PostTask to the main thread.
+  ScopedPtrVector<CopyOutputRequest> main_thread_copy_requests;
+  for (ScopedPtrVector<CopyOutputRequest>::iterator it = copy_requests_.begin();
+       it != copy_requests_.end();
+       ++it) {
+    scoped_ptr<CopyOutputRequest> original_request = copy_requests_.take(it);
+    scoped_ptr<CopyOutputRequest> main_thread_request =
+        CopyOutputRequest::CreateBitmapRequest(base::Bind(
+            &PostCopyCallbackToMainThread,
+            layer_tree_host()->proxy()->MainThread(),
+            base::Passed(&original_request)));
+    main_thread_copy_requests.push_back(main_thread_request.Pass());
   }
-  request_copy_callbacks_.clear();
-  layer->PassRequestCopyCallbacks(&main_thread_request_copy_callbacks);
+  copy_requests_.clear();
+  layer->PassCopyRequests(&main_thread_copy_requests);
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->set_update_rect(update_rect_);
 
   if (layer->layer_tree_impl()->settings().impl_side_painting) {
     DCHECK(layer->layer_tree_impl()->IsPendingTree());
@@ skipping 142 matching lines @@
 
 ScrollbarLayer* Layer::ToScrollbarLayer() {
   return NULL;
 }
 
 RenderingStatsInstrumentation* Layer::rendering_stats_instrumentation() const {
   return layer_tree_host_->rendering_stats_instrumentation();
 }
 
 }  // namespace cc