Revert of Switch Blink SkShader clients to sk_sp

third_party/WebKit/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 66 matching lines @@
 
 void Gradient::addColorStop(const Gradient::ColorStop& stop)
 {
     if (m_stops.isEmpty()) {
         m_stopsSorted = true;
     } else {
         m_stopsSorted = m_stopsSorted && compareStops(m_stops.last(), stop);
     }
 
     m_stops.append(stop);
-    m_gradient.reset();
+    m_gradient.clear();
 }
 
 void Gradient::sortStopsIfNecessary()
 {
     if (m_stopsSorted)
         return;
 
     m_stopsSorted = true;
 
     if (!m_stops.size())
@@ skipping 12 matching lines @@
 
     m_spreadMethod = spreadMethod;
 }
 
 void Gradient::setDrawsInPMColorSpace(bool drawInPMColorSpace)
 {
     if (drawInPMColorSpace == m_drawInPMColorSpace)
         return;
 
     m_drawInPMColorSpace = drawInPMColorSpace;
-    m_gradient.reset();
+    m_gradient.clear();
 }
 
 void Gradient::setGradientSpaceTransform(const AffineTransform& gradientSpaceTransformation)
 {
     if (m_gradientSpaceTransformation == gradientSpaceTransformation)
         return;
 
     m_gradientSpaceTransformation = gradientSpaceTransformation;
-    m_gradient.reset();
+    m_gradient.clear();
 }
 
 // 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;
@@ skipping 42 matching lines @@
     }
 
     // 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];
     }
 }
 
-sk_sp<SkShader> Gradient::shader()
+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());
 
     ColorStopOffsetVector pos(countUsed);
     ColorStopColorVector colors(countUsed);
@@ skipping 20 matching lines @@
             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);
         }
         SkMatrix localMatrix = affineTransformToSkMatrix(m_gradientSpaceTransformation);
 
         // 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::MakeRadial(m_p1.data(), m_r1, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix);
+            m_gradient = adoptRef(SkGradientShader::CreateRadial(m_p1.data(), m_r1, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix));
         } 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::MakeTwoPointConical(m_p0.data(), radius0, m_p1.data(), radius1, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix);
+            m_gradient = adoptRef(SkGradientShader::CreateTwoPointConical(m_p0.data(), radius0, m_p1.data(), radius1, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix));
         }
     } else {
         SkPoint pts[2] = { m_p0.data(), m_p1.data() };
         SkMatrix localMatrix = affineTransformToSkMatrix(m_gradientSpaceTransformation);
-        m_gradient = SkGradientShader::MakeLinear(pts, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix);
+        m_gradient = adoptRef(SkGradientShader::CreateLinear(pts, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix));
     }
 
     if (!m_gradient) {
         // use last color, since our "geometry" was degenerate (e.g. radius==0)
-        m_gradient = SkShader::MakeColorShader(colors[countUsed - 1]);
+        m_gradient = adoptRef(SkShader::CreateColorShader(colors[countUsed - 1]));
     }
-    return m_gradient;
+    return m_gradient.get();
 }
 
 void Gradient::applyToPaint(SkPaint& paint)
 {
     paint.setShader(shader());
 
     // Legacy behavior: gradients are always dithered.
     paint.setDither(true);
 }
 } // namespace blink