NOT FOR COMMIT: Copying the path command data directly into the path byte stream buffer

third_party/WebKit/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
  * 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/svg/SVGPathByteStreamBuilder.h"
 
 #include "core/svg/SVGPathByteStream.h"
 #include "core/svg/SVGPathData.h"
 #include "platform/geometry/FloatPoint.h"
 
 namespace blink {
 
-// Helper class that coalesces writes to a SVGPathByteStream to a local buffer.
-class CoalescingBuffer {
+namespace {
+
+class StreamBufferHelper {
 public:
-    CoalescingBuffer(SVGPathByteStream& byteStream)
-        : m_currentOffset(0)
-        , m_byteStream(byteStream)
+    StreamBufferHelper(SVGPathByteStream& byteStream, size_t bytesToReserve)
+        : m_buffer(byteStream.appendUninitialized(bytesToReserve))
     {
+#if ENABLE(ASSERT)
+        m_expectedEnd = m_buffer + bytesToReserve;
+#endif
     }
-    ~CoalescingBuffer()
-    {
-        for (size_t i = 0; i < m_currentOffset; ++i)
-            m_byteStream.append(m_bytes[i]);
-    }
+    ~StreamBufferHelper() { ASSERT(m_expectedEnd == m_buffer); }
 
     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;
+        memcpy(m_buffer, data.bytes, typeSize);
+        m_buffer += 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;
+    unsigned char* m_buffer;
+#if ENABLE(ASSERT)
+    const unsigned char* m_expectedEnd;
+#endif
 };
 
+}
+
 SVGPathByteStreamBuilder::SVGPathByteStreamBuilder(SVGPathByteStream& byteStream)
     : m_byteStream(byteStream)
 {
 }
 
+static const unsigned char commandParamLength[] = {
+    0,
+    /* PathSegClosePath */                 0,
+    /* PathSegMoveToAbs */                 sizeof(FloatPoint),
+    /* PathSegMoveToRel */                 sizeof(FloatPoint),
+    /* PathSegLineToAbs */                 sizeof(FloatPoint),
+    /* PathSegLineToRel */                 sizeof(FloatPoint),
+    /* PathSegCurveToCubicAbs */           3 * sizeof(FloatPoint),
+    /* PathSegCurveToCubicRel */           3 * sizeof(FloatPoint),
+    /* PathSegCurveToQuadraticAbs */       2 * sizeof(FloatPoint),
+    /* PathSegCurveToQuadraticRel */       2 * sizeof(FloatPoint),
+    /* PathSegArcAbs */                    2 * sizeof(FloatPoint) + 1 * sizeof(float) + 2 * sizeof(bool),
+    /* PathSegArcRel */                    2 * sizeof(FloatPoint) + 1 * sizeof(float) + 2 * sizeof(bool),
+    /* PathSegLineToHorizontalAbs */       sizeof(float),
+    /* PathSegLineToHorizontalRel */       sizeof(float),
+    /* PathSegLineToVerticalAbs */         sizeof(float),
+    /* PathSegLineToVerticalRel */         sizeof(float),
+    /* PathSegCurveToCubicSmoothAbs */     2 * sizeof(FloatPoint),
+    /* PathSegCurveToCubicSmoothRel */     2 * sizeof(FloatPoint),
+    /* PathSegCurveToQuadraticSmoothAbs */ sizeof(FloatPoint),
+    /* PathSegCurveToQuadraticSmoothRel */ sizeof(FloatPoint)
+};
+
 void SVGPathByteStreamBuilder::emitSegment(const PathSegmentData& segment)
 {
-    CoalescingBuffer buffer(m_byteStream);
+    ASSERT(segment.command > PathSegUnknown && segment.command <= PathSegCurveToQuadraticSmoothRel);
+    size_t commandLength = sizeof(unsigned short) + commandParamLength[segment.command];
+    StreamBufferHelper buffer(m_byteStream, commandLength);
     buffer.writeSegmentType(segment.command);
 
     switch (segment.command) {
     case PathSegMoveToRel:
     case PathSegMoveToAbs:
     case PathSegLineToRel:
     case PathSegLineToAbs:
     case PathSegCurveToQuadraticSmoothRel:
     case PathSegCurveToQuadraticSmoothAbs:
         buffer.writeFloatPoint(segment.targetPoint);
@@ skipping 31 matching lines @@
         buffer.writeFlag(segment.arcLarge);
         buffer.writeFlag(segment.arcSweep);
         buffer.writeFloatPoint(segment.targetPoint);
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 } // namespace blink