implement the logic to set tile priorities based on current matrix

cc/tile_priority.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/tile_priority.h"
+
+namespace {
+
+// TODO(qinmin): modify ui/range/Range.h to support template so that we
+// don't need to define this.
+struct Range {
+  Range(double start, double end) : start_(start), end_(end) {}
+  Range Intersects(const Range& other);
+  bool IsEmpty();
+  double start_;
+  double end_;
+};
+
+Range Range::Intersects(const Range& other) {
+  start_ = std::max(start_, other.start_);
+  end_ = std::min(end_, other.end_);
+  return Range(start_, end_);
+}
+
+bool Range::IsEmpty() {
+  return start_ >= end_;
+}
+
+// Calculate a time range that |value| will be larger than |threshold|
+// given the velocity of its change.
+Range TimeRangeValueLargerThanThreshold(
+    int value, int threshold, double velocity) {
+  double minimum_time = 0;
+  double maximum_time = cc::TilePriority::kMaxTimeToVisibleInSeconds;
+
+  if (velocity > 0) {
+    if (value < threshold)
+      minimum_time = std::min(cc::TilePriority::kMaxTimeToVisibleInSeconds,
+                              (threshold - value) / velocity);
+  } else if (velocity <= 0) {
+    if (value < threshold)
+      minimum_time = cc::TilePriority::kMaxTimeToVisibleInSeconds;
+    else if (velocity != 0)
+      maximum_time = std::min(maximum_time, (threshold - value) / velocity);
+  }
+
+  return Range(minimum_time, maximum_time);
+}
+
+}  // namespace
+
+namespace cc {
+
+const double TilePriority::kMaxTimeToVisibleInSeconds = 1000;
+
+int TilePriority::manhattanDistance(const gfx::RectF& a, const gfx::RectF& b) {
+  gfx::RectF c = gfx::UnionRects(a, b);
+  // Rects touching the edge of the screen should not be considered visible.
+  // So we add 1 pixel here to avoid that situation.
+  int x = static_cast<int>(
+      std::max(0.0f, c.width() - a.width() - b.width() + 1));
+  int y = static_cast<int>(
+      std::max(0.0f, c.height() - a.height() - b.height() + 1));
+  return (x + y);
+}
+
+double TilePriority::TimeForBoundsToIntersect(gfx::RectF previous_bounds,
+                                              gfx::RectF current_bounds,
+                                              double time_delta,
+                                              gfx::RectF target_bounds) {
+  if (current_bounds.Intersects(target_bounds))
+    return 0;
+
+  if (previous_bounds.Intersects(target_bounds) || time_delta == 0)

[enne (OOO), 2012/12/04 01:13:27]

Why is it the case that if the previous bounds but not the current bounds
intersect the target bounds that it's kMaxTime?

[qinmin, 2012/12/04 01:39:53]

so if the previous bounds intersect, and the current biounds is not, which means
the bounds is moving away from the target, so we set it to maxTime. This is
always true for scrolling/scaling case, but may not hold for rotation. But since
we have distance, we can use that info in case.


On 2012/12/04 01:13:27, enne wrote:

+    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
+  // each other during that period of time.
+  double velocity =
+      (current_bounds.right() - previous_bounds.right()) / time_delta;
+  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_;
+}
+
+}  // namespace cc