cc: Move copy requests from layers to the effect tree

cc/trees/property_tree.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/math_util.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/input/scroll_state.h"
 #include "cc/layers/layer_impl.h"
+#include "cc/output/copy_output_request.h"
 #include "cc/proto/gfx_conversions.h"
 #include "cc/proto/property_tree.pb.h"
 #include "cc/proto/scroll_offset.pb.h"
 #include "cc/proto/synced_property_conversions.h"
 #include "cc/proto/transform.pb.h"
 #include "cc/proto/vector2df.pb.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
@@ skipping 1283 matching lines @@
   }
 
   DCHECK(nodes_affected_by_outer_viewport_bounds_delta_.empty());
   for (int i = 0; i < data.nodes_affected_by_outer_viewport_bounds_delta_size();
        ++i) {
     nodes_affected_by_outer_viewport_bounds_delta_.push_back(
         data.nodes_affected_by_outer_viewport_bounds_delta(i));
   }
 }
 
+EffectTree::EffectTree() {}
+
+EffectTree::~EffectTree() {}
+
 float EffectTree::EffectiveOpacity(const EffectNode* node) const {
   return node->data.subtree_hidden ? 0.f : node->data.opacity;
 }
 
 void EffectTree::UpdateOpacities(EffectNode* node, EffectNode* parent_node) {
   node->data.screen_space_opacity = EffectiveOpacity(node);
 
   if (parent_node)
     node->data.screen_space_opacity *= parent_node->data.screen_space_opacity;
 }
@@ skipping 69 matching lines @@
 void EffectTree::UpdateEffects(int id) {
   EffectNode* node = Node(id);
   EffectNode* parent_node = parent(node);
 
   UpdateOpacities(node, parent_node);
   UpdateIsDrawn(node, parent_node);
   UpdateEffectChanged(node, parent_node);
   UpdateBackfaceVisibility(node, parent_node);
 }
 
+void EffectTree::AddCopyRequest(int node_id,
+                                std::unique_ptr<CopyOutputRequest> request) {
+  copy_requests_.insert(std::make_pair(node_id, std::move(request)));
+}
+
+void EffectTree::PushCopyRequestsTo(EffectTree* other_tree) {
+  // If other_tree still has copy requests, this means there was a commit
+  // without a draw. This only happens in some edge cases during lost context or
+  // visibility changes, so don't try to handle preserving these output
+  // requests.
+  if (!other_tree->copy_requests_.empty()) {
+    // Destroying these copy requests will abort them.
+    other_tree->copy_requests_.clear();
+  }
+
+  if (copy_requests_.empty())
+    return;
+
+  for (auto& request : copy_requests_) {
+    other_tree->copy_requests_.insert(
+        std::make_pair(request.first, std::move(request.second)));
+  }
+  copy_requests_.clear();
+
+  // Property trees need to get rebuilt since effect nodes (and render surfaces)
+  // that were created only for the copy requests we just pushed are no longer
+  // needed.
+  if (property_trees()->is_main_thread)
+    property_trees()->needs_rebuild = true;
+}
+
+void EffectTree::TakeCopyRequestsAndTransformToSurface(
+    int node_id,
+    std::vector<std::unique_ptr<CopyOutputRequest>>* requests) {
+  EffectNode* effect_node = Node(node_id);
+  DCHECK(effect_node->data.has_render_surface);
+  DCHECK(effect_node->data.has_copy_request);
+
+  auto range = copy_requests_.equal_range(node_id);
+  for (auto it = range.first; it != range.second; ++it)
+    requests->push_back(std::move(it->second));
+  copy_requests_.erase(range.first, range.second);
+
+  for (auto& it : *requests) {
+    if (!it->has_area())
+      continue;
+
+    // The area needs to be transformed from the space of content that draws to
+    // the surface to the space of the surface itself.

[Ian Vollick, 2016/05/31 01:47:12]

The comments really help, but this is a bit subtle and I was surprised that the
logic was specific to copy requests. I went on a quick search for similar code
elsewhere, but didn't find anything obviously the same (the closest I found was
UpdateTargetSpaceTransform).

Is there a chance that this code could eventually be shared, or is the copy
request scaling unique?

[ajuma, 2016/05/31 14:27:08]

I've updated this to call ComputeTransformWithDestinationSublayerScale to share
code a bit more. The more general idea of "put this rect into the space of this
surface" does seem like something that could eventually be shared with clip or
visible rect computation.

+    gfx::Transform transform;
+    if (effect_node->parent_id != -1) {
+      // For non-root surfaces, transform by sub-layer scale.
+      gfx::Vector2dF sublayer_scale =
+          property_trees()
+              ->transform_tree.Node(effect_node->data.transform_id)
+              ->data.sublayer_scale;
+      transform.Scale(sublayer_scale.x(), sublayer_scale.y());
+    } else {
+      // The root surface doesn't have the notion of sub-layer scale, but
+      // instead has a similar notion of transforming from the space of the root
+      // layer to the space of the screen.
+      property_trees()->transform_tree.ComputeTransform(1, 0, &transform);
+    }
+    it->set_area(MathUtil::MapEnclosingClippedRect(transform, it->area()));
+  }
+}
+
+bool EffectTree::HasCopyRequests() const {
+  return !copy_requests_.empty();
+}
+
 void EffectTree::ClearCopyRequests() {
   for (auto& node : nodes()) {
     node.data.num_copy_requests_in_subtree = 0;
     node.data.has_copy_request = false;
   }
+
+  // Any copy requests that are still left will be aborted (sending an empty
+  // result) on desruction.
+  copy_requests_.clear();
   set_needs_update(true);
 }
 
 bool EffectTree::ContributesToDrawnSurface(int id) {
   // All drawn nodes contribute to drawn surface.
   // Exception : Nodes that are hidden and are drawn only for the sake of
   // copy requests.
   EffectNode* node = Node(id);
   EffectNode* parent_node = parent(node);
   return node->data.is_drawn && (!parent_node || parent_node->data.is_drawn);
@@ skipping 46 matching lines @@
 
 void ClipTree::FromProtobuf(
     const proto::PropertyTree& proto,
     std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Clip);
 
   PropertyTree::FromProtobuf(proto, node_id_to_index_map);
 }
 
+EffectTree& EffectTree::operator=(const EffectTree& from) {
+  PropertyTree::operator=(from);
+  // copy_requests_ are omitted here, since these need to be moved rather
+  // than copied or assigned.
+  return *this;
+}
+
 bool EffectTree::operator==(const EffectTree& other) const {
   return PropertyTree::operator==(other);
 }
 
 void EffectTree::ToProtobuf(proto::PropertyTree* proto) const {
   DCHECK(!proto->has_property_type());
   proto->set_property_type(proto::PropertyTree::Effect);
 
   PropertyTree::ToProtobuf(proto);
 }
@@ skipping 649 matching lines @@
   value->EndDictionary();
 
   value->BeginDictionary("scroll_tree");
   scroll_tree.AsValueInto(value.get());
   value->EndDictionary();
 
   return value;
 }
 
 }  // namespace cc