cc: Convert non-const reference arguments to pointers.

cc/base/math_util.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/base/math_util.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 117 matching lines @@
                                               float* ymax,
                                               gfx::PointF p) {
   *xmin = std::min(p.x(), *xmin);
   *xmax = std::max(p.x(), *xmax);
   *ymin = std::min(p.y(), *ymin);
   *ymax = std::max(p.y(), *ymax);
 }
 
 static inline void AddVertexToClippedQuad(gfx::PointF new_vertex,
                                           gfx::PointF clipped_quad[8],
-                                          int& num_vertices_in_clipped_quad) {
-  clipped_quad[num_vertices_in_clipped_quad] = new_vertex;
-  num_vertices_in_clipped_quad++;
+                                          int* num_vertices_in_clipped_quad) {
+  clipped_quad[*num_vertices_in_clipped_quad] = new_vertex;
+  (*num_vertices_in_clipped_quad)++;
 }
 
 gfx::Rect MathUtil::MapClippedRect(const gfx::Transform& transform,
                                    gfx::Rect src_rect) {
   return gfx::ToEnclosingRect(MapClippedRect(transform, gfx::RectF(src_rect)));
 }
 
 gfx::RectF MathUtil::MapClippedRect(const gfx::Transform& transform,
                                     const gfx::RectF& src_rect) {
   if (transform.IsIdentityOrTranslation())
@@ skipping 39 matching lines @@
   HomogeneousCoordinate h2 = ProjectHomogeneousPoint(transform, q.p2());
   HomogeneousCoordinate h3 = ProjectHomogeneousPoint(transform, q.p3());
   HomogeneousCoordinate h4 = ProjectHomogeneousPoint(transform, q.p4());
 
   return ComputeEnclosingClippedRect(h1, h2, h3, h4);
 }
 
 void MathUtil::MapClippedQuad(const gfx::Transform& transform,
                               const gfx::QuadF& src_quad,
                               gfx::PointF clipped_quad[8],
-                              int& num_vertices_in_clipped_quad) {
+                              int* num_vertices_in_clipped_quad) {
   HomogeneousCoordinate h1 =
       MapHomogeneousPoint(transform, gfx::Point3F(src_quad.p1()));
   HomogeneousCoordinate h2 =
       MapHomogeneousPoint(transform, gfx::Point3F(src_quad.p2()));
   HomogeneousCoordinate h3 =
       MapHomogeneousPoint(transform, gfx::Point3F(src_quad.p3()));
   HomogeneousCoordinate h4 =
       MapHomogeneousPoint(transform, gfx::Point3F(src_quad.p4()));
 
   // The order of adding the vertices to the array is chosen so that
   // clockwise / counter-clockwise orientation is retained.
 
-  num_vertices_in_clipped_quad = 0;
+  *num_vertices_in_clipped_quad = 0;
 
   if (!h1.ShouldBeClipped()) {
     AddVertexToClippedQuad(
         h1.CartesianPoint2d(), clipped_quad, num_vertices_in_clipped_quad);
   }
 
   if (h1.ShouldBeClipped() ^ h2.ShouldBeClipped()) {
     AddVertexToClippedQuad(
         ComputeClippedPointForEdge(h1, h2).CartesianPoint2d(),
         clipped_quad,
@@ skipping 29 matching lines @@
         h4.CartesianPoint2d(), clipped_quad, num_vertices_in_clipped_quad);
   }
 
   if (h4.ShouldBeClipped() ^ h1.ShouldBeClipped()) {
     AddVertexToClippedQuad(
         ComputeClippedPointForEdge(h4, h1).CartesianPoint2d(),
         clipped_quad,
         num_vertices_in_clipped_quad);
   }
 
-  DCHECK_LE(num_vertices_in_clipped_quad, 8);
+  DCHECK_LE(*num_vertices_in_clipped_quad, 8);
 }
 
 gfx::RectF MathUtil::ComputeEnclosingRectOfVertices(gfx::PointF vertices[],
                                                     int num_vertices) {
   if (num_vertices < 2)
     return gfx::RectF();
 
   float xmin = std::numeric_limits<float>::max();
   float xmax = -std::numeric_limits<float>::max();
   float ymin = std::numeric_limits<float>::max();
@@ skipping 272 matching lines @@
   return scoped_ptr<base::Value>(base::Value::CreateDoubleValue(
       std::min(value, std::numeric_limits<double>::max())));
 }
 
 scoped_ptr<base::Value> MathUtil::AsValueSafely(float value) {
   return scoped_ptr<base::Value>(base::Value::CreateDoubleValue(
       std::min(value, std::numeric_limits<float>::max())));
 }
 
 }  // namespace cc