cc: Compute target space transform 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 49 matching lines @@
   PropertyTree();
   PropertyTree(const PropertyTree& other) = delete;
 
   // These C++ special member functions cannot be implicit inline because
   // they are exported by CC_EXPORT. They will be instantiated in every
   // compilation units that included this header, and compilation can fail
   // because T may be incomplete.
   ~PropertyTree();
   PropertyTree<T>& operator=(const PropertyTree<T>&);
 
+  // Property tree node starts from index 0.
+  static const int kInvalidNodeId = -1;
+  static const int kRootNodeId = 0;
+
   bool operator==(const PropertyTree<T>& other) const;
 
   int Insert(const T& tree_node, int parent_id);
 
   T* Node(int i) {
     // TODO(vollick): remove this.
     CHECK(i < static_cast<int>(nodes_.size()));
     return i > -1 ? &nodes_[i] : nullptr;
   }
   const T* Node(int i) const {
@@ skipping 124 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) const;
+  const gfx::Transform& FromTarget(int node_id, int effect) const;
   void SetFromTarget(int node_id, const gfx::Transform& transform);
 
-  const gfx::Transform& ToTarget(int node_id) const;
+  // 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;
   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 227 matching lines @@
   float starting_animation_scale;
 
   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;
+  gfx::Transform from_target;
+  gfx::Transform to_target;
+
+  DrawTransforms(gfx::Transform from, gfx::Transform to)
+      : invertible(true), 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;
+  }
+};
+
+struct DrawTransformData {
+  int update_number;
+  DrawTransforms transforms;
+
+  // TODO(sunxd): Move screen space transforms here if it can improve
+  // performance.
+  DrawTransformData()
+      : update_number(-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;
 
   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 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();
   void PushChangeTrackingTo(PropertyTrees* tree);
   void ResetAllChangeTracking();
@@ skipping 10 matching lines @@
     return inner_viewport_scroll_bounds_delta_;
   }
 
   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;
+
   void ResetCachedData();
   void UpdateCachedNumber();
   gfx::Transform ToScreenSpaceTransformWithoutSurfaceContentsScale(
       int transform_id,
       int effect_id) const;
 
  private:
   gfx::Vector2dF inner_viewport_container_bounds_delta_;
   gfx::Vector2dF outer_viewport_container_bounds_delta_;
   gfx::Vector2dF inner_viewport_scroll_bounds_delta_;
 
   PropertyTreesCachedData cached_data_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_