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

cc/resources/picture_layer_tiling.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/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/debug/trace_event.h"
@@ skipping 14 matching lines @@
                                                 client));
 }
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Clone(
     gfx::Size layer_bounds,
     PictureLayerTilingClient* client) const {
   scoped_ptr<PictureLayerTiling> out =
     make_scoped_ptr(new PictureLayerTiling(contents_scale_,
                                            layer_bounds,
                                            client));
   out->resolution_ = resolution_;

[enne (OOO), 2013/05/02 19:59:46]

Looking at this code closer, but could this lead to multiple hi res tilings?

[danakj, 2013/05/02 20:02:04]

Hmm! It's kinda weird anyway right? You should manage tilings to decide the
resolution.

I'll make another CL to remove this with a test to verify it makes sense.

-  out->last_source_frame_number_ = last_source_frame_number_;
-  out->last_impl_frame_time_ = last_impl_frame_time_;
   return out.Pass();
 }
 
 PictureLayerTiling::PictureLayerTiling(float contents_scale,
                                        gfx::Size layer_bounds,
                                        PictureLayerTilingClient* client)
     : contents_scale_(contents_scale),
       layer_bounds_(layer_bounds),
       resolution_(NON_IDEAL_RESOLUTION),
       client_(client),
       tiling_data_(gfx::Size(), gfx::Size(), true),
-      last_source_frame_number_(0),
-      last_impl_frame_time_(0.0) {
+      last_impl_frame_time_in_seconds_(0.0) {
   gfx::Size content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale));
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
 
   tiling_data_.SetTotalSize(content_bounds);
   tiling_data_.SetMaxTextureSize(tile_size);
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
 }
@@ skipping 227 matching lines @@
     WhichTree tree,
     gfx::Size device_viewport,
     const gfx::RectF& viewport_in_layer_space,
     const gfx::RectF& visible_layer_rect,
     gfx::Size last_layer_bounds,
     gfx::Size current_layer_bounds,
     float last_layer_contents_scale,
     float current_layer_contents_scale,
     const gfx::Transform& last_screen_transform,
     const gfx::Transform& current_screen_transform,
-    int current_source_frame_number,
-    double current_frame_time,
+    double current_frame_time_in_seconds,
     bool store_screen_space_quads_on_tiles,
     size_t max_tiles_for_interest_area) {
   if (ContentRect().IsEmpty())
     return;
+  if (!NeedsUpdateForFrameAtTime(current_frame_time_in_seconds))
+    return;
 
   gfx::Rect viewport_in_content_space =
       gfx::ToEnclosingRect(gfx::ScaleRect(viewport_in_layer_space,
                                           contents_scale_));
   gfx::Rect visible_content_rect =
       gfx::ToEnclosingRect(gfx::ScaleRect(visible_layer_rect,
                                           contents_scale_));
 
   gfx::Size tile_size = tiling_data_.max_texture_size();
   int64 interest_rect_area =
       max_tiles_for_interest_area * tile_size.width() * tile_size.height();
 
   gfx::Rect starting_rect = visible_content_rect.IsEmpty()
                             ? viewport_in_content_space
                             : visible_content_rect;
   gfx::Rect interest_rect = ExpandRectEquallyToAreaBoundedBy(
       starting_rect,
       interest_rect_area,
       ContentRect());
   DCHECK(interest_rect.IsEmpty() ||
          ContentRect().Contains(interest_rect));
 
   SetLiveTilesRect(interest_rect);
 
-  bool first_update_in_new_source_frame =
-      current_source_frame_number != last_source_frame_number_;
-
-  bool first_update_in_new_impl_frame =
-      current_frame_time != last_impl_frame_time_;
-
-  // 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
-  //   (first_update_in_new_impl_frame).
-  // In active tree, this is only called during draw. We update priorities:
-  // - On draw if properties were not already computed by the pending tree
-  //   and activated for the frame (first_update_in_new_impl_frame).
-  if (!first_update_in_new_impl_frame && !first_update_in_new_source_frame)
-    return;
-
-  double time_delta = 0.0;
-  if (last_impl_frame_time_ != 0.0 &&
-      last_layer_bounds == current_layer_bounds)
-    time_delta = current_frame_time - last_impl_frame_time_;
+  double time_delta = 0;
+  if (last_impl_frame_time_in_seconds_ != 0.0 &&
+      last_layer_bounds == current_layer_bounds) {
+    time_delta =
+        current_frame_time_in_seconds - last_impl_frame_time_in_seconds_;
+  }
 
   gfx::Rect view_rect(device_viewport);
   float current_scale = current_layer_contents_scale / contents_scale_;
   float last_scale = last_layer_contents_scale / contents_scale_;
 
   // Fast path tile priority calculation when both transforms are translations.
   if (last_screen_transform.IsIdentityOrTranslation() &&
       current_screen_transform.IsIdentityOrTranslation()) {
     gfx::Vector2dF current_offset(
         current_screen_transform.matrix().get(0, 3),
@@ skipping 72 matching lines @@
           bool clipped;
           priority.set_current_screen_quad(
             MathUtil::MapQuad(current_screen_transform,
                               gfx::QuadF(current_layer_content_rect),
                               &clipped));
       }
       tile->SetPriority(tree, priority);
     }
   }
 
-  last_source_frame_number_ = current_source_frame_number;
-  last_impl_frame_time_ = current_frame_time;
+  last_impl_frame_time_in_seconds_ = current_frame_time_in_seconds;
 }
 
 void PictureLayerTiling::SetLiveTilesRect(
     gfx::Rect new_live_tiles_rect) {
   DCHECK(new_live_tiles_rect.IsEmpty() ||
          ContentRect().Contains(new_live_tiles_rect));
   if (live_tiles_rect_ == new_live_tiles_rect)
     return;
 
   // Iterate to delete all tiles outside of our new live_tiles rect.
@@ skipping 167 matching lines @@
 
     // If our delta is less then our event distance, we're done.
     if (delta < event.distance)
       break;
   }
 
   return gfx::Rect(origin_x, origin_y, width, height);
 }
 
 }  // namespace cc