[NOT FOR REVIEW]

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 1074 matching lines @@
   node->clip = viewport_rect;
   set_needs_update(true);
 }
 
 gfx::RectF ClipTree::ViewportClip() const {
   const unsigned long min_size = 1;
   DCHECK_GT(size(), min_size);
   return Node(kViewportNodeId)->clip;
 }
 
+void ClipTree::set_needs_update(bool needs_update) {
+  if (needs_update && !needs_update_)
+    property_trees()->UpdateClipTreeUpdateNumber();
+  needs_update_ = needs_update;
+}
+
 bool ClipTree::operator==(const ClipTree& other) const {
   return PropertyTree::operator==(other);
 }
 
 EffectTree& EffectTree::operator=(const EffectTree& from) {
   PropertyTree::operator=(from);
   mask_layer_ids_ = from.mask_layer_ids_;
   // copy_requests_ are omitted here, since these need to be moved rather
   // than copied or assigned.
   return *this;
@@ skipping 425 matching lines @@
 
 gfx::ScrollOffset ScrollTree::ClampScrollOffsetToLimits(
     gfx::ScrollOffset offset,
     ScrollNode* scroll_node) const {
   offset.SetToMin(MaxScrollOffset(scroll_node->id));
   offset.SetToMax(gfx::ScrollOffset());
   return offset;
 }
 
 PropertyTreesCachedData::PropertyTreesCachedData()
-    : transform_tree_update_number(0) {
+    : transform_tree_update_number(0), clip_tree_update_number(0) {
   animation_scales.clear();
 }
 
 PropertyTreesCachedData::~PropertyTreesCachedData() {}
 
 PropertyTrees::PropertyTrees()
     : needs_rebuild(true),
       non_root_surfaces_enabled(true),
       changed(false),
       full_tree_damaged(false),
@@ skipping 444 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;
 }
 
+int PropertyTrees::ClipRectCacheId(int clip_id, int target_id) const {
+  auto& cached_clips = cached_data_.clip_rects[clip_id];
+  for (size_t i = 0; i < cached_clips.size(); i++) {
+    if (cached_clips[i].target_id == target_id &&
+        cached_clips[i].update_number == cached_data_.clip_tree_update_number)
+      return static_cast<int>(i);
+  }
+  return -1;
+}
+
+ConditionalClip& PropertyTrees::FetchClipRectFromCache(int clip_id,
+                                                       int target_id,
+                                                       int cache_index) const {
+  DCHECK_GE(cache_index, 0);
+  DCHECK_NE(ClipRectCacheId(clip_id, target_id), -1);
+  DCHECK_EQ(cached_data_.clip_rects[clip_id][cache_index].update_number,
+            cached_data_.clip_tree_update_number);
+  return cached_data_.clip_rects[clip_id][cache_index].clip;
+}
+
+void PropertyTrees::AddToClipRectCache(int clip_id,
+                                       int target_id,
+                                       const ConditionalClip& clip) {
+  auto& cached_clips = cached_data_.clip_rects[clip_id];
+
+  if (cached_clips.size() > 1 || cached_clips.back().target_id != -1) {
+    cached_clips.push_back(ClipRectData());
+  }
+
+  ClipRectData& data = cached_clips.back();
+  data.update_number = cached_data_.clip_tree_update_number;
+  data.target_id = target_id;
+  data.clip = clip;
+}
+
+bool PropertyTrees::IsInVisibleRectCache(int clip_id) const {
+  return cached_data_.visible_rects[clip_id].update_number ==
+         cached_data_.clip_tree_update_number;
+}
+
+gfx::RectF PropertyTrees::FetchVisibleRectFromCache(int clip_id) const {
+  DCHECK_EQ(cached_data_.visible_rects[clip_id].update_number,
+            cached_data_.clip_tree_update_number);
+  return cached_data_.visible_rects[clip_id].visible_rect;
+}
+
+void PropertyTrees::AddToVisibleRectCache(int clip_id, const gfx::RectF& rect) {
+  auto& visible_rect_data = cached_data_.visible_rects[clip_id];
+  visible_rect_data.update_number = cached_data_.clip_tree_update_number;
+  visible_rect_data.visible_rect = rect;
+}
+
 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 38 matching lines @@
     data.transforms.to_valid = true;
   data.update_number = cached_data_.transform_tree_update_number;
   data.target_id = dest_id;
   data.transforms.from_target = from_target;
   data.transforms.to_target = target_space_transform;
   return data.transforms;
 }
 
 void PropertyTrees::ResetCachedData() {
   cached_data_.transform_tree_update_number = 0;
+  cached_data_.clip_tree_update_number = 0;
   cached_data_.animation_scales = std::vector<AnimationScaleData>(
       transform_tree.nodes().size(), AnimationScaleData());
   cached_data_.draw_transforms = std::vector<std::vector<DrawTransformData>>(
       transform_tree.nodes().size(), std::vector<DrawTransformData>(1));
+  cached_data_.clip_rects = std::vector<std::vector<ClipRectData>>(
+      clip_tree.nodes().size(), std::vector<ClipRectData>(1));
+  cached_data_.visible_rects =
+      std::vector<VisibleRectData>(clip_tree.nodes().size());
 }
 
 void PropertyTrees::UpdateTransformTreeUpdateNumber() {
   cached_data_.transform_tree_update_number++;
 }
 
+void PropertyTrees::UpdateClipTreeUpdateNumber() {
+  cached_data_.clip_tree_update_number++;
+}
+
 gfx::Transform PropertyTrees::ToScreenSpaceTransformWithoutSurfaceContentsScale(
     int transform_id,
     int effect_id) const {
   if (transform_id == TransformTree::kRootNodeId) {
     return gfx::Transform();
   }
   gfx::Transform screen_space_transform = transform_tree.ToScreen(transform_id);
   const EffectNode* effect_node = effect_tree.Node(effect_id);
 
   if (effect_node->surface_contents_scale.x() != 0.0 &&
@@ skipping 13 matching lines @@
 
   const EffectNode* effect_node = effect_tree.Node(effect_id);
 
   bool success = GetFromTarget(transform_id, effect_id, transform);
   transform->Scale(effect_node->surface_contents_scale.x(),
                    effect_node->surface_contents_scale.y());
   return success;
 }
 
 }  // namespace cc