cc: Remove SetNeedsCommitNoRebuild from Layer API

cc/trees/draw_property_utils.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 "cc/trees/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/draw_properties.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/trees/clip_node.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree.h"
 #include "cc/trees/property_tree_builder.h"
+#include "cc/trees/scroll_node.h"
 #include "cc/trees/transform_node.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 namespace draw_property_utils {
 
 namespace {
 
 static bool IsRootLayer(const Layer* layer) {
@@ skipping 872 matching lines @@
 
       clip_node->combined_clip_in_target_space = gfx::IntersectRects(
           parent_combined_clip_in_target_space, source_clip_in_target_space);
     }
     ResetIfHasNanCoordinate(&clip_node->clip_in_target_space);
     ResetIfHasNanCoordinate(&clip_node->combined_clip_in_target_space);
   }
   clip_tree->set_needs_update(false);
 }
 
+void UpdateScrollTree(ScrollTree* scroll_tree,
+                      const LayerTreeHost* layer_tree_host) {
+  if (!scroll_tree->needs_update())
+    return;
+
+  for (int i = ScrollTree::kRootNodeId;
+       i < static_cast<int>(scroll_tree->size()); ++i) {
+    ScrollNode* scroll_node = scroll_tree->Node(i);
+    if (Layer* scroll_layer =
+            layer_tree_host->LayerById(scroll_node->owning_layer_id)) {
+      if (Layer* scroll_clip_layer = scroll_layer->scroll_clip_layer()) {
+        scroll_node->scroll_clip_layer_bounds = scroll_clip_layer->bounds();
+      }
+    }
+  }
+}
+
 void ComputeTransforms(TransformTree* transform_tree) {
   if (!transform_tree->needs_update())
     return;
   for (int i = TransformTree::kContentsRootNodeId;
        i < static_cast<int>(transform_tree->size()); ++i)
     transform_tree->UpdateTransforms(i);
   transform_tree->set_needs_update(false);
 }
 
 void UpdateRenderTarget(EffectTree* effect_tree,
@@ skipping 126 matching lines @@
   ComputeClips(property_trees, can_render_to_separate_surface);
 
   FindLayersThatNeedUpdates(root_layer->layer_tree_impl(), property_trees,
                             visible_layer_list);
   CalculateClipRects(*visible_layer_list, property_trees,
                      can_render_to_separate_surface);
   CalculateVisibleRects(*visible_layer_list, property_trees,
                         can_render_to_separate_surface);
 }
 
-void UpdatePropertyTrees(PropertyTrees* property_trees,
+void UpdatePropertyTrees(LayerTreeHost* layer_tree_host,
+                         PropertyTrees* property_trees,
                          bool can_render_to_separate_surface) {
+  DCHECK(layer_tree_host);
+  DCHECK(property_trees);
+  DCHECK_EQ(layer_tree_host->property_trees(), property_trees);
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
     property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
     property_trees->transform_tree.set_needs_update(true);
   }
   if (property_trees->transform_tree.needs_update()) {
     property_trees->clip_tree.set_needs_update(true);
     property_trees->effect_tree.set_needs_update(true);
   }
+  UpdateScrollTree(&property_trees->scroll_tree, layer_tree_host);
   ComputeTransforms(&property_trees->transform_tree);
   // Computation of clips uses surface contents scale which is updated while
   // computing effects. So, ComputeEffects should be before ComputeClips.
   ComputeEffects(&property_trees->effect_tree);
   ComputeClips(property_trees, can_render_to_separate_surface);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(
     LayerImpl* root_layer,
     const LayerImpl* page_scale_layer,
@@ skipping 392 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc