cc: Make impl-thread property trees handle fixed-position layers

cc/trees/property_tree.h

 // 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.
 
 #ifndef CC_TREES_PROPERTY_TREE_H_
 #define CC_TREES_PROPERTY_TREE_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 88 matching lines @@
   // TODO(vollick): will be moved when accelerated effects are implemented.
   gfx::ScrollOffset scroll_offset;
 
   // We scroll snap where possible, but this has an effect on scroll
   // compensation: the snap is yet more scrolling that must be compensated for.
   // This value stores the snapped amount for this purpose.
   gfx::Vector2dF scroll_snap;
 
   // TODO(vollick): will be moved when accelerated effects are implemented.
   gfx::Vector2dF source_offset;
+  gfx::Vector2dF source_to_parent;
 
   void set_to_parent(const gfx::Transform& transform) {
     to_parent = transform;
     is_invertible = to_parent.IsInvertible();
   }
 
   void update_pre_local_transform(const gfx::Point3F& transform_origin);
 
   void update_post_local_transform(const gfx::PointF& position,
                                    const gfx::Point3F& transform_origin);
@@ skipping 49 matching lines @@
 
  private:
   // Copy and assign are permitted. This is how we do tree sync.
   std::vector<T> nodes_;
 
   bool needs_update_;
 };
 
 class CC_EXPORT TransformTree final : public PropertyTree<TransformNode> {
  public:
+  TransformTree();
+
   // Computes the change of basis transform from node |source_id| to |dest_id|.
   // The function returns false iff the inverse of a singular transform was
   // used (and the result should, therefore, not be trusted). Transforms may
   // be computed between any pair of nodes that have an ancestor/descendant
   // relationship. Transforms between other pairs of nodes may only be computed
   // if the following condition holds: let id1 the larger id and let id2 be the
   // other id; then the nearest ancestor of node id1 whose id is smaller than
   // id2 is the lowest common ancestor of the pair of nodes, and the transform
   // from this lowest common ancestor to node id2 is only a 2d translation.
   bool ComputeTransform(int source_id,
@@ skipping 17 matching lines @@
                                                int dest_id,
                                                gfx::Transform* transform) const;
 
   // Returns true iff the nodes indexed by |source_id| and |dest_id| are 2D axis
   // aligned with respect to one another.
   bool Are2DAxisAligned(int source_id, int dest_id) const;
 
   // Updates the parent, target, and screen space transforms and snapping.
   void UpdateTransforms(int id);
 
+  // A TransformNode's source_to_parent value is used to account for the fact
+  // that fixed-position layers are positioned by Blink wrt to their layer tree

[enne (OOO), 2015/05/29 20:07:53]

I will be so glad when we get to the point that we can just do this the right
way.

+  // parent (their "source"), but are parented in the transform tree by their
+  // fixed-position container. This value needs to be updated on main-thread
+  // property trees (for position changes initiated by Blink), but not on the
+  // compositor thread (since the offset from a node corresponding to a
+  // fixed-position layer to its fixed-position container is unaffected by
+  // compositor-driven effects).
+  void set_source_to_parent_updates_allowed(bool allowed) {
+    source_to_parent_updates_allowed_ = allowed;
+  }
+  bool source_to_parent_updates_allowed() const {
+    return source_to_parent_updates_allowed_;
+  }
+
  private:
   // Returns true iff the node at |desc_id| is a descendant of the node at
   // |anc_id|.
   bool IsDescendant(int desc_id, int anc_id) const;
 
   // Computes the combined transform between |source_id| and |dest_id| and
   // returns false if the inverse of a singular transform was used. These two
   // nodes must be on the same ancestor chain.
   bool CombineTransformsBetween(int source_id,
                                 int dest_id,
                                 gfx::Transform* transform) const;
 
   // Computes the combined inverse transform between |source_id| and |dest_id|
   // and returns false if the inverse of a singular transform was used. These
   // two nodes must be on the same ancestor chain.
   bool CombineInversesBetween(int source_id,
                               int dest_id,
                               gfx::Transform* transform) const;
 
   void UpdateLocalTransform(TransformNode* node);
   void UpdateScreenSpaceTransform(TransformNode* node,
                                   TransformNode* parent_node,
                                   TransformNode* target_node);
   void UpdateSublayerScale(TransformNode* node);
   void UpdateTargetSpaceTransform(TransformNode* node,
                                   TransformNode* target_node);
   void UpdateIsAnimated(TransformNode* node, TransformNode* parent_node);
   void UpdateSnapping(TransformNode* node);
+  bool NeedsSourceToParentUpdate(TransformNode* node);
+
+  bool source_to_parent_updates_allowed_;
 };
 
 class CC_EXPORT ClipTree final : public PropertyTree<ClipNode> {};
 
 class CC_EXPORT OpacityTree final : public PropertyTree<OpacityNode> {};
 
 class CC_EXPORT PropertyTrees final {
  public:
   PropertyTrees();
 
   TransformTree transform_tree;
   OpacityTree opacity_tree;
   ClipTree clip_tree;
   bool needs_rebuild;
   int sequence_number;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_