cpplint.py pass on cc/(base|debug|quads|resources)/

cc/resources/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/resources/tile_priority.h"
 
 #include "base/values.h"
 #include "cc/base/math_util.h"
 
 namespace {
@@ skipping 12 matching lines @@
 }
 
 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,
+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);
+    out->start_ = std::max(out->start_, t);
   else
-    out.end_ = std::min(out.end_, t);
+    out->end_ = std::min(out->end_, t);
 }
 
-inline void IntersectPositiveHalfplane(Range& out, float previous,
+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);
+    out->start_ = std::max(out->start_, t);
   else
-    out.end_ = std::min(out.end_, t);
+    out->end_ = std::min(out->end_, t);
 }
 
 }  // namespace
 
 namespace cc {
 
 const float TilePriority::kMaxDistanceInContentSpace = 4096.0f;
 
 // At 256x256 tiles, 128 tiles cover an area of 2048x4096 pixels.
 const int64 TilePriority::
@@ skipping 64 matching lines @@
     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(),
+      &range, previous_bounds.x(), current_bounds.x(),
       target_bounds.right(), time_delta);
   IntersectNegativeHalfplane(
-      range, previous_bounds.right(), current_bounds.right(),
+      &range, previous_bounds.right(), current_bounds.right(),
       target_bounds.x(), time_delta);
   IntersectPositiveHalfplane(
-      range, previous_bounds.y(), current_bounds.y(),
+      &range, previous_bounds.y(), current_bounds.y(),
       target_bounds.bottom(), time_delta);
   IntersectNegativeHalfplane(
-      range, previous_bounds.bottom(), current_bounds.bottom(),
+      &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"));
@@ skipping 34 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