A host of micro-optimizations and a refactor of TimeForBoundsToIntersect

cc/tile_priority.cc

Index: cc/tile_priority.cc
diff --git a/cc/tile_priority.cc b/cc/tile_priority.cc
index 5fcf4f21c8aa71f91caaae62e9bad31a08d9ceab..190c8f4608f2b79564b573eb48bcc6891fb87549 100644
--- a/cc/tile_priority.cc
+++ b/cc/tile_priority.cc
@@ -11,84 +11,63 @@ 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);
+  Range(float start, float end) : start_(start), end_(end) {}
   bool IsEmpty();
-  double start_;
-  double end_;
+  float start_;
+  float end_;
 };
 
-Range Range::Intersects(const Range& other) {
-  start_ = std::max(start_, other.start_);
-  end_ = std::min(end_, other.end_);
-  return Range(start_, end_);
+inline bool Intersects(const Range& a, const Range& b) {
+  return a.start_ < b.end_ && b.start_ < a.end_;
+}
+
+inline Range Intersect(const Range& a, const Range& b) {
+  return Range(std::max(a.start_, b.start_), std::min(a.end_, b.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);
-  }
+inline void IntersectNegativeHalfplane(Range& out, float previous,
+    float current, float target, float time_delta) {
+  float time_per_dist = time_delta / (current - previous);
+  float t = (target - current) * time_per_dist;
+  if (time_per_dist > 0.0f)
+    out.start_ = std::max(out.start_, t);
+  else
+    out.end_ = std::min(out.end_, t);
+}
 
-  return Range(minimum_time, maximum_time);
+inline void IntersectPositiveHalfplane(Range& out, float previous,
+    float current, float target, float time_delta) {
+  float time_per_dist = time_delta / (current - previous);
+  float t = (target - current) * time_per_dist;
+  if (time_per_dist < 0.0f)
+    out.start_ = std::max(out.start_, t);
+  else
+    out.end_ = std::min(out.end_, t);
 }
 
 }  // namespace
 
 namespace cc {
 
-const double TilePriority::kMaxTimeToVisibleInSeconds = 1000;
-
-scoped_ptr<base::Value> WhichTreeAsValue(WhichTree tree) {
-  switch (tree) {
-  case ACTIVE_TREE:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
-          "ACTIVE_TREE"));
-  case PENDING_TREE:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
-          "PENDING_TREE"));
-  default:
-      DCHECK(false) << "Unrecognized WhichTree value";
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
-          "<unknown WhichTree value>"));
-  }
-}
-
-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)
+const float TilePriority::kMaxTimeToVisibleInSeconds =
+    std::numeric_limits<float>::infinity();
+
+float TilePriority::TimeForBoundsToIntersect(const gfx::RectF& previous_bounds,
+                                             const gfx::RectF& current_bounds,
+                                             float time_delta,
+                                             const gfx::RectF& target_bounds) {
+  // Perform an intersection test explicitly between current and target.
+  if (current_bounds.x() < target_bounds.right() &&
+      current_bounds.y() < target_bounds.bottom() &&
+      target_bounds.x() < current_bounds.right() &&
+      target_bounds.y() < current_bounds.bottom())
+    return 0.0f;
+
+  if (time_delta == 0.0f)
     return kMaxTimeToVisibleInSeconds;
 
   // As we are trying to solve the case of both scaling and scrolling, using
@@ -97,24 +76,19 @@ double TilePriority::TimeForBoundsToIntersect(gfx::RectF previous_bounds,
   // 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));
-
+  Range range(0.0f, kMaxTimeToVisibleInSeconds);
+  IntersectPositiveHalfplane(
+      range, previous_bounds.x(), current_bounds.x(),
+      target_bounds.right(), time_delta);
+  IntersectNegativeHalfplane(
+      range, previous_bounds.right(), current_bounds.right(),
+      target_bounds.x(), time_delta);
+  IntersectPositiveHalfplane(
+      range, previous_bounds.y(), current_bounds.y(),
+      target_bounds.bottom(), time_delta);
+  IntersectNegativeHalfplane(
+      range, previous_bounds.bottom(), current_bounds.bottom(),
+      target_bounds.y(), time_delta);
   return range.IsEmpty() ? kMaxTimeToVisibleInSeconds : range.start_;
 }