implement the logic to set tile priorities based on current matrix

cc/picture_layer_tiling.cc

Index: cc/picture_layer_tiling.cc
diff --git a/cc/picture_layer_tiling.cc b/cc/picture_layer_tiling.cc
index 7d3f975bda1c44eda663de9cac9dfd4290d850fd..4c792bf7865e2963812adb87d447739affbd8a2a 100644
--- a/cc/picture_layer_tiling.cc
+++ b/cc/picture_layer_tiling.cc
@@ -3,9 +3,17 @@
 // 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"
 
+#include <algorithm>
+
+namespace {
+const double kMaxTimeToVisibleInSeconds = 1000.0;
+}
+
 namespace cc {
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
@@ -266,4 +274,118 @@ gfx::Size PictureLayerTiling::Iterator::texture_size() const {
   return tiling_->tiling_data_.max_texture_size();
 }
 
+void PictureLayerTiling::UpdateTilePriorities(
+    const gfx::Size& view_port,
+    const gfx::Transform& last_transform,
+    const gfx::Transform& current_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_rect = gfx::ToEnclosingRect(

[epennerAtGoogle, 2012/11/29 22:52:55]

Question for Enne. Is this scale correct in order to use the screen space
transform?

+          gfx::ScaleRect(content_rect, 1 / contents_scale_));
+      gfx::Rect screen_rect = MathUtil::mapClippedRect(

[epennerAtGoogle, 2012/11/29 22:07:50]

I think this might bite us performance-wise if we do this for every tile. Same
goes for using doubles in time-bounds calculation.

However, better to not prematurely optimize so we can wait for it to show up on
a trace.

+          current_transform, layer_rect);

[danakj, 2012/11/29 22:57:30]

What is current_transform? If it's the screen space transform
(current_screenspace_transform?) then you want to give it the content_rect, not
the layer_rect.. unless this isn't the same screenSpaceTransform() found on
other layers.

[epennerAtGoogle, 2012/11/29 23:02:58]

The trouble is there is multiple content scales, so what does content_rect mean
in this context? So we figured screenSpaceTransform for this layer must be for
content_scale = 1.

[qinmin, 2012/11/30 00:35:00]

Ok, passing the content_scale from the layer to this function. I think the
content_scale_ in this class is pretty confusing. Probably call it tiling_scale_
might be better. Anyway, we need to remove the content_scale_ applied to the
content_rect, and then apply the layer content_scale here.

On 2012/11/29 22:57:30, danakj wrote:

+      gfx::Rect previous_rect = MathUtil::mapClippedRect(
+          last_transform, layer_rect);
+
+      TilePriority priority;
+      priority.resolution = HIGH_RESOLUTION;
+      priority.time_to_visible_in_seconds = TimeForBoundsToIntersect(
+          previous_rect, screen_rect, time_delta, view_rect);
+

[epennerAtGoogle, 2012/11/29 22:07:50]

I think for painting we are better off using manhattan distance (x+y) since
tiles show up in rows/columns. We could just copy manhattanDistance(rect,rect)
inside priority_calculator.cc?

[qinmin, 2012/11/29 22:44:17]

I like the idea of manhattan distance, it saves the squareroot operation and
makes more sense for tiling.
Copied it over from priority_calculator.cc as that file might go away.

On 2012/11/29 22:07:50, epennerAtGoogle wrote:

+      int x_offset = 0;
+      if (screen_rect.right() < view_rect.x())
+        x_offset = view_rect.x() - screen_rect.right();
+      else if (screen_rect.x() > view_rect.right())
+        x_offset = screen_rect.x() - view_rect.right();
+
+      int y_offset = 0;
+      if (screen_rect.bottom() < view_rect.y())
+        y_offset = view_rect.y() - screen_rect.bottom();
+      else if (screen_rect.y() > view_rect.bottom())
+        y_offset = screen_rect.y() - view_rect.bottom();
+
+      priority.distance_to_visible_in_pixels =
+          gfx::Vector2dF(x_offset, x_offset).Length();
+      // TODO(qinmin): pass the correct tree to this function.
+      TileAt(i, j)->set_priority(ACTIVE_TREE, priority);
+    }
+  }
+}
+
+double PictureLayerTiling::TimeForBoundsToIntersect(gfx::Rect previous_bounds,

[epennerAtGoogle, 2012/11/29 22:07:50]

This is super clever.

+                                                    gfx::Rect current_bounds,
+                                                    double time_delta,
+                                                    gfx::Rect target_bounds) {
+  if (current_bounds.Intersects(target_bounds))
+    return 0;
+
+  if (previous_bounds.Intersects(target_bounds) || time_delta == 0)
+    return kMaxTimeToVisibleInSeconds;
+
+  // As we are trying to solve the case of both scaling and scrolling, using
+  // a single coordinate with velocity is not enough. The logic here is to
+  // calculate the velocity for each edge. Then we calculate the time range that
+  // each edge will stay on the same side of the target bounds. If there is an
+  // overlap between these time ranges, the bounds must have intersect with

[epennerAtGoogle, 2012/11/29 22:07:50]

I was initially confused by the comment but now I think I get it. Each edge
calculates a one-sided range and then when you intersect them all you get the
the predicted time range of intersection?

It seems like a line/rect intersect would likely be close enough to this. But
then it needs adjustments to be conservative, so if it's not a perf issue I
really like this.

+  // each other during that period of time.
+  double velocity =
+      (current_bounds.right() - previous_bounds.right()) / time_delta;
+  PictureLayerTiling::Range range = TimeRangeValueLargerThanThreshold(
+      current_bounds.right(), target_bounds.x(), velocity);
+
+  velocity = (current_bounds.x() - previous_bounds.x()) / time_delta;
+  range = range.Intersects(TimeRangeValueLargerThanThreshold(
+      -current_bounds.x(), -target_bounds.right(), -velocity));
+
+
+  velocity = (current_bounds.y() - previous_bounds.y()) / time_delta;
+  range = range.Intersects(TimeRangeValueLargerThanThreshold(
+      -current_bounds.y(), -target_bounds.bottom(), -velocity));
+
+  velocity = (current_bounds.bottom() - previous_bounds.bottom()) / time_delta;
+  range = range.Intersects(TimeRangeValueLargerThanThreshold(
+      current_bounds.bottom(), target_bounds.y(), velocity));
+
+  return range.IsEmpty() ? kMaxTimeToVisibleInSeconds : range.start_;
+}
+
+PictureLayerTiling::Range PictureLayerTiling::TimeRangeValueLargerThanThreshold(
+    int value, int threshold, double velocity) {
+  double minimum_time = 0;
+  double maximum_time = kMaxTimeToVisibleInSeconds;
+
+  if (velocity > 0) {
+    if (value < threshold)
+      minimum_time = std::min(kMaxTimeToVisibleInSeconds,
+                              (threshold - value) / velocity);
+  } else if (velocity <= 0) {
+    if (value < threshold)
+      minimum_time = kMaxTimeToVisibleInSeconds;
+    else if (velocity != 0)
+      maximum_time = std::min(maximum_time, (threshold - value) / velocity);
+  }
+
+  return PictureLayerTiling::Range(minimum_time, maximum_time);
+}
+
+PictureLayerTiling::Range PictureLayerTiling::Range::Intersects(
+    const PictureLayerTiling::Range& other) {
+  start_ = std::max(start_, other.start_);
+  end_ = std::min(end_, other.end_);
+  return PictureLayerTiling::Range(start_, end_);
+}
+
+bool PictureLayerTiling::Range::IsEmpty() {
+  return start_ >= end_;
+}
+
 }  // namespace cc