cc : Clean up cc clip 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"
@@ skipping 1965 matching lines @@
       .combined_maximum_animation_target_scale = maximum_animation_scale;
   cached_data_.animation_scales[transform_id]
       .combined_starting_animation_scale = starting_animation_scale;
   cached_data_.animation_scales[transform_id].update_number =
       cached_data_.transform_tree_update_number;
 }
 
 bool PropertyTrees::GetToTarget(int transform_id,
                                 int effect_id,
                                 gfx::Transform* to_target) const {
+  if (effect_id == EffectTree::kContentsRootNodeId) {
+    *to_target = transform_tree.ToScreen(transform_id);
+    return true;
+  }
   DrawTransforms& transforms = GetDrawTransforms(transform_id, effect_id);
   if (transforms.to_valid) {
     *to_target = transforms.to_target;
     return true;
   } else if (!transforms.might_be_invertible) {
     return false;
   } else {
     transforms.might_be_invertible =
         transforms.from_target.GetInverse(to_target);
     transforms.to_valid = transforms.might_be_invertible;
     transforms.to_target = *to_target;
     return transforms.to_valid;
   }
 }
 
 bool PropertyTrees::GetFromTarget(int transform_id,
                                   int effect_id,
                                   gfx::Transform* from_target) const {
+  const TransformNode* node = transform_tree.Node(transform_id);
+  if (node->ancestors_are_invertible &&
+      effect_id == EffectTree::kContentsRootNodeId) {
+    *from_target = transform_tree.FromScreen(transform_id);
+    return true;
+  }
   DrawTransforms& transforms = GetDrawTransforms(transform_id, effect_id);
   if (transforms.from_valid) {
     *from_target = transforms.from_target;
     return true;
   } else if (!transforms.might_be_invertible) {
     return false;
   } else {
     transforms.might_be_invertible =
         transforms.to_target.GetInverse(from_target);
     transforms.from_valid = transforms.might_be_invertible;
@@ skipping 15 matching lines @@
     }
   }
   // Add an entry to the cache.
   cached_data_.draw_transforms[transform_id].push_back(DrawTransformData());
   DrawTransformData& data = cached_data_.draw_transforms[transform_id].back();
   data.update_number = -1;
   data.target_id = dest_id;
   return data;
 }
 
+ClipRectData* PropertyTrees::FetchClipRectFromCache(int clip_id,
+                                                    int target_id) {
+  ClipNode* clip_node = clip_tree.Node(clip_id);
+  for (auto& data : clip_node->cached_clip_rects) {
+    if (data.target_id == target_id || data.target_id == -1)
+      return &data;
+  }
+  clip_node->cached_clip_rects.push_back(ClipRectData());
+  return &clip_node->cached_clip_rects.back();
+}
+
 DrawTransforms& PropertyTrees::GetDrawTransforms(int transform_id,
                                                  int effect_id) const {
   const EffectNode* effect_node = effect_tree.Node(effect_id);
   int dest_id = effect_node->transform_id;
 
   DrawTransformData& data =
       FetchDrawTransformsDataFromCache(transform_id, dest_id);
 
   DCHECK(data.update_number != cached_data_.transform_tree_update_number ||
          data.target_id != EffectTree::kInvalidNodeId);
@@ skipping 65 matching lines @@
   const EffectNode* effect_node = effect_tree.Node(effect_id);
 
   if (effect_node->surface_contents_scale.x() != 0.0 &&
       effect_node->surface_contents_scale.y() != 0.0)
     screen_space_transform.Scale(1.0 / effect_node->surface_contents_scale.x(),
                                  1.0 / effect_node->surface_contents_scale.y());
   return screen_space_transform;
 }
 
 }  // namespace cc