A host of micro-optimizations and a refactor of TimeForBoundsToIntersect

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"
 
 #include "base/values.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);
+  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;
+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);
+}
 
-  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);
+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.0;
-const double TilePriority::kMaxDistanceInContentSpace = 4096.0;
+const float TilePriority::kMaxDistanceInContentSpace = 4096.0f;
 
 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;
+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 (previous_bounds.Intersects(target_bounds) || time_delta == 0)
+  const float kMaxTimeToVisibleInSeconds =
+      std::numeric_limits<float>::infinity();
+
+  if (time_delta == 0.0f)
     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));
-
+  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_;
 }
 
 scoped_ptr<base::Value> TileMemoryLimitPolicyAsValue(
     TileMemoryLimitPolicy policy) {
   switch (policy) {
   case ALLOW_NOTHING:
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "ALLOW_NOTHING"));
   case ALLOW_ABSOLUTE_MINIMUM:
@@ skipping 33 matching lines @@
 scoped_ptr<base::Value> GlobalStateThatImpactsTilePriority::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->Set("memory_limit_policy", TileMemoryLimitPolicyAsValue(memory_limit_policy).release());
   state->SetInteger("memory_limit_in_bytes", memory_limit_in_bytes);
   state->Set("tree_priority", TreePriorityAsValue(tree_priority).release());
   return state.PassAs<base::Value>();
 }
 
 
 }  // namespace cc