cc: Throttle tile priority updates to once a frame.

cc/layer_tree_impl.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/layer_tree_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
 #include "ui/gfx/vector2d_conversions.h"
@@ skipping 103 matching lines @@
   gfx::Vector2dF max_scroll = gfx::Rect(ScrollableSize()).bottom_right() -
       gfx::RectF(view_bounds).bottom_right();
 
   // The viewport may be larger than the contents in some cases, such as
   // having a vertical scrollbar but no horizontal overflow.
   max_scroll.ClampToMin(gfx::Vector2dF());
 
   root_scroll_layer_->setMaxScrollOffset(gfx::ToFlooredVector2d(max_scroll));
 }
 
-void LayerTreeImpl::UpdateDrawProperties() {
-  if (!needs_update_draw_properties_)
+struct UpdateTilePrioritiesForLayer {
+  void operator()(LayerImpl *layer) {
+    layer->updateTilePriorities();
+  }
+};
+
+void LayerTreeImpl::UpdateDrawProperties(UpdateDrawPropertiesReason reason) {
+  if (!needs_update_draw_properties_) {
+    if (reason == UPDATE_ACTIVE_TREE_FOR_DRAW && RootLayer())
+      LayerTreeHostCommon::callFunctionForSubtree<UpdateTilePrioritiesForLayer>(

[enne (OOO), 2013/01/25 20:59:10]

I think this might be unneeded.

You should only need to update tile priorities after commit (to initialize) or
when draw properties have changed.  (This patch throttles back how many times we
do it from the second condition.) However, if there's no need to update draw
properties, then there should be equally no need to update tile priorities.

[danakj, 2013/01/25 21:18:15]

The idea is that if you update draw props on scroll (ensureRSLL) but don't
update tile prio at the time, you do it when you draw.

+          RootLayer());
     return;
+  }
 
   needs_update_draw_properties_ = false;
   render_surface_layer_list_.clear();
 
   // For maxTextureSize.
   if (!layer_tree_host_impl_->renderer())
       return;
 
   if (!RootLayer())
     return;
 
   if (root_scroll_layer_) {
     root_scroll_layer_->setImplTransform(
         layer_tree_host_impl_->implTransform());
     // Setting the impl transform re-sets this.
     needs_update_draw_properties_ = false;
   }
 
   {
     TRACE_EVENT1("cc", "LayerTreeImpl::UpdateDrawProperties", "IsActive", IsActiveTree());
+    bool update_tile_priorities =
+        reason == UPDATE_PENDING_TREE ||
+        reason == UPDATE_ACTIVE_TREE_FOR_DRAW;
     LayerTreeHostCommon::calculateDrawProperties(
         RootLayer(),
         device_viewport_size(),
         device_scale_factor(),
         pinch_zoom_viewport().page_scale_factor(),
         MaxTextureSize(),
         settings().canUseLCDText,
-        render_surface_layer_list_);
+        render_surface_layer_list_,
+        update_tile_priorities);
   }
 
   DCHECK(!needs_update_draw_properties_) <<
       "calcDrawProperties should not set_needs_update_draw_properties()";
 }
 
 static void ClearRenderSurfacesOnLayerImplRecursive(LayerImpl* current)
 {
     DCHECK(current);
     for (size_t i = 0; i < current->children().size(); ++i)
@@ skipping 180 matching lines @@
 
 AnimationRegistrar* LayerTreeImpl::animationRegistrar() const {
   return layer_tree_host_impl_->animationRegistrar();
 }
 
 const PinchZoomViewport& LayerTreeImpl::pinch_zoom_viewport() const {
   return layer_tree_host_impl_->pinchZoomViewport();
 }
 
 } // namespace cc