cc: Move copy requests from layers to the effect tree

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1189 matching lines @@
 
   // When a scroll offset animation is interrupted the new scroll position on
   // the pending tree will clobber any impl-side scrolling occuring on the
   // active tree. To do so, avoid scrolling the pending tree along with it
   // instead of trying to undo that scrolling later.
   if (ScrollOffsetAnimationWasInterrupted())
     layer_tree_host()
         ->property_trees()
         ->scroll_tree.SetScrollOffsetClobberActiveValue(layer->id());
 
-  {
-    TRACE_EVENT0("cc", "Layer::PushPropertiesTo::CopyOutputRequests");
-    // Wrap the copy_requests_ in a PostTask to the main thread.
-    std::vector<std::unique_ptr<CopyOutputRequest>> main_thread_copy_requests;
-    for (auto it = copy_requests_.begin(); it != copy_requests_.end(); ++it) {
-      scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
-          layer_tree_host()->task_runner_provider()->MainThreadTaskRunner();
-      std::unique_ptr<CopyOutputRequest> original_request = std::move(*it);
-      const CopyOutputRequest& original_request_ref = *original_request;
-      std::unique_ptr<CopyOutputRequest> main_thread_request =
-          CopyOutputRequest::CreateRelayRequest(
-              original_request_ref,
-              base::Bind(&PostCopyCallbackToMainThread, main_thread_task_runner,
-                         base::Passed(&original_request)));
-      main_thread_copy_requests.push_back(std::move(main_thread_request));
-    }
-    if (!copy_requests_.empty() && layer_tree_host_)
-      layer_tree_host_->property_trees()->needs_rebuild = true;
-
-    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->SetUpdateRect(update_rect_);
 
   layer->SetHasWillChangeTransformHint(has_will_change_transform_hint());
 
   // Reset any state that should be cleared for the next update.
   subtree_property_changed_ = false;
   update_rect_ = gfx::Rect();
 
   layer_tree_host()->RemoveLayerShouldPushProperties(this);
 }
 
+void Layer::TakeCopyRequests(
+    std::vector<std::unique_ptr<CopyOutputRequest>>* requests) {
+  for (auto& it : copy_requests_) {
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
+        layer_tree_host()->task_runner_provider()->MainThreadTaskRunner();
+    std::unique_ptr<CopyOutputRequest> original_request = std::move(it);
+    const CopyOutputRequest& original_request_ref = *original_request;
+    std::unique_ptr<CopyOutputRequest> main_thread_request =
+        CopyOutputRequest::CreateRelayRequest(
+            original_request_ref,
+            base::Bind(&PostCopyCallbackToMainThread, main_thread_task_runner,
+                       base::Passed(&original_request)));
+    if (main_thread_request->has_area()) {
+      main_thread_request->set_area(gfx::IntersectRects(
+          main_thread_request->area(), gfx::Rect(bounds())));
+    }
+    requests->push_back(std::move(main_thread_request));
+  }
+
+  copy_requests_.clear();
+}
+
 void Layer::SetTypeForProtoSerialization(proto::LayerNode* proto) const {
   proto->set_type(proto::LayerNode::LAYER);
 }
 
 void Layer::ToLayerNodeProto(proto::LayerNode* proto) const {
   proto->set_id(layer_id_);
   SetTypeForProtoSerialization(proto);
 
   if (parent_)
     proto->set_parent_id(parent_->id());
@@ skipping 571 matching lines @@
       ->data.num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc