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 764 matching lines @@
     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,
     LayerType* page_scale_application_layer,
     bool in_subtree_of_page_scale_application_layer,
     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 478 matching lines @@
         nearest_ancestor_that_moves_pixels,
         render_surface_layer_list,
         &descendants,
         layer_sorter,
         max_texture_size,
         device_scale_factor,
         page_scale_factor,
         page_scale_application_layer,
         in_subtree_of_page_scale_application_layer,
         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 30 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;
   bool in_subtree_of_page_scale_application_layer = 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,
       page_scale_application_layer,
       in_subtree_of_page_scale_application_layer,
       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,
     LayerImpl* page_scale_application_layer,
     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 18 matching lines @@
       NULL,
       render_surface_layer_list,
       &dummy_layer_list,
       &layer_sorter,
       max_texture_size,
       device_scale_factor,
       page_scale_factor,
       page_scale_application_layer,
       in_subtree_of_page_scale_application_layer,
       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