Simplify Gradient by holding a Color instead of four floats.

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 52 matching lines @@
     , m_spreadMethod(SpreadMethodPad)
 {
 }
 
 Gradient::~Gradient()
 {
 }
 
 void Gradient::addColorStop(float value, const Color& color)
 {
-    float r;
-    float g;
-    float b;
-    float a;
-    color.getRGBA(r, g, b, a);
-    m_stops.append(ColorStop(value, r, g, b, a));
+    m_stops.append(ColorStop(value, color));
 
     m_stopsSorted = false;
     m_gradient.clear();
 }
 
 void Gradient::addColorStop(const Gradient::ColorStop& stop)
 {
     m_stops.append(stop);
 
     m_stopsSorted = false;
@@ skipping 14 matching lines @@
 
     if (!m_stops.size())
         return;
 
     std::stable_sort(m_stops.begin(), m_stops.end(), compareStops);
 }
 
 bool Gradient::hasAlpha() const
 {
     for (size_t i = 0; i < m_stops.size(); i++) {
-        if (m_stops[i].alpha < 1)
+        if (m_stops[i].color.hasAlpha())
             return true;
     }
 
     return false;
 }
 
 void Gradient::setSpreadMethod(GradientSpreadMethod spreadMethod)
 {
     // FIXME: Should it become necessary, allow calls to this method after m_gradient has been set.
     ASSERT(!m_gradient);
@@ skipping 16 matching lines @@
 void Gradient::setGradientSpaceTransform(const AffineTransform& gradientSpaceTransformation)
 {
     if (m_gradientSpaceTransformation == gradientSpaceTransformation)
         return;
 
     m_gradientSpaceTransformation = gradientSpaceTransformation;
     if (m_gradient)
         m_gradient->setLocalMatrix(affineTransformToSkMatrix(m_gradientSpaceTransformation));
 }
 
-static inline U8CPU F2B(float x)
-{
-    return static_cast<int>(x * 255);
-}
-
-static SkColor makeSkColor(float a, float r, float g, float b)
-{
-    return SkColorSetARGB(F2B(a), F2B(r), F2B(g), F2B(b));
-}
-
 // Determine the total number of stops needed, including pseudo-stops at the
 // ends as necessary.
 static size_t totalStopsNeeded(const Gradient::ColorStop* stopData, size_t count)
 {
     // N.B.: The tests in this function should kept in sync with the ones in
     // fillStops(), or badness happens.
     const Gradient::ColorStop* stop = stopData;
     size_t countUsed = count;
     if (count < 1 || stop->stop > 0.0)
         countUsed++;
     stop += count - 1;
     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)
 {
     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);
+        colors[0] = SK_ColorTRANSPARENT;
         start = 1;
     } else if (stop->stop > 0.0) {
         // Copy the first stop to 0.0. The first stop position may have a slight
         // rounding error, but we don't care in this float comparison, since
         // 0.0 comes through cleanly and people aren't likely to want a gradient
         // with a stop at (0 + epsilon).
         pos[0] = WebCoreFloatToSkScalar(0.0);
-        colors[0] = makeSkColor(stop->alpha, stop->red, stop->green, stop->blue);
+        colors[0] = stop->color.rgb();

[f(malita), 2014/03/17 18:50:17]

We should use SkColorSetARGB() to avoid any packing assumptions.

         start = 1;
     }
 
     for (size_t i = start; i < start + count; i++) {
         pos[i] = WebCoreFloatToSkScalar(stop->stop);
-        colors[i] = makeSkColor(stop->alpha, stop->red, stop->green, stop->blue);
+        colors[i] = stop->color.rgb();

[f(malita), 2014/03/17 18:50:17]

Ditto.

         ++stop;
     }
 
     // Copy the last stop to 1.0 if needed. See comment above about this float
     // comparison.
     if (count < 1 || (--stop)->stop < 1.0) {
         pos[start + count] = WebCoreFloatToSkScalar(1.0);
         colors[start + count] = colors[start + count - 1];
     }
 }
@@ skipping 60 matching lines @@
     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