Remove globalSVGPath* from SVGPathUtilities.cpp

Source/core/svg/SVGPathByteStreamBuilder.cpp

 /*
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * 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
@@ skipping 11 matching lines @@
 #include "core/svg/SVGPathByteStreamBuilder.h"
 
 #include "core/svg/SVGPathSeg.h"
 #include "wtf/OwnPtr.h"
 
 namespace blink {
 
 // Helper class that coalesces writes to a SVGPathByteStream to a local buffer.
 class CoalescingBuffer {
 public:
-    CoalescingBuffer(SVGPathByteStream* byteStream)
+    CoalescingBuffer(SVGPathByteStream& byteStream)
         : m_currentOffset(0)
         , m_byteStream(byteStream)
     {
-        ASSERT(byteStream);
     }
     ~CoalescingBuffer()
     {
         for (size_t i = 0; i < m_currentOffset; ++i)
-            m_byteStream->append(m_bytes[i]);
+            m_byteStream.append(m_bytes[i]);
     }
 
     template<typename DataType>
     void writeType(DataType value)
     {
         ByteType<DataType> data;
         data.value = value;
         size_t typeSize = sizeof(ByteType<DataType>);
         ASSERT(m_currentOffset + typeSize <= sizeof(m_bytes));
         memcpy(m_bytes + m_currentOffset, data.bytes, typeSize);
         m_currentOffset += typeSize;
     }
 
     void writeFlag(bool value) { writeType<bool>(value); }
     void writeFloat(float value) { writeType<float>(value); }
     void writeFloatPoint(const FloatPoint& point)
     {
         writeType<float>(point.x());
         writeType<float>(point.y());
     }
     void writeSegmentType(unsigned short value) { writeType<unsigned short>(value); }
 
 private:
     // Adjust size to fit the largest command (in serialized/byte-stream format).
     // Currently a cubic segment.
     size_t m_currentOffset;
     unsigned char m_bytes[sizeof(unsigned short) + sizeof(FloatPoint) * 3];
-    SVGPathByteStream* m_byteStream;
+    SVGPathByteStream& m_byteStream;
 };
 
-SVGPathByteStreamBuilder::SVGPathByteStreamBuilder()
-    : m_byteStream(0)
+SVGPathByteStreamBuilder::SVGPathByteStreamBuilder(SVGPathByteStream& byteStream)
+    : m_byteStream(byteStream)
 {
 }
 
 void SVGPathByteStreamBuilder::moveTo(const FloatPoint& targetPoint, bool, PathCoordinateMode mode)
 {
     CoalescingBuffer buffer(m_byteStream);
     buffer.writeSegmentType(mode == RelativeCoordinates ?  PathSegMoveToRel : PathSegMoveToAbs);
     buffer.writeFloatPoint(targetPoint);
 }
 
@@ skipping 62 matching lines @@
     buffer.writeFloatPoint(targetPoint);
 }
 
 void SVGPathByteStreamBuilder::closePath()
 {
     CoalescingBuffer buffer(m_byteStream);
     buffer.writeSegmentType(PathSegClosePath);
 }
 
 } // namespace blink