Replace manual pointer arithmetic with WTF:Vector in Gradient::shader()

Source/platform/graphics/Gradient.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 18 matching lines @@
 #include "platform/graphics/Gradient.h"
 
 #include "platform/geometry/FloatRect.h"
 #include "platform/graphics/Color.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "third_party/skia/include/core/SkColorShader.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 
+typedef Vector<SkScalar, 8> ColorStopOffsetVector;
+typedef Vector<SkColor, 8> ColorStopColorVector;
+
 namespace WebCore {
 
 Gradient::Gradient(const FloatPoint& p0, const FloatPoint& p1)
     : m_p0(p0)
     , m_p1(p1)
     , m_r0(0)
     , m_r1(0)
     , m_aspectRatio(1)
     , m_radial(false)
     , m_stopsSorted(false)
@@ skipping 122 matching lines @@
     if (count < 1 || stop->stop < 1.0)
         countUsed++;
     return countUsed;
 }
 
 // Collect sorted stop position and color information into the pos and colors
 // buffers, ensuring stops at both 0.0 and 1.0. The buffers must be large
 // enough to hold information for all stops, including the new endpoints if
 // stops at 0.0 and 1.0 aren't already included.
 static void fillStops(const Gradient::ColorStop* stopData,
-    size_t count, SkScalar* pos, SkColor* colors)
+    size_t count, ColorStopOffsetVector& pos, ColorStopColorVector& colors)
 {
     const Gradient::ColorStop* stop = stopData;
     size_t start = 0;
     if (count < 1) {
         // A gradient with no stops must be transparent black.
         pos[0] = WebCoreFloatToSkScalar(0.0);
         colors[0] = makeSkColor(0.0, 0.0, 0.0, 0.0);
         start = 1;
     } else if (stop->stop > 0.0) {
         // Copy the first stop to 0.0. The first stop position may have a slight
@@ skipping 24 matching lines @@
     if (m_gradient)
         return m_gradient.get();
 
     sortStopsIfNecessary();
     ASSERT(m_stopsSorted);
 
     size_t countUsed = totalStopsNeeded(m_stops.data(), m_stops.size());
     ASSERT(countUsed >= 2);
     ASSERT(countUsed >= m_stops.size());
 
-    // FIXME: Why is all this manual pointer math needed?!
-    SkAutoMalloc storage(countUsed * (sizeof(SkColor) + sizeof(SkScalar)));
-    SkColor* colors = (SkColor*)storage.get();
-    SkScalar* pos = (SkScalar*)(colors + countUsed);
-
+    ColorStopOffsetVector pos(countUsed);
+    ColorStopColorVector colors(countUsed);
     fillStops(m_stops.data(), m_stops.size(), pos, colors);
 
     SkShader::TileMode tile = SkShader::kClamp_TileMode;
     switch (m_spreadMethod) {
     case SpreadMethodReflect:
         tile = SkShader::kMirror_TileMode;
         break;
     case SpreadMethodRepeat:
         tile = SkShader::kRepeat_TileMode;
         break;
     case SpreadMethodPad:
         tile = SkShader::kClamp_TileMode;
         break;
     }
 
     uint32_t shouldDrawInPMColorSpace = m_drawInPMColorSpace ? SkGradientShader::kInterpolateColorsInPremul_Flag : 0;
     if (m_radial) {
         // Since the two-point radial gradient is slower than the plain radial,
         // only use it if we have to.
         if (m_p0 == m_p1 && m_r0 <= 0.0f) {
-            m_gradient = adoptRef(SkGradientShader::CreateRadial(m_p1, m_r1, colors, pos, static_cast<int>(countUsed), tile, 0, shouldDrawInPMColorSpace));
+            m_gradient = adoptRef(SkGradientShader::CreateRadial(m_p1, m_r1, colors.data(), pos.data(), static_cast<int>(countUsed), tile, 0, shouldDrawInPMColorSpace));
         } else {
             // The radii we give to Skia must be positive. If we're given a
             // negative radius, ask for zero instead.
             SkScalar radius0 = m_r0 >= 0.0f ? WebCoreFloatToSkScalar(m_r0) : 0;
             SkScalar radius1 = m_r1 >= 0.0f ? WebCoreFloatToSkScalar(m_r1) : 0;
-            m_gradient = adoptRef(SkGradientShader::CreateTwoPointConical(m_p0, radius0, m_p1, radius1, colors, pos, static_cast<int>(countUsed), tile, 0, shouldDrawInPMColorSpace));
+            m_gradient = adoptRef(SkGradientShader::CreateTwoPointConical(m_p0, radius0, m_p1, radius1, colors.data(), pos.data(), static_cast<int>(countUsed), tile, 0, shouldDrawInPMColorSpace));
         }
 
         if (aspectRatio() != 1) {
             // CSS3 elliptical gradients: apply the elliptical scaling at the
             // gradient center point.
             m_gradientSpaceTransformation.translate(m_p0.x(), m_p0.y());
             m_gradientSpaceTransformation.scale(1, 1 / aspectRatio());
             m_gradientSpaceTransformation.translate(-m_p0.x(), -m_p0.y());
             ASSERT(m_p0 == m_p1);
         }
     } else {
         SkPoint pts[2] = { m_p0, m_p1 };
-        m_gradient = adoptRef(SkGradientShader::CreateLinear(pts, colors, pos, static_cast<int>(countUsed), tile, 0, shouldDrawInPMColorSpace));
+        m_gradient = adoptRef(SkGradientShader::CreateLinear(pts, colors.data(), pos.data(), static_cast<int>(countUsed), tile, 0, shouldDrawInPMColorSpace));
     }
 
     if (!m_gradient) {
         // use last color, since our "geometry" was degenerate (e.g. radius==0)
         m_gradient = adoptRef(new SkColorShader(colors[countUsed - 1]));
     } else {
         m_gradient->setLocalMatrix(affineTransformToSkMatrix(m_gradientSpaceTransformation));
     }
     return m_gradient.get();
 }
 
 } //namespace