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();
+  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) {
+    for (int i = 0; i <= right; ++i) {
+      gfx::Rect content_rect = tiling_data_.TileBounds(i, j);
+      gfx::Rect layer_content_rect = gfx::ToEnclosingRect(

[danakj, 2012/12/01 01:20:19]

Why go to a Rect and take the enclosing rect here? Seems like you could just
keep it as a RectF and not have to do rounding.

[qinmin, 2012/12/01 01:36:44]

if we keep it rectF, then the following calculations will also needs to be
rectF. 
But using rectF doesn't add too much value to calculate the visible_in_seconds
and distance_to_visible_in_seconds. These values should just be a rough
estimation, especially since we are using manhattan instead of euclidean
distance, and velocity calculation does not take friction into consideration.

On 2012/12/01 01:20:19, danakj wrote:

[danakj, 2012/12/01 01:58:25]

The mapRect function is going to convert it to float at each step anyways. And
then you just lost precision, I don't see the advantange. I'd only go back to
ints if it's going to add precision. Otherwise keep it all floats as long as you
can.

[qinmin, 2012/12/01 02:31:20]

ok, switched to rectF for all the remaining calculations

On 2012/12/01 01:58:25, danakj wrote:

+          gfx::ScaleRect(content_rect,
+                         layer_content_scaleX / contents_scale_,
+                         layer_content_scaleY / contents_scale_));
+      gfx::Rect screen_rect = MathUtil::mapClippedRect(
+          current_screen_transform, layer_content_rect);
+      gfx::Rect 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);
+
+      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