cc: Add CopyAsBitmapRequest class to hold the readback callback.

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 "cc/animation/animation_registrar.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/animation/scrollbar_animation_controller_linear_fade.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/debug/layer_tree_debug_state.h"
 #include "cc/debug/traced_value.h"
 #include "cc/input/layer_scroll_offset_delegate.h"
 #include "cc/layers/quad_sink.h"
 #include "cc/layers/scrollbar_layer_impl.h"
+#include "cc/output/copy_output_request.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "cc/trees/proxy.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
@@ skipping 36 matching lines @@
   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())
+void LayerImpl::PassCopyRequests(ScopedPtrVector<CopyOutputRequest>* requests) {
+  if (requests->empty())
     return;
 
-  request_copy_callbacks_.insert(request_copy_callbacks_.end(),
-                                 callbacks->begin(),
-                                 callbacks->end());
-  callbacks->clear();
+  copy_requests_.insert_and_take(copy_requests_.end(), *requests);
+  requests->clear();
 
   NoteLayerPropertyChangedForSubtree();
 }
 
-void LayerImpl::TakeRequestCopyCallbacks(
-    std::vector<RenderPass::RequestCopyAsBitmapCallback>* callbacks) {
-  if (request_copy_callbacks_.empty())
+void LayerImpl::TakeCopyRequests(ScopedPtrVector<CopyOutputRequest>* requests) {
+  if (copy_requests_.empty())
     return;
 
-  callbacks->insert(callbacks->end(),
-                    request_copy_callbacks_.begin(),
-                    request_copy_callbacks_.end());
-  request_copy_callbacks_.clear();
+  requests->insert_and_take(requests->end(), copy_requests_);
+  copy_requests_.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() {
@@ skipping 239 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_);
+  layer->PassCopyRequests(&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_);
 
   layer->SetScrollDelta(layer->ScrollDelta() - layer->sent_scroll_delta());
   layer->SetSentScrollDelta(gfx::Vector2d());
@@ skipping 633 matching lines @@
 
 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
 
 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