cc: Simplify the logic for deciding to update tile priorities.

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 394 matching lines @@
       // Note: Again, Concat is used to conver the result coordinate space from
       //       the container render surface to the container layer.
       target_surface_space_to_container_layer_space.ConcatTransform(
           container_target_surface_space_to_container_layer_space);
     }
   }
 
   // Apply step 3
   gfx::Transform container_layer_space_to_target_surface_space;
   if (target_surface_space_to_container_layer_space.GetInverse(
-      &container_layer_space_to_target_surface_space))
+          &container_layer_space_to_target_surface_space)) {
     result_transform.PreconcatTransform(
         container_layer_space_to_target_surface_space);
-  else {
+  } else {
     // FIXME: A non-invertible matrix could still make meaningful projection.
     // For example ScaleZ(0) is non-invertible but the layer is still visible.
     return gfx::Transform();
   }
 
   // Apply step 2
   result_transform.Translate(position_offset.x(), position_offset.y());
 
   // Apply step 1
   result_transform.PreconcatTransform(
       target_surface_space_to_container_layer_space);
 
   return result_transform;
 }
 
 void ApplyPositionAdjustment(
     Layer* layer,
     Layer* container,
     const gfx::Transform& scroll_compensation,
     gfx::Transform* combined_transform) { }
 void ApplyPositionAdjustment(
     LayerImpl* layer,
     LayerImpl* container,
     const gfx::Transform& scroll_compensation,
-    gfx::Transform* combined_transform)
-{
+    gfx::Transform* combined_transform) {
   if (!layer->position_constraint().is_fixed_position())
     return;
 
   // Special case: this layer is a composited fixed-position layer; we need to
   // explicitly compensate for all ancestors' nonzero scroll_deltas to keep
   // this layer fixed correctly.
   // Note carefully: this is Concat, not Preconcat
   // (current_scroll_compensation * combined_transform).
   combined_transform->ConcatTransform(scroll_compensation);
 
@@ skipping 315 matching lines @@
     gfx::Rect clip_rect_from_ancestor_in_descendant_space,
     bool ancestor_clips_subtree,
     RenderSurfaceType* nearest_ancestor_that_moves_pixels,
     LayerList* render_surface_layer_list,
     LayerList* layer_list,
     LayerSorter* layer_sorter,
     int max_texture_size,
     float device_scale_factor,
     float page_scale_factor,
     bool subtree_can_use_lcd_text,
-    gfx::Rect* drawable_content_rect_of_subtree,
-    bool update_tile_priorities) {
+    gfx::Rect* drawable_content_rect_of_subtree) {
   // This function computes the new matrix transformations recursively for this
   // layer and all its descendants. It also computes the appropriate render
   // surfaces.
   // Some important points to remember:
   //
   // 0. Here, transforms are notated in Matrix x Vector order, and in words we
   // describe what the transform does from left to right.
   //
   // 1. In our terminology, the "layer origin" refers to the top-left corner of
   // a layer, and the positive Y-axis points downwards. This interpretation is
@@ skipping 457 matching lines @@
         clip_rect_for_subtree_in_descendant_space,
         subtree_should_be_clipped,
         nearest_ancestor_that_moves_pixels,
         render_surface_layer_list,
         &descendants,
         layer_sorter,
         max_texture_size,
         device_scale_factor,
         page_scale_factor,
         subtree_can_use_lcd_text,
-        &drawable_content_rect_of_child_subtree,
-        update_tile_priorities);
+        &drawable_content_rect_of_child_subtree);
     if (!drawable_content_rect_of_child_subtree.IsEmpty()) {
       accumulated_drawable_content_rect_of_children.Union(
           drawable_content_rect_of_child_subtree);
       if (child->render_surface())
         descendants.push_back(child);
     }
   }
 
   if (layer->render_surface() && !IsRootLayer(layer) &&
       layer->render_surface()->layer_list().empty()) {
@@ skipping 113 matching lines @@
       // Compute the replica's "screen_space_transform" that maps from the
       // replica's origin space to the screen's origin space.
       gfx::Transform replica_screen_space_transform =
           layer->render_surface()->screen_space_transform() *
           surface_origin_to_replica_origin_transform;
       render_surface->SetReplicaScreenSpaceTransform(
           replica_screen_space_transform);
     }
   }
 
-  if (update_tile_priorities)
-    UpdateTilePrioritiesForLayer(layer);
+  UpdateTilePrioritiesForLayer(layer);
 
   // If neither this layer nor any of its children were added, early out.
   if (sorting_start_index == descendants.size())
     return;
 
   // If preserves-3d then sort all the descendants in 3D so that they can be
   // drawn from back to front. If the preserves-3d property is also set on the
   // parent then skip the sorting as the parent will sort all the descendants
   // anyway.
   if (layer_sorter && descendants.size() && layer->preserves_3d() &&
@@ skipping 29 matching lines @@
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform device_scale_transform;
   device_scale_transform.Scale(device_scale_factor, device_scale_factor);
   LayerList dummy_layer_list;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
   bool subtree_should_be_clipped = true;
   gfx::Rect device_viewport_rect(device_viewport_size);
-  bool update_tile_priorities = false;
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformation<Layer>(root_layer);
   CalculateDrawPropertiesInternal<Layer,
                                   LayerList,
                                   RenderSurface>(root_layer,
                                                  device_scale_transform,
                                                  identity_matrix,
                                                  identity_matrix,
                                                  NULL,
                                                  device_viewport_rect,
                                                  device_viewport_rect,
                                                  subtree_should_be_clipped,
                                                  NULL,
                                                  render_surface_layer_list,
                                                  &dummy_layer_list,
                                                  NULL,
                                                  max_texture_size,
                                                  device_scale_factor,
                                                  page_scale_factor,
                                                  can_use_lcd_text,
-                                                 &total_drawable_content_rect,
-                                                 update_tile_priorities);
+                                                 &total_drawable_content_rect);
 
   // The dummy layer list should not have been used.
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(root_layer->render_surface());
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     LayerImpl* root_layer,
     gfx::Size device_viewport_size,
     float device_scale_factor,
     float page_scale_factor,
     int max_texture_size,
     bool can_use_lcd_text,
-    LayerImplList* render_surface_layer_list,
-    bool update_tile_priorities) {
+    LayerImplList* render_surface_layer_list) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform device_scale_transform;
   device_scale_transform.Scale(device_scale_factor, device_scale_factor);
   LayerImplList dummy_layer_list;
   LayerSorter layer_sorter;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
   bool subtree_should_be_clipped = true;
@@ skipping 15 matching lines @@
       device_viewport_rect,
       subtree_should_be_clipped,
       NULL,
       render_surface_layer_list,
       &dummy_layer_list,
       &layer_sorter,
       max_texture_size,
       device_scale_factor,
       page_scale_factor,
       can_use_lcd_text,
-      &total_drawable_content_rect,
-      update_tile_priorities);
+      &total_drawable_content_rect);
 
   // The dummy layer list should not have been used.
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(root_layer->render_surface());
 }
 
 static bool PointHitsRect(
     gfx::PointF screen_space_point,
@@ skipping 180 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc