cc: Async readback.

cc/layers/layer_impl.cc

 // Copyright 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.
 
 #include "cc/layers/layer_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "cc/animation/animation_registrar.h"
@@ skipping 51 matching lines @@
   AnimationRegistrar* registrar = layer_tree_impl_->animationRegistrar();
   layer_animation_controller_ =
       registrar->GetAnimationControllerForId(layer_id_);
   layer_animation_controller_->AddValueObserver(this);
 }
 
 LayerImpl::~LayerImpl() {
 #ifndef NDEBUG
   DCHECK(!between_will_draw_and_did_draw_);
 #endif
+
+  for (size_t i = 0; i < request_copy_callbacks_.size(); ++i)
+    request_copy_callbacks_[i].Run(scoped_ptr<SkBitmap>());
+
   layer_tree_impl_->UnregisterLayer(this);
   layer_animation_controller_->RemoveValueObserver(this);
 }
 
 void LayerImpl::AddChild(scoped_ptr<LayerImpl> child) {
   child->set_parent(this);
   DCHECK_EQ(layer_tree_impl(), child->layer_tree_impl());
   children_.push_back(child.Pass());
   layer_tree_impl()->set_needs_update_draw_properties();
 }
@@ skipping 13 matching lines @@
 }
 
 void LayerImpl::ClearChildList() {
   if (children_.empty())
     return;
 
   children_.clear();
   layer_tree_impl()->set_needs_update_draw_properties();
 }
 
+void LayerImpl::PassRequestCopyCallbacks(
+    std::vector<RenderPass::RequestCopyAsBitmapCallback>* callbacks) {
+  if (callbacks->empty())
+    return;
+
+  request_copy_callbacks_.insert(request_copy_callbacks_.end(),
+                                 callbacks->begin(),
+                                 callbacks->end());
+  callbacks->clear();
+
+  NoteLayerPropertyChangedForSubtree();
+}
+
+void LayerImpl::TakeRequestCopyCallbacks(
+    std::vector<RenderPass::RequestCopyAsBitmapCallback>* callbacks) {
+  if (request_copy_callbacks_.empty())
+    return;
+
+  callbacks->insert(callbacks->end(),
+                    request_copy_callbacks_.begin(),
+                    request_copy_callbacks_.end());
+  request_copy_callbacks_.clear();
+}
+
 void LayerImpl::CreateRenderSurface() {
   DCHECK(!draw_properties_.render_surface);
   draw_properties_.render_surface =
       make_scoped_ptr(new RenderSurfaceImpl(this));
   draw_properties_.render_target = this;
 }
 
 void LayerImpl::ClearRenderSurface() {
   draw_properties_.render_surface.reset();
 }
@@ skipping 229 matching lines @@
   layer->SetPositionConstraint(position_constraint_);
   layer->SetPreserves3d(preserves_3d());
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   layer->SetSublayerTransform(sublayer_transform_);
   layer->SetTransform(transform_);
 
   layer->SetScrollable(scrollable_);
   layer->SetScrollOffset(scroll_offset_);
   layer->SetMaxScrollOffset(max_scroll_offset_);
 
+  layer->PassRequestCopyCallbacks(&request_copy_callbacks_);
+
   // 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_);
 
   layer->SetScrollDelta(layer->scroll_delta() - layer->sent_scroll_delta());
   layer->SetSentScrollDelta(gfx::Vector2d());
 
@@ skipping 599 matching lines @@
   dict->Set("layer_quad", MathUtil::AsValue(layer_quad).release());
 }
 
 scoped_ptr<base::Value> LayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   AsValueInto(state.get());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc