Implement position: sticky updates on compositor

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/animation/animation_host.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/synced_property_conversions.h"
 #include "cc/trees/clip_node.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree.h"
 #include "cc/trees/scroll_node.h"
 #include "cc/trees/transform_node.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
-
 namespace cc {
 
 template <typename T>
 PropertyTree<T>::PropertyTree()
     : needs_update_(false) {
   nodes_.push_back(T());
   back()->id = kRootNodeId;
   back()->parent_id = kInvalidNodeId;
 }
 
@@ skipping 87 matching lines @@
     value->EndDictionary();
   }
   value->EndArray();
 }
 
 template class PropertyTree<TransformNode>;
 template class PropertyTree<ClipNode>;
 template class PropertyTree<EffectNode>;
 template class PropertyTree<ScrollNode>;
 
+void StickyPositionNodeData::ToProtobuf(
+    proto::StickyPositionNodeData* proto) const {
+  proto->set_scroll_ancestor(scroll_ancestor);
+  constraints.ToProtobuf(proto->mutable_constraints());
+  Vector2dFToProto(main_thread_offset, proto->mutable_main_thread_offset());
+}
+
+void StickyPositionNodeData::FromProtobuf(
+    const proto::StickyPositionNodeData& proto) {
+  scroll_ancestor = proto.scroll_ancestor();
+  constraints.FromProtobuf(proto.constraints());
+  main_thread_offset = ProtoToVector2dF(proto.main_thread_offset());
+}
+
 int TransformTree::Insert(const TransformNode& tree_node, int parent_id) {
   int node_id = PropertyTree<TransformNode>::Insert(tree_node, parent_id);
   DCHECK_EQ(node_id, static_cast<int>(cached_data_.size()));
 
   cached_data_.push_back(TransformCachedNodeData());
   return node_id;
 }
 
 void TransformTree::clear() {
   PropertyTree<TransformNode>::clear();
 
   page_scale_factor_ = 1.f;
   device_scale_factor_ = 1.f;
   device_transform_scale_factor_ = 1.f;
   nodes_affected_by_inner_viewport_bounds_delta_.clear();
   nodes_affected_by_outer_viewport_bounds_delta_.clear();
   cached_data_.clear();
   cached_data_.push_back(TransformCachedNodeData());
+  sticky_position_data_.clear();
 
 #if DCHECK_IS_ON()
   TransformTree tree;
   // TODO(jaydasika) : Move tests that expect source_to_parent_updates_allowed
   // to be true on impl thread to main thread and set it to is_main_thread here.
   tree.source_to_parent_updates_allowed_ = source_to_parent_updates_allowed_;
   DCHECK(tree == *this);
 #endif
 }
 
@@ skipping 81 matching lines @@
     node->transform_changed = false;
   }
 }
 
 void TransformTree::UpdateTransforms(int id) {
   TransformNode* node = Node(id);
   TransformNode* parent_node = parent(node);
   TransformNode* target_node = Node(TargetId(id));
   TransformNode* source_node = Node(node->source_node_id);
   property_trees()->UpdateCachedNumber();
-  if (node->needs_local_transform_update || NeedsSourceToParentUpdate(node))
+  // TODO(flackr): Only dirty when scroll offset changes.
+  if (node->sticky_position_constraint_id >= 0 ||
+      node->needs_local_transform_update || NeedsSourceToParentUpdate(node)) {
     UpdateLocalTransform(node);
-  else
+  } else {
     UndoSnapping(node);
+  }
   UpdateScreenSpaceTransform(node, parent_node, target_node);
   UpdateSurfaceContentsScale(node);
   UpdateAnimationProperties(node, parent_node);
   UpdateSnapping(node);
   UpdateTargetSpaceTransform(node, target_node);
   UpdateNodeAndAncestorsHaveIntegerTranslations(node, parent_node);
   UpdateTransformChanged(node, parent_node, source_node);
   UpdateNodeAndAncestorsAreAnimatedOrInvertible(node, parent_node);
 }
 
@@ skipping 125 matching lines @@
   // from the destination to the source, with flattening, and then invert the
   // result.
   gfx::Transform dest_to_source;
   CombineTransformsBetween(dest_id, source_id, &dest_to_source);
   gfx::Transform source_to_dest;
   bool all_are_invertible = dest_to_source.GetInverse(&source_to_dest);
   transform->PreconcatTransform(source_to_dest);
   return all_are_invertible;
 }
 
+gfx::Vector2dF StickyPositionOffset(TransformTree* tree, TransformNode* node) {
+  if (node->sticky_position_constraint_id == -1)
+    return gfx::Vector2dF();
+  const StickyPositionNodeData* sticky_data =
+      tree->StickyPositionData(node->id);
+  const LayerStickyPositionConstraint& constraint = sticky_data->constraints;
+  ScrollNode* scroll_node =
+      tree->property_trees()->scroll_tree.Node(sticky_data->scroll_ancestor);
+  gfx::ScrollOffset scroll_offset =
+      tree->property_trees()->scroll_tree.current_scroll_offset(
+          scroll_node->owner_id);
+
+  gfx::RectF clip(gfx::PointF(scroll_offset.x(), scroll_offset.y()),
+                  gfx::SizeF(scroll_node->scroll_clip_layer_bounds));
+  gfx::Vector2dF sticky_offset(
+      constraint.scroll_container_relative_sticky_box_rect.OffsetFromOrigin());
+  gfx::Vector2dF layer_offset(sticky_data->main_thread_offset);
+
+  // In each of the following cases, we measure the limit which is the point
+  // that the element should stick to, clamping on one side to 0 (because sticky
+  // only pushes elements in one direction). Then we clamp to how far we can
+  // push the element in that direction without being pushed outside of its
+  // containing block.
+  //
+  // Note: The order of applying the sticky constraints is applied such that
+  // left offset takes precedence over right offset, and top takes precedence
+  // over bottom offset.
+  if (constraint.is_anchored_right) {
+    float right_limit = clip.right() - constraint.right_offset;
+    float right_delta = std::min<float>(
+        0, right_limit -
+               constraint.scroll_container_relative_sticky_box_rect.right());
+    float available_space = std::min<float>(
+        0, constraint.scroll_container_relative_containing_block_rect.x() -
+               constraint.scroll_container_relative_sticky_box_rect.x());
+    if (right_delta < available_space)
+      right_delta = available_space;
+    sticky_offset.set_x(sticky_offset.x() + right_delta);
+  }
+  if (constraint.is_anchored_left) {
+    float left_limit = clip.x() + constraint.left_offset;
+    float left_delta = std::max<float>(
+        0,
+        left_limit - constraint.scroll_container_relative_sticky_box_rect.x());
+    float available_space = std::max<float>(
+        0, constraint.scroll_container_relative_containing_block_rect.right() -
+               constraint.scroll_container_relative_sticky_box_rect.right());
+    if (left_delta > available_space)
+      left_delta = available_space;
+    sticky_offset.set_x(sticky_offset.x() + left_delta);
+  }
+  if (constraint.is_anchored_bottom) {
+    float bottom_limit = clip.bottom() - constraint.bottom_offset;
+    float bottom_delta = std::min<float>(
+        0, bottom_limit -
+               constraint.scroll_container_relative_sticky_box_rect.bottom());
+    float available_space = std::min<float>(
+        0, constraint.scroll_container_relative_containing_block_rect.y() -
+               constraint.scroll_container_relative_sticky_box_rect.y());
+    if (bottom_delta < available_space)
+      bottom_delta = available_space;
+    sticky_offset.set_y(sticky_offset.y() + bottom_delta);
+  }
+  if (constraint.is_anchored_top) {
+    float top_limit = clip.y() + constraint.top_offset;
+    float top_delta = std::max<float>(
+        0,
+        top_limit - constraint.scroll_container_relative_sticky_box_rect.y());
+    float available_space = std::max<float>(
+        0, constraint.scroll_container_relative_containing_block_rect.bottom() -
+               constraint.scroll_container_relative_sticky_box_rect.bottom());
+    if (top_delta > available_space)
+      top_delta = available_space;
+    sticky_offset.set_y(sticky_offset.y() + top_delta);
+  }
+  return sticky_offset - layer_offset -
+         constraint.scroll_container_relative_sticky_box_rect
+             .OffsetFromOrigin();
+}
+
 void TransformTree::UpdateLocalTransform(TransformNode* node) {
   gfx::Transform transform = node->post_local;
   if (NeedsSourceToParentUpdate(node)) {
     gfx::Transform to_parent;
     ComputeTranslation(node->source_node_id, node->parent_id, &to_parent);
     gfx::Vector2dF unsnapping;
     TransformNode* current;
     TransformNode* parent_node;
     for (current = Node(node->source_node_id); current->id > node->parent_id;
          current = parent(current)) {
@@ skipping 29 matching lines @@
 
   if (node->affected_by_inner_viewport_bounds_delta_y)
     fixed_position_adjustment.set_y(inner_viewport_bounds_delta.y());
   else if (node->affected_by_outer_viewport_bounds_delta_y)
     fixed_position_adjustment.set_y(outer_viewport_bounds_delta.y());
 
   transform.Translate(node->source_to_parent.x() - node->scroll_offset.x() +
                           fixed_position_adjustment.x(),
                       node->source_to_parent.y() - node->scroll_offset.y() +
                           fixed_position_adjustment.y());
+  transform.Translate(StickyPositionOffset(this, node));
   transform.PreconcatTransform(node->local);
   transform.PreconcatTransform(node->pre_local);
+
   node->set_to_parent(transform);
   node->needs_local_transform_update = false;
 }
 
 void TransformTree::UpdateScreenSpaceTransform(TransformNode* node,
                                                TransformNode* parent_node,
                                                TransformNode* target_node) {
   if (!parent_node) {
     SetToScreen(node->id, node->to_parent);
     node->ancestors_are_invertible = true;
@@ skipping 289 matching lines @@
          device_scale_factor_ == other.device_scale_factor() &&
          device_transform_scale_factor_ ==
              other.device_transform_scale_factor() &&
          nodes_affected_by_inner_viewport_bounds_delta_ ==
              other.nodes_affected_by_inner_viewport_bounds_delta() &&
          nodes_affected_by_outer_viewport_bounds_delta_ ==
              other.nodes_affected_by_outer_viewport_bounds_delta() &&
          cached_data_ == other.cached_data();
 }
 
+StickyPositionNodeData* TransformTree::StickyPositionData(int node_id) {
+  TransformNode* node = Node(node_id);
+  if (node->sticky_position_constraint_id == -1) {
+    node->sticky_position_constraint_id = sticky_position_data_.size();
+    sticky_position_data_.push_back(StickyPositionNodeData());
+  }
+  return &sticky_position_data_[node->sticky_position_constraint_id];
+}
+
 void TransformTree::ToProtobuf(proto::PropertyTree* proto) const {
   DCHECK(!proto->has_property_type());
   proto->set_property_type(proto::PropertyTree::Transform);
 
   PropertyTree::ToProtobuf(proto);
   proto::TransformTreeData* data = proto->mutable_transform_tree_data();
 
   data->set_source_to_parent_updates_allowed(source_to_parent_updates_allowed_);
   data->set_page_scale_factor(page_scale_factor_);
   data->set_device_scale_factor(device_scale_factor_);
   data->set_device_transform_scale_factor(device_transform_scale_factor_);
 
   for (auto i : nodes_affected_by_inner_viewport_bounds_delta_)
     data->add_nodes_affected_by_inner_viewport_bounds_delta(i);
 
   for (auto i : nodes_affected_by_outer_viewport_bounds_delta_)
     data->add_nodes_affected_by_outer_viewport_bounds_delta(i);
 
   for (int i = 0; i < static_cast<int>(cached_data_.size()); ++i)
     cached_data_[i].ToProtobuf(data->add_cached_data());
+
+  for (int i = 0; i < static_cast<int>(sticky_position_data_.size()); ++i)
+    sticky_position_data_[i].ToProtobuf(data->add_sticky_position_data());
 }
 
 void TransformTree::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::Transform);
 
   PropertyTree::FromProtobuf(proto, node_id_to_index_map);
   const proto::TransformTreeData& data = proto.transform_tree_data();
@@ skipping 16 matching lines @@
     nodes_affected_by_outer_viewport_bounds_delta_.push_back(
         data.nodes_affected_by_outer_viewport_bounds_delta(i));
   }
 
   DCHECK_EQ(static_cast<int>(cached_data_.size()), 1);
   cached_data_.back().FromProtobuf(data.cached_data(0));
   for (int i = 1; i < data.cached_data_size(); ++i) {
     cached_data_.push_back(TransformCachedNodeData());
     cached_data_.back().FromProtobuf(data.cached_data(i));
   }
+
+  DCHECK(static_cast<int>(sticky_position_data_.empty()));
+  for (int i = 0; i < data.sticky_position_data_size(); ++i) {
+    sticky_position_data_.push_back(StickyPositionNodeData());
+    sticky_position_data_.back().FromProtobuf(data.sticky_position_data(i));
+  }
 }
 
 EffectTree::EffectTree() {}
 
 EffectTree::~EffectTree() {}
 
 void EffectTree::clear() {
   PropertyTree<EffectNode>::clear();
   mask_replica_layer_ids_.clear();
 
@@ skipping 1419 matching lines @@
     from_target.ConcatTransform(draw_transforms.from_target);
     from_target.Scale(effect_node->surface_contents_scale.x(),
                       effect_node->surface_contents_scale.y());
     DCHECK(from_target.ApproximatelyEqual(*transform) ||
            !draw_transforms.invertible);
   }
   return success;
 }
 
 }  // namespace cc