Move PathTraversalState.cpp/.h to platform/

Source/platform/graphics/PathTraversalState.cpp

 /*
  * Copyright (C) 2006, 2007 Eric Seidel <eric@webkit.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
-#include "core/platform/graphics/PathTraversalState.h"
+#include "platform/graphics/PathTraversalState.h"
 
 #include "wtf/MathExtras.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 static const float kPathSegmentLengthTolerance = 0.00001f;
 
 static inline FloatPoint midPoint(const FloatPoint& first, const FloatPoint& second)
 {
@@ skipping 71 matching lines @@
 
     FloatPoint start;
     FloatPoint control1;
     FloatPoint control2;
     FloatPoint end;
 };
 
 // FIXME: This function is possibly very slow due to the ifs required for proper path measuring
 // A simple speed-up would be to use an additional boolean template parameter to control whether
 // to use the "fast" version of this function with no PathTraversalState updating, vs. the slow
-// version which does update the PathTraversalState.  We'll have to shark it to see if that's necessary.
+// version which does update the PathTraversalState. We'll have to shark it to see if that's necessary.
 // Another check which is possible up-front (to send us down the fast path) would be to check if
 // approximateDistance() + current total distance > desired distance
 template<class CurveType>
 static float curveLength(PathTraversalState& traversalState, CurveType curve)
 {
     static const unsigned curveStackDepthLimit = 20;
 
     Vector<CurveType> curveStack;
     curveStack.append(curve);
 
     float totalLength = 0;
     do {
         float length = curve.approximateDistance();
         if ((length - distanceLine(curve.start, curve.end)) > kPathSegmentLengthTolerance && curveStack.size() <= curveStackDepthLimit) {
             CurveType leftCurve;
             CurveType rightCurve;
             curve.split(leftCurve, rightCurve);
             curve = leftCurve;
             curveStack.append(rightCurve);
         } else {
             totalLength += length;
-            if (traversalState.m_action == PathTraversalState::TraversalPointAtLength
-             || traversalState.m_action == PathTraversalState::TraversalNormalAngleAtLength) {
+            if (traversalState.m_action == PathTraversalState::TraversalPointAtLength || traversalState.m_action == PathTraversalState::TraversalNormalAngleAtLength) {
                 traversalState.m_previous = curve.start;
                 traversalState.m_current = curve.end;
                 if (traversalState.m_totalLength + totalLength > traversalState.m_desiredLength)
                     return totalLength;
             }
             curve = curveStack.last();
             curveStack.removeLast();
         }
     } while (!curveStack.isEmpty());
 
@@ skipping 59 matching lines @@
 void PathTraversalState::processSegment()
 {
     if (m_action == TraversalSegmentAtLength && m_totalLength >= m_desiredLength)
         m_success = true;
 
     if ((m_action == TraversalPointAtLength || m_action == TraversalNormalAngleAtLength) && m_totalLength >= m_desiredLength) {
         float slope = FloatPoint(m_current - m_previous).slopeAngleRadians();
         if (m_action == TraversalPointAtLength) {
             float offset = m_desiredLength - m_totalLength;
             m_current.move(offset * cosf(slope), offset * sinf(slope));
-        } else
+        } else {
             m_normalAngle = rad2deg(slope);
+        }
         m_success = true;
     }
     m_previous = m_current;
 }
 
 }