cc: Compute draw transforms dynamically.

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 <stddef.h>
 
 #include <memory>
@@ skipping 102 matching lines @@
   void SetPropertyTrees(PropertyTrees* property_trees) {
     property_trees_ = property_trees;
   }
   PropertyTrees* property_trees() const { return property_trees_; }
 
   void AsValueInto(base::trace_event::TracedValue* value) const;
 
  private:
   std::vector<T> nodes_;
 
+  friend class TransformTree;
   bool needs_update_;
   PropertyTrees* property_trees_;
 };
 
 struct StickyPositionNodeData {
   int scroll_ancestor;
   LayerStickyPositionConstraint constraints;
 
   // This is the offset that blink has already applied to counteract the main
   // thread scroll offset of the scroll ancestor. We need to account for this
@@ skipping 54 matching lines @@
   void ResetChangeTracking();
   // Updates the parent, target, and screen space transforms and snapping.
   void UpdateTransforms(int id);
   void UpdateTransformChanged(TransformNode* node,
                               TransformNode* parent_node,
                               TransformNode* source_node);
   void UpdateNodeAndAncestorsAreAnimatedOrInvertible(
       TransformNode* node,
       TransformNode* parent_node);
 
+  void set_needs_update(bool needs_update);
+
   // 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
   // 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;
@@ skipping 33 matching lines @@
 
   const std::vector<int>& nodes_affected_by_inner_viewport_bounds_delta()
       const {
     return nodes_affected_by_inner_viewport_bounds_delta_;
   }
   const std::vector<int>& nodes_affected_by_outer_viewport_bounds_delta()
       const {
     return nodes_affected_by_outer_viewport_bounds_delta_;
   }
 
-  const gfx::Transform& FromTarget(int node_id, int effect) const;
+  gfx::Transform FromTarget(int node_id, int effect) const;
   void SetFromTarget(int node_id, const gfx::Transform& transform);
 
   // TODO(sunxd): Remove target space transforms in cached data when we
   // completely implement computing draw transforms on demand.
-  const gfx::Transform& ToTarget(int node_id, int effect_id) const;
+  gfx::Transform ToTarget(int node_id, int effect_id) const;
   void SetToTarget(int node_id, const gfx::Transform& transform);
 
   const gfx::Transform& FromScreen(int node_id) const;
   void SetFromScreen(int node_id, const gfx::Transform& transform);
 
   const gfx::Transform& ToScreen(int node_id) const;
   void SetToScreen(int node_id, const gfx::Transform& transform);
 
   int TargetId(int node_id) const;
   void SetTargetId(int node_id, int target_id);
@@ skipping 244 matching lines @@
 
   CombinedAnimationScale(float maximum, float starting)
       : maximum_animation_scale(maximum), starting_animation_scale(starting) {}
   bool operator==(const CombinedAnimationScale& other) const {
     return maximum_animation_scale == other.maximum_animation_scale &&
            starting_animation_scale == other.starting_animation_scale;
   }
 };
 
 struct DrawTransforms {
-  bool invertible;
+  // We compute invertibility of a draw transforms lazily.
+  // Might_be_invertible is true if we have not computed the inverse of either
+  // to_target or from_target, or to_target / from_target is invertible.
+  bool might_be_invertible;
+  // From_valid is true if the from_target is already computed directly or
+  // computed by inverting an invertible to_target.
+  bool from_valid;
+  // To_valid is true if to_target stores a valid result, similar to from_valid.
+  bool to_valid;
   gfx::Transform from_target;
   gfx::Transform to_target;
 
   DrawTransforms(gfx::Transform from, gfx::Transform to)
-      : invertible(true), from_target(from), to_target(to) {}
+      : might_be_invertible(true),
+        from_valid(false),
+        to_valid(false),
+        from_target(from),
+        to_target(to) {}
   bool operator==(const DrawTransforms& other) const {
-    return invertible == other.invertible && from_target == other.from_target &&
-           to_target == other.to_target;
+    return from_valid == other.from_valid && to_valid == other.to_valid &&
+           from_target == other.from_target && to_target == other.to_target;
   }
 };
 
 struct DrawTransformData {
   int update_number;
+  int target_id;
+
   DrawTransforms transforms;
 
   // TODO(sunxd): Move screen space transforms here if it can improve
   // performance.
   DrawTransformData()
-      : update_number(-1), transforms(gfx::Transform(), gfx::Transform()) {}
+      : update_number(-1),
+        target_id(-1),
+        transforms(gfx::Transform(), gfx::Transform()) {}
 };
 
 struct PropertyTreesCachedData {
   int property_tree_update_number;
   std::vector<AnimationScaleData> animation_scales;
-  mutable std::vector<std::unordered_map<int, DrawTransformData>>
-      draw_transforms;
+  mutable std::vector<std::vector<DrawTransformData>> draw_transforms;
 
   PropertyTreesCachedData();
   ~PropertyTreesCachedData();
 };
 
 class CC_EXPORT PropertyTrees final {
  public:
   PropertyTrees();
   PropertyTrees(const PropertyTrees& other) = delete;
   ~PropertyTrees();
@@ skipping 24 matching lines @@
   bool changed;
   // We cache a global bool for full tree damages to avoid walking the entire
   // tree.
   // TODO(jaydasika): Changes to transform and effects that damage the entire
   // tree should be tracked by this bool. Currently, they are tracked by the
   // individual nodes.
   bool full_tree_damaged;
   int sequence_number;
   bool is_main_thread;
   bool is_active;
-  bool verify_transform_tree_calculations;
 
   void clear();
 
   void SetInnerViewportContainerBoundsDelta(gfx::Vector2dF bounds_delta);
   void SetOuterViewportContainerBoundsDelta(gfx::Vector2dF bounds_delta);
   void SetInnerViewportScrollBoundsDelta(gfx::Vector2dF bounds_delta);
   void PushOpacityIfNeeded(PropertyTrees* target_tree);
   void RemoveIdFromIdToIndexMaps(int id);
   bool IsInIdToIndexMap(TreeType tree_type, int id);
   void UpdateChangeTracking();
@@ skipping 13 matching lines @@
   }
 
   std::unique_ptr<base::trace_event::TracedValue> AsTracedValue() const;
 
   CombinedAnimationScale GetAnimationScales(int transform_node_id,
                                             LayerTreeImpl* layer_tree_impl);
   void SetAnimationScalesForTesting(int transform_id,
                                     float maximum_animation_scale,
                                     float starting_animation_scale);
 
