Remove unnecessary static function

cc/trees/layer_sorter.cc

 // Copyright 2011 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/trees/layer_sorter.h"
 
 #include <algorithm>
 #include <deque>
 #include <limits>
 #include <vector>
 
 #include "base/logging.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/render_surface_impl.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 // This epsilon is used to determine if two layers are too close to each other
 // to be able to tell which is in front of the other.  It's a relative epsilon
 // so it is robust to changes in scene scale.  This value was chosen by picking
 // a value near machine epsilon and then increasing it until the flickering on
 // the test scene went away.
 const float k_layer_epsilon = 1e-4f;
 
-inline static float PerpProduct(const gfx::Vector2dF& u,
-                                const gfx::Vector2dF& v) {
-  return u.x() * v.y() - u.y() * v.x();
-}
-
 // Tests if two edges defined by their endpoints (a,b) and (c,d) intersect.
 // Returns true and the point of intersection if they do and false otherwise.
 static bool EdgeEdgeTest(const gfx::PointF& a,
                          const gfx::PointF& b,
                          const gfx::PointF& c,
                          const gfx::PointF& d,
                          gfx::PointF* r) {
   gfx::Vector2dF u = b - a;
   gfx::Vector2dF v = d - c;
   gfx::Vector2dF w = a - c;
 
-  float denom = PerpProduct(u, v);
+  float denom = gfx::CrossProduct(u, v);

[danakj, 2014/08/06 13:45:55]

this method returns a double, so you'll get narrowing errors storing it directly
into a float. you'll have to cast it.

[hj.r.chung, 2014/08/07 01:55:12]

While looking into the code, I've found that there aren't any other callers for
CrossProduct(Vector2dF&, Vector2dF&). Do you think it will be ok to change
CrossProduct() to return float instead of double? Will there be any cases that
need double precision in the future?

 
   // If denom == 0 then the edges are parallel. While they could be overlapping
   // we don't bother to check here as the we'll find their intersections from
   // the corner to quad tests.
   if (!denom)
     return false;
 
-  float s = PerpProduct(v, w) / denom;
+  float s = gfx::CrossProduct(v, w) / denom;
   if (s < 0.f || s > 1.f)
     return false;
 
-  float t = PerpProduct(u, w) / denom;
+  float t = gfx::CrossProduct(u, w) / denom;
   if (t < 0.f || t > 1.f)
     return false;
 
   u.Scale(s);
   *r = a + u;
   return true;
 }
 
 GraphNode::GraphNode(LayerImpl* layer_impl)
     : layer(layer_impl),
@@ skipping 396 matching lines @@
     *it = sorted_list[count++]->layer;
 
   DVLOG(2) << "Sorting end ----";
 
   nodes_.clear();
   edges_.clear();
   active_edges_.clear();
 }
 
 }  // namespace cc