Remove more unnamed namespace usages.

experimental/StrokePathRenderer/GrStrokePathRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrStrokePathRenderer.h"
 
 #include "GrDrawTarget.h"
 #include "SkPath.h"
 #include "SkStrokeRec.h"
 
-namespace {
-
-bool is_clockwise(const SkVector& before, const SkVector& after) {
+static bool is_clockwise(const SkVector& before, const SkVector& after) {
     return before.cross(after) > 0;
 }
 
 enum IntersectionType {
     kNone_IntersectionType,
     kIn_IntersectionType,
     kOut_IntersectionType
 };
 
-IntersectionType intersection(const SkPoint& p1, const SkPoint& p2,
-                              const SkPoint& p3, const SkPoint& p4,
-                                    SkPoint& res) {
+static IntersectionType intersection(const SkPoint& p1, const SkPoint& p2,
+                                     const SkPoint& p3, const SkPoint& p4,
+                                     SkPoint& res) {
     // Store the values for fast access and easy
     // equations-to-code conversion
     SkScalar x1 = p1.x(), x2 = p2.x(), x3 = p3.x(), x4 = p4.x();
     SkScalar y1 = p1.y(), y2 = p2.y(), y3 = p3.y(), y4 = p4.y();
 
     SkScalar d = SkScalarMul(x1 - x2, y3 - y4) - SkScalarMul(y1 - y2, x3 - x4);
     // If d is zero, there is no intersection
     if (SkScalarNearlyZero(d)) {
         return kNone_IntersectionType;
     }
 
     // Get the x and y
     SkScalar pre  = SkScalarMul(x1, y2) - SkScalarMul(y1, x2),
              post = SkScalarMul(x3, y4) - SkScalarMul(y3, x4);
     // Compute the point of intersection
     res.set(SkScalarDiv(SkScalarMul(pre, x3 - x4) - SkScalarMul(x1 - x2, post), d),
             SkScalarDiv(SkScalarMul(pre, y3 - y4) - SkScalarMul(y1 - y2, post), d));
 
     // Check if the x and y coordinates are within both lines
     return (res.x() < GrMin(x1, x2) || res.x() > GrMax(x1, x2) ||
             res.x() < GrMin(x3, x4) || res.x() > GrMax(x3, x4) ||
             res.y() < GrMin(y1, y2) || res.y() > GrMax(y1, y2) ||
             res.y() < GrMin(y3, y4) || res.y() > GrMax(y3, y4)) ?
             kOut_IntersectionType : kIn_IntersectionType;
 }
 
-} // namespace
-
 GrStrokePathRenderer::GrStrokePathRenderer() {
 }
 
 bool GrStrokePathRenderer::canDrawPath(const SkPath& path,
                                        const SkStrokeRec& stroke,
                                        const GrDrawTarget* target,
                                        bool antiAlias) const {
     // FIXME : put the proper condition once GrDrawTarget::isOpaque is implemented
     const bool isOpaque = true; // target->isOpaque();
 
@@ skipping 228 matching lines @@
     if (vCount > 0) {
         target->drawIndexed(kTriangles_GrPrimitiveType,
                             0,        // start vertex
                             0,        // start index
                             vCount,
                             iCount);
     }
 
     return true;
 }