-  // GetDrawTransforms may change the value of cached_data_.
-  const DrawTransforms& GetDrawTransforms(int transform_id,
-                                          int effect_id) const;
+  bool GetToTarget(int transform_id,
+                   int effect_id,
+                   gfx::Transform* to_target) const;
+  bool GetFromTarget(int transform_id,
+                     int effect_id,
+                     gfx::Transform* from_target) const;
 
   void ResetCachedData();
   void UpdateCachedNumber();
   gfx::Transform ToScreenSpaceTransformWithoutSurfaceContentsScale(
       int transform_id,
       int effect_id) const;
   bool ComputeTransformToTarget(int transform_id,
                                 int effect_id,
                                 gfx::Transform* transform) const;
 
   bool ComputeTransformFromTarget(int transform_id,
                                   int effect_id,
                                   gfx::Transform* transform) const;
 
  private:
   gfx::Vector2dF inner_viewport_container_bounds_delta_;
   gfx::Vector2dF outer_viewport_container_bounds_delta_;
   gfx::Vector2dF inner_viewport_scroll_bounds_delta_;
 
+  // GetDrawTransforms may change the value of cached_data_.
+  DrawTransforms& GetDrawTransforms(int transform_id, int effect_id) const;
+  DrawTransformData& FetchDrawTransformsDataFromCache(int transform_id,
+                                                      int effect_id) const;
+
   PropertyTreesCachedData cached_data_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_