| // 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/resources/tile_priority.h" |
| |
| #include "base/values.h" |
| #include "cc/base/math_util.h" |
| |
| namespace { |
| |
| // TODO(qinmin): modify ui/range/Range.h to support template so that we |
| // don't need to define this. |
| struct Range { |
| Range(float start, float end) : start_(start), end_(end) {} |
| bool IsEmpty(); |
| float start_; |
| float 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_; |
| } |
| |
| 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); |
| } |
| |
| 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 { |
| |
| 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 " << tree; |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "<unknown WhichTree value>")); |
| } |
| } |
| |
| scoped_ptr<base::Value> TileResolutionAsValue( |
| TileResolution resolution) { |
| switch (resolution) { |
| case LOW_RESOLUTION: |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "LOW_RESOLUTION")); |
| case HIGH_RESOLUTION: |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "HIGH_RESOLUTION")); |
| case NON_IDEAL_RESOLUTION: |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "NON_IDEAL_RESOLUTION")); |
| default: |
| DCHECK(false) << "Unrecognized TileResolution value " << resolution; |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "<unknown TileResolution value>")); |
| } |
| } |
| |
| scoped_ptr<base::Value> TilePriority::AsValue() const { |
| scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue()); |
| state->Set("resolution", TileResolutionAsValue(resolution).release()); |
| state->Set("time_to_visible_in_seconds", |
| MathUtil::AsValueSafely(time_to_visible_in_seconds).release()); |
| state->Set("distance_to_visible_in_pixels", |
| MathUtil::AsValueSafely(distance_to_visible_in_pixels).release()); |
| return state.PassAs<base::Value>(); |
| } |
| |
| 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; |
| |
| 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. |
| 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: |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "ALLOW_ABSOLUTE_MINIMUM")); |
| case ALLOW_PREPAINT_ONLY: |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "ALLOW_PREPAINT_ONLY")); |
| case ALLOW_ANYTHING: |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "ALLOW_ANYTHING")); |
| default: |
| DCHECK(false) << "Unrecognized policy value"; |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "<unknown>")); |
| } |
| } |
| |
| scoped_ptr<base::Value> TreePriorityAsValue(TreePriority prio) { |
| switch (prio) { |
| case SAME_PRIORITY_FOR_BOTH_TREES: |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "SAME_PRIORITY_FOR_BOTH_TREES")); |
| case SMOOTHNESS_TAKES_PRIORITY: |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "SMOOTHNESS_TAKES_PRIORITY")); |
| case NEW_CONTENT_TAKES_PRIORITY: |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "NEW_CONTENT_TAKES_PRIORITY")); |
| default: |
| DCHECK(false) << "Unrecognized priority value " << prio; |
| return scoped_ptr<base::Value>(base::Value::CreateStringValue( |
| "<unknown>")); |
| } |
| } |
| |
| 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->SetInteger("unused_memory_limit_in_bytes", |
| unused_memory_limit_in_bytes); |
| state->SetInteger("num_resources_limit", num_resources_limit); |
| state->Set("tree_priority", TreePriorityAsValue(tree_priority).release()); |
| return state.PassAs<base::Value>(); |
| } |
| |
| } // namespace cc |