Use RefPtr to manage shaders in Gradient and Pattern.

Source/core/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 35 matching lines @@
     : m_radial(false)
     , m_p0(p0)
     , m_p1(p1)
     , m_r0(0)
     , m_r1(0)
     , m_aspectRatio(1)
     , m_stopsSorted(false)
     , m_spreadMethod(SpreadMethodPad)
     , m_cachedHash(0)
     , m_drawInPMColorSpace(false)
-    , m_gradient(0)
 {
 }
 
 Gradient::Gradient(const FloatPoint& p0, float r0, const FloatPoint& p1, float r1, float aspectRatio)
     : m_radial(true)
     , m_p0(p0)
     , m_p1(p1)
     , m_r0(r0)
     , m_r1(r1)
     , m_aspectRatio(aspectRatio)
     , m_stopsSorted(false)
     , m_spreadMethod(SpreadMethodPad)
     , m_cachedHash(0)
     , m_drawInPMColorSpace(false)
-    , m_gradient(0)
 {
 }
 
 Gradient::~Gradient()
 {
-    destroyShader();
-}
-
-void Gradient::destroyShader()
-{
-    SkSafeUnref(m_gradient);
-    m_gradient = 0;
 }
 
 void Gradient::adjustParametersForTiledDrawing(IntSize& size, FloatRect& srcRect)
 {
     if (m_radial)
         return;
 
     if (srcRect.isEmpty())
         return;
 
@@ skipping 14 matching lines @@
 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_stopsSorted = false;
-    destroyShader();
+    m_gradient.clear();
 
     invalidateHash();
 }
 
 void Gradient::addColorStop(const Gradient::ColorStop& stop)
 {
     m_stops.append(stop);
 
     m_stopsSorted = false;
-    destroyShader();
+    m_gradient.clear();
 
     invalidateHash();
 }
 
 static inline bool compareStops(const Gradient::ColorStop& a, const Gradient::ColorStop& b)
 {
     return a.stop < b.stop;
 }
 
 void Gradient::sortStopsIfNecessary()
@@ skipping 17 matching lines @@
         if (m_stops[i].alpha < 1)
             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 == 0);
+    ASSERT(!m_gradient);
 
     if (m_spreadMethod == spreadMethod)
         return;
 
     m_spreadMethod = spreadMethod;
 
     invalidateHash();
 }
 
 void Gradient::setDrawsInPMColorSpace(bool drawInPMColorSpace)
 {
     if (drawInPMColorSpace == m_drawInPMColorSpace)
         return;
 
     m_drawInPMColorSpace = drawInPMColorSpace;
-
-    if (m_gradient)
-        destroyShader();
+    m_gradient.clear();
 
     invalidateHash();
 }
 
 void Gradient::setGradientSpaceTransform(const AffineTransform& gradientSpaceTransformation)
 {
     if (m_gradientSpaceTransformation == gradientSpaceTransformation)
         return;
 
     m_gradientSpaceTransformation = gradientSpaceTransformation;
@@ skipping 105 matching lines @@
     // comparison.
     if (count < 1 || (--stop)->stop < 1.0) {
         pos[start + count] = WebCoreFloatToSkScalar(1.0);
         colors[start + count] = colors[start + count - 1];
     }
 }
 
 SkShader* Gradient::shader()
 {
     if (m_gradient)
-        return 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)));
@@ skipping 12 matching lines @@
         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 = SkGradientShader::CreateRadial(m_p1, m_r1, colors, pos, static_cast<int>(countUsed), tile, 0, shouldDrawInPMColorSpace);
-        else {
+        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));

[Stephen Chennney, 2013/07/08 13:55:11]

In Blink, a "Create..." method would return a PassRefPtr. I presume that is not
possible here because PassrefPtr is not known to SkGradientShader. Is that
right?

[jbroman, 2013/07/08 13:59:19]

Correct; these methods are defined in Skia, which does not know about the WTF
smart pointers.

+        } 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 = 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, pos, 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 = SkGradientShader::CreateLinear(pts, colors, pos, static_cast<int>(countUsed), tile, 0, shouldDrawInPMColorSpace);
+        m_gradient = adoptRef(SkGradientShader::CreateLinear(pts, colors, pos, static_cast<int>(countUsed), tile, 0, shouldDrawInPMColorSpace));
     }
 
-    if (!m_gradient)
+    if (!m_gradient) {
         // use last color, since our "geometry" was degenerate (e.g. radius==0)
-        m_gradient = new SkColorShader(colors[countUsed - 1]);
-    else
+        m_gradient = adoptRef(new SkColorShader(colors[countUsed - 1]));
+    } else {
         m_gradient->setLocalMatrix(m_gradientSpaceTransformation);
-    return m_gradient;
+    }
+    return m_gradient.get();
 }
 
 } //namespace