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

cc/trees/layer_tree_host_common.cc

Index: cc/trees/layer_tree_host_common.cc
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 7548cd293bbf1a2212062e961bc269fa34b0f08e..96f214894245d8bc97c0f103a67a6061666bc2b3 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -252,6 +252,15 @@ static inline bool SubtreeShouldBeSkipped(Layer* layer) {
          !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).
@@ -412,10 +421,10 @@ gfx::Transform ComputeSizeDeltaCompensation(
   // 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();
@@ -440,8 +449,7 @@ 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;
 
@@ -1391,7 +1399,8 @@ static void CalculateDrawPropertiesInternal(
     }
   }
 
-  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.