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 234 matching lines @@
   // If the opacity is being animated then the opacity on the main thread is
   // unreliable (since the impl thread may be using a different opacity), so it
   // should not be trusted.
   // In particular, it should not cause the subtree to be skipped.
   // Similarly, for layers that might animate opacity using an impl-only
   // animation, their subtree should also not be skipped.
   return !layer->opacity() && !layer->OpacityIsAnimating() &&
          !layer->OpacityCanAnimateOnImplThread();
 }
 
+static inline bool NeedsFirstTimeUpdateTilePrioritiesForLayer(
+    LayerImpl* layer) {
+  return layer->NeedsFirstTimeUpdateTilePriorities();
+}
+
+static inline bool NeedsFirstTimeUpdateTilePrioritiesForLayer(Layer* layer) {
+  return false;
+}
+
 // Called on each layer that could be drawn after all information from
 // CalcDrawProperties has been updated on that layer.  May have some false
 // positives (e.g. layers get this called on them but don't actually get drawn).
 static inline void UpdateTilePrioritiesForLayer(LayerImpl* layer) {
   layer->UpdateTilePriorities();
 
   // Mask layers don't get this call, so explicitly update them so they can
   // kick off tile rasterization.
   if (layer->mask_layer())
     layer->mask_layer()->UpdateTilePriorities();
@@ skipping 140 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 929 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)
+  if (update_tile_priorities ||
+      NeedsFirstTimeUpdateTilePrioritiesForLayer(layer))

[enne (OOO), 2013/04/22 17:03:48]

I'm a little ಠ_ಠ at adding yet another virtual function to LayerImpl.  If you
have to call a virtual function to check if calling a virtual function is
needed, you might as well just do all the work in the second function and
early-out.

I think all of the "needs update tile priorities" could get pushed out of
LayerTreeImpl and get checked from PictureLayerImpl/Tiling.

[danakj, 2013/04/22 18:37:30]

I could certainly call the current function always and pass in "I want you to do
something" and it can decide to do something even if I said not to, if it has a
tiling that's never been prioritized.
Ah, I was happy about making this a single variable on the LTI instead of a
variable in every tiling, it seemed much simpler logic that way along with
smaller tilings. But I can go the other way instead - it doesn't seem required
tho to avoid the extra virtual. Do you prefer it in the tilings instead?

[enne (OOO), 2013/04/22 18:44:13]

You have LayerTreeImpl::frame_time_last_update_tile_priorities_ and
PictureLayerTiling::last_impl_frame_time_.  How do these differ?  Don't you
already have a variable on the tiling?

[danakj, 2013/04/22 18:59:38]

Hm... right. Okay! Just using that now.

PTAL.

     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.
@@ skipping 310 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