[#4] Pass gfx structs by const ref (gfx::PointF)

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>
 
 #include "base/values.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/rect_f.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/vector2d_f.h"
 
 namespace cc {
 
 const double MathUtil::kPiDouble = 3.14159265358979323846;
 const float MathUtil::kPiFloat = 3.14159265358979323846f;
 
 static HomogeneousCoordinate ProjectHomogeneousPoint(
     const gfx::Transform& transform,
-    gfx::PointF p) {
+    const gfx::PointF& p) {
   // In this case, the layer we are trying to project onto is perpendicular to
   // ray (point p and z-axis direction) that we are trying to project. This
   // happens when the layer is rotated so that it is infinitesimally thin, or
   // when it is co-planar with the camera origin -- i.e. when the layer is
   // invisible anyway.
   if (!transform.matrix().get(2, 2))
     return HomogeneousCoordinate(0.0, 0.0, 0.0, 1.0);
 
   SkMScalar z = -(transform.matrix().get(2, 0) * p.x() +
              transform.matrix().get(2, 1) * p.y() +
@@ skipping 43 matching lines @@
   SkMScalar y = (SK_MScalar1 - t) * h1.y() + t * h2.y();
   SkMScalar z = (SK_MScalar1 - t) * h1.z() + t * h2.z();
 
   return HomogeneousCoordinate(x, y, z, w);
 }
 
 static inline void ExpandBoundsToIncludePoint(float* xmin,
                                               float* xmax,
                                               float* ymin,
                                               float* ymax,
-                                              gfx::PointF p) {
+                                              const 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,
+static inline void AddVertexToClippedQuad(const 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)++;
 }
 
 gfx::Rect MathUtil::MapClippedRect(const gfx::Transform& transform,
                                    const gfx::Rect& src_rect) {
   return gfx::ToEnclosingRect(MapClippedRect(transform, gfx::RectF(src_rect)));
 }
@@ skipping 108 matching lines @@
   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);
 }
 
-gfx::RectF MathUtil::ComputeEnclosingRectOfVertices(gfx::PointF vertices[],
-                                                    int num_vertices) {
+gfx::RectF MathUtil::ComputeEnclosingRectOfVertices(
+    const 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();
   float ymax = -std::numeric_limits<float>::max();
 
   for (int i = 0; i < num_vertices; ++i)
     ExpandBoundsToIncludePoint(&xmin, &xmax, &ymin, &ymax, vertices[i]);
@@ skipping 111 matching lines @@
 
   // Result will be invalid if clipped == true. But, compute it anyway just in
   // case, to emulate existing behavior.
   return gfx::QuadF(h1.CartesianPoint2d(),
                     h2.CartesianPoint2d(),
                     h3.CartesianPoint2d(),
                     h4.CartesianPoint2d());
 }
 
 gfx::PointF MathUtil::MapPoint(const gfx::Transform& transform,
-                               gfx::PointF p,
+                               const gfx::PointF& p,
                                bool* clipped) {
   HomogeneousCoordinate h = MapHomogeneousPoint(transform, gfx::Point3F(p));
 
   if (h.w() > 0) {
     *clipped = false;
     return h.CartesianPoint2d();
   }
 
   // The cartesian coordinates will be invalid after dividing by w.
   *clipped = true;
@@ skipping 44 matching lines @@
   *clipped |= clipped_point;
   projected_quad.set_p3(ProjectPoint(transform, q.p3(), &clipped_point));
   *clipped |= clipped_point;
   projected_quad.set_p4(ProjectPoint(transform, q.p4(), &clipped_point));
   *clipped |= clipped_point;
 
   return projected_quad;
 }
 
 gfx::PointF MathUtil::ProjectPoint(const gfx::Transform& transform,
-                                   gfx::PointF p,
+                                   const gfx::PointF& p,
                                    bool* clipped) {
   HomogeneousCoordinate h = ProjectHomogeneousPoint(transform, p);
 
   if (h.w() > 0) {
     // The cartesian coordinates will be valid in this case.
     *clipped = false;
     return h.CartesianPoint2d();
   }
 
   // The cartesian coordinates will be invalid after dividing by w.
@@ skipping 109 matching lines @@
   ok &= value->GetInteger(1, &y);
   ok &= value->GetInteger(2, &w);
   ok &= value->GetInteger(3, &h);
   if (!ok)
     return false;
 
   *out_rect = gfx::Rect(x, y, w, h);
   return true;
 }
 
-scoped_ptr<base::Value> MathUtil::AsValue(gfx::PointF pt) {
+scoped_ptr<base::Value> MathUtil::AsValue(const gfx::PointF& pt) {
   scoped_ptr<base::ListValue> res(new base::ListValue());
   res->AppendDouble(pt.x());
   res->AppendDouble(pt.y());
   return res.PassAs<base::Value>();
 }
 
 scoped_ptr<base::Value> MathUtil::AsValue(const gfx::QuadF& q) {
   scoped_ptr<base::ListValue> res(new base::ListValue());
   res->AppendDouble(q.p1().x());
   res->AppendDouble(q.p1().y());
@@ skipping 40 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