cc: Async readback.

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/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/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
@@ skipping 39 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 212 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) {
+  DCHECK(IsPropertyChangeAllowed());
+  if (callback.is_null())
+    return;
+  request_copy_callbacks_.push_back(callback);
+  SetNeedsCommit();
+}
+
 void Layer::SetAnchorPoint(gfx::PointF anchor_point) {
   DCHECK(IsPropertyChangeAllowed());
   if (anchor_point_ == anchor_point)
     return;
   anchor_point_ = anchor_point;
   SetNeedsCommit();
 }
 
 void Layer::SetAnchorPointZ(float anchor_point_z) {
   DCHECK(IsPropertyChangeAllowed());
@@ skipping 289 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 PostCopyCallbackToMainThread(
+    Thread* main_thread,
+    const Layer::RequestCopyAsBitmapCallback& callback,
+    scoped_ptr<SkBitmap> bitmap) {
+  main_thread->PostTask(base::Bind(&RunCopyCallbackOnMainThread,
+                                   callback,
+                                   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());
   layer->SetDebugName(debug_name_);
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawCheckerboardForMissingTiles(
@@ skipping 21 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]));
+  }
+  request_copy_callbacks_.clear();
+  layer->PassRequestCopyCallbacks(&main_thread_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_);
 
   if (layer->layer_tree_impl()->settings().impl_side_painting) {
     DCHECK(layer->layer_tree_impl()->IsPendingTree());
     LayerImpl* active_twin =
@@ skipping 183 matching lines @@
 
 ScrollbarLayer* Layer::ToScrollbarLayer() {
   return NULL;
 }
 
 RenderingStatsInstrumentation* Layer::rendering_stats_instrumentation() const {
   return layer_tree_host_->rendering_stats_instrumentation();
 }
 
 }  // namespace cc