cc: Throttle tile priority updates to once a frame.

cc/picture_layer_impl.cc

 // Copyright 2012 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/picture_layer_impl.h"
 
 #include "base/time.h"
 #include "cc/append_quads_data.h"
 #include "cc/checkerboard_draw_quad.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/debug_colors.h"
+#include "cc/frame_rate_counter.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/tile_draw_quad.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace {
 const float kMaxScaleRatioDuringPinch = 2.0f;
 }
 
 namespace cc {
 
 PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* treeImpl, int id)
     : LayerImpl(treeImpl, id),
       pile_(PicturePileImpl::Create()),
+      last_source_frame_number_(0),
+      last_impl_frame_number_(0),
       last_update_time_(0),
       last_content_scale_(0),
       ideal_contents_scale_(0),
       is_mask_(false) {
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
 }
 
 const char* PictureLayerImpl::layerTypeAsString() const {
@@ skipping 19 matching lines @@
 }
 
 void PictureLayerImpl::pushPropertiesTo(LayerImpl* base_layer) {
   LayerImpl::pushPropertiesTo(base_layer);
 
   PictureLayerImpl* layer_impl = static_cast<PictureLayerImpl*>(base_layer);
 
   layer_impl->SetIsMask(is_mask_);
   layer_impl->TransferTilingSet(tilings_.Pass());
   layer_impl->pile_ = pile_;
+  layer_impl->last_impl_frame_number_ = 0;

[enne (OOO), 2013/01/25 18:17:52]

I don't understand this.  I think you'd want to set this to be
this->last_impl_frame_number_ so that if you activate the pending tree, you
don't update priorities again on it as the active tree.  Also, do you need to
set layer_impl->last_source_frame_number_?

[danakj, 2013/01/25 18:25:47]

This is resetting the value on the target tree. This way if you get into
updateTilePriorities() it will say "hey my last impl frame number is 0" and
reset it to "current frame" and then say "well i've already updated this frame
so don't update".

My understanding was that this is called on the pending tree's layer, so
layer_impl here is the active layer. Similar to commit. Am I mistaking that?

last_source_frame_number doesn't need to be set because it only increments on
commit. This needs to be reset to indicate a commit/sync happened. the
source_frame_number changing indicates this already.

[enne (OOO), 2013/01/25 18:51:26]

You're right that this is called on the pending tree's layer and layer_impl is
the active layer.

Just to walk through the logic, if you activate a tree of source frame 7, the
values on the active layer are going to be last_impl_frame_number_=0,
last_source_frame_number_=6.  activeTree()->source_frame_number() will be 7. 
This active layer will then update tile priorities on draw because the source
frame numbers are different?

[danakj, 2013/01/25 18:56:30]

The goal is that when you activate the tree, it won't update priorities on the
first draw, because it already has priorities from the pending tree. That was
what we had planned yesterday at least.

I didn't think that the source_frame_number would change but you're right. So
I'll make it only use the source_frame_number on the pending tree. Active tree
will make its decision only on the impl_frame_number.

[enne (OOO), 2013/01/25 19:00:26]

I think if you just sync the last source frame number over during activation
pushPropertiesTo, then it would work as desired.

(You might even be able to just sync the impl frame number as well and drop the
special 0 case?)

[danakj, 2013/01/25 20:45:25]

Yes, I agree. Good observation. Special case is gone.

   pile_ = PicturePileImpl::Create();
   pile_->set_slow_down_raster_scale_factor(
       layerTreeImpl()->debug_state().slowDownRasterScaleFactor);
 }
 
 
 void PictureLayerImpl::appendQuads(QuadSink& quadSink,
                                    AppendQuadsData& appendQuadsData) {
   const gfx::Rect& rect = visibleContentRect();
   gfx::Rect content_rect(gfx::Point(), contentBounds());
@@ skipping 107 matching lines @@
   // During a pinch, a user could zoom in and out, so throwing away a tiling may
   // be premature.
   if (!layerTreeImpl()->PinchGestureActive())
     CleanUpUnusedTilings(seen_tilings);
 }
 
 void PictureLayerImpl::dumpLayerProperties(std::string*, int indent) const {
   // TODO(enne): implement me
 }
 
-void PictureLayerImpl::didUpdateTransforms() {
+void PictureLayerImpl::updateTilePriorities() {
+  int current_source_frame_number = layerTreeImpl()->source_frame_number();
+  bool first_update_in_new_source_frame =
+      current_source_frame_number != last_source_frame_number_;
+
+  int current_impl_frame_number =
+      layerTreeImpl()->frame_rate_counter()->currentFrameNumber();

[enne (OOO), 2013/01/25 18:17:52]

Can you expose this on LayerTreeImpl like source_frame_number is?

[danakj, 2013/01/25 18:25:47]

Yep.

+  bool first_frame_in_new_impl_tree =
+      last_impl_frame_number_ == 0 ||
+      current_impl_frame_number == last_impl_frame_number_;
+
+  // In pending tree, this is always called. We update priorities:
+  // - Immediately after a commit (first_update_in_new_source_frame).
+  // - On animation ticks after the first frame in the tree.
+  // In active tree, this is only called during draw. We update priorities:

[enne (OOO), 2013/01/25 18:17:52]

How is ensureRSLL handled?

[danakj, 2013/01/25 18:25:47]

ensureRSLL calls UDP(ACTIVE_TREE) which does not do tile prioritization.

UDP(ACTIVE_TREE_FOR_DRAW) does do tile prioritization. So, we don't get here as
claimed on 214.

[enne (OOO), 2013/01/25 18:51:26]

Aha, thanks.

+  // - On draws after the first frame in the tree.
+  if (first_frame_in_new_impl_tree && !first_update_in_new_source_frame)
+    return;
+
   gfx::Transform current_screen_space_transform =
       screenSpaceTransform();
   double current_time =
       (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
   double time_delta = 0;
   if (last_update_time_ != 0 && last_bounds_ == bounds() &&
       last_content_bounds_ == contentBounds() &&
       last_content_scale_ == contentsScaleX()) {
     time_delta = current_time - last_update_time_;
   }
   WhichTree tree = layerTreeImpl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
   tilings_->UpdateTilePriorities(
       tree,
       layerTreeImpl()->device_viewport_size(),
       last_content_scale_,
       contentsScaleX(),
       last_screen_space_transform_,
       current_screen_space_transform,
       time_delta);
 
+  last_source_frame_number_ = current_source_frame_number;
+  last_impl_frame_number_ = current_impl_frame_number;
   last_screen_space_transform_ = current_screen_space_transform;
   last_update_time_ = current_time;
   last_bounds_ = bounds();
   last_content_bounds_ = contentBounds();
   last_content_scale_ = contentsScaleX();
 }
 
 void PictureLayerImpl::didBecomeActive() {
   LayerImpl::didBecomeActive();
   tilings_->DidBecomeActive();
@@ skipping 298 matching lines @@
     if (std::find(used_tilings.begin(), used_tilings.end(), tiling) ==
         used_tilings.end())
       to_remove.push_back(tiling);
   }
 
   for (size_t i = 0; i < to_remove.size(); ++i)
     tilings_->Remove(to_remove[i]);
 }
 
 }  // namespace cc