implement the logic to set tile priorities based on current matrix

cc/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/picture_layer_tiling.h"
+
+#include "cc/math_util.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
     float contents_scale,
     gfx::Size tile_size) {
   return make_scoped_ptr(new PictureLayerTiling(contents_scale, tile_size));
 }
@@ skipping 243 matching lines @@
   DCHECK_LE(texture_rect.right(), texture_size().width());
   DCHECK_LE(texture_rect.bottom(), texture_size().height());
 
   return texture_rect;
 }
 
 gfx::Size PictureLayerTiling::Iterator::texture_size() const {
   return tiling_->tiling_data_.max_texture_size();
 }
 
+void PictureLayerTiling::UpdateTilePriorities(
+    const gfx::Size& view_port,
+    float layer_content_scaleX,
+    float layer_content_scaleY,
+    const gfx::Transform& last_screen_transform,
+    const gfx::Transform& current_screen_transform,
+    double time_delta) {
+  gfx::Rect countent_rect = ContentRect();

[enne (OOO), 2012/12/03 19:57:28]

countent => content

[qinmin, 2012/12/04 00:37:30]

Done.

+  if (countent_rect.IsEmpty())
+    return;
+
+  gfx::Rect view_rect(gfx::Point(), view_port);
+  int right = tiling_data_.TileXIndexFromSrcCoord(countent_rect.width() - 1);
+  int bottom = tiling_data_.TileYIndexFromSrcCoord(countent_rect.height() - 1);
+  for (int j = 0; j <= bottom; ++j) {

[enne (OOO), 2012/12/03 19:57:28]

For correctness, do you need to iterate over all tiles here rather than just the
visible ones? Won't previous tiles that have been marked as
distance_to_visible=0 but have now moved off screen have a stale priority?

[qinmin, 2012/12/04 00:37:30]

Done. looping throught the whole hash map to set priorities of all tiles.

+    for (int i = 0; i <= right; ++i) {
+      gfx::Rect content_rect = tiling_data_.TileBounds(i, j);

[enne (OOO), 2012/12/03 19:57:28]

I think your math is wrong here for layer content scales != 1.  Can you add a
test where this is the case?

TileBounds is a tile's bounds within some tiling's particular scale.  If you
want to use screen transform, then you need to also transform to the layer's
scale.  See the dest_to_content_scale_ math elsewhere in PictureLayerTiling.

[enne (OOO), 2012/12/03 22:08:54]

Actually, scratch that.  I think your math is right.  You are converting from
tiling content scale to layer content scale.

+      gfx::RectF layer_content_rect = gfx::ScaleRect(
+          content_rect,
+          layer_content_scaleX / contents_scale_,
+          layer_content_scaleY / contents_scale_);
+      gfx::RectF screen_rect = MathUtil::mapClippedRect(
+          current_screen_transform, layer_content_rect);
+      gfx::RectF previous_rect = MathUtil::mapClippedRect(
+          last_screen_transform, layer_content_rect);
+
+      TilePriority priority;
+      priority.resolution = HIGH_RESOLUTION;
+      priority.time_to_visible_in_seconds =
+          TilePriority::TimeForBoundsToIntersect(
+              previous_rect, screen_rect, time_delta, view_rect);

[enne (OOO), 2012/12/03 19:57:28]

Oh, interesting!  So rather than caring about all of the clips along the way,
you just look at where the screen space is and how quickly something is moving
to get into the screen space rect.  I suppose on complicated pages this is
wrong, but it seems like it should solve the use cases we care about.  This
seems like a good start.

[qinmin, 2012/12/04 00:37:30]

Yes, this is an efficient way to deal with the scaling/scrolling case. For other
transformations, this might not work well.

On 2012/12/03 19:57:28, enne wrote:

+
+      priority.distance_to_visible_in_pixels =
+          TilePriority::manhattanDistance(screen_rect, view_rect);
+      // TODO(qinmin): pass the correct tree to this function.
+      TileAt(i, j)->set_priority(ACTIVE_TREE, priority);
+    }
+  }
+}
+
 }  // namespace cc