Update Skia

This required a bunch of changes because of the new sk_sp type Skia has
introduced into their API.

DEPS

@@ -21,7 +21,7 @@ vars = {
   'chromium_git': 'https://chromium.googlesource.com',
   'mojo_sdk_revision': '5c0d7cd229bff7e2dfbcdea8310592ec90482919',
   'base_revision': '6c89618151eb0e23d330778e6d6ea16fc6105010',
-  'skia_revision': '992ad363d7ca879cdb86f802b379f06800a44125',
+  'skia_revision': '50e82e61766d22da5238905916a8abc3e6664060',
 
   # Note: When updating the Dart revision, ensure that all entries that are
   # dependencies of dart are also updated

flow/checkerboard.cc

@@ -8,14 +8,15 @@
 
 namespace flow {
 
-static SkShader* CreateCheckerboardShader(SkColor c1, SkColor c2, int size) {
+static sk_sp<SkShader> CreateCheckerboardShader(SkColor c1, SkColor c2,
+                                                int size) {
   SkBitmap bm;
   bm.allocN32Pixels(2 * size, 2 * size);
   bm.eraseColor(c1);
   bm.eraseArea(SkIRect::MakeLTRB(0, 0, size, size), c2);
   bm.eraseArea(SkIRect::MakeLTRB(size, size, 2 * size, 2 * size), c2);
-  return SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
-                                      SkShader::kRepeat_TileMode);
+  return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode,
+                                    SkShader::kRepeat_TileMode);
 }
 
 static void DrawCheckerboard(SkCanvas* canvas,
@@ -23,7 +24,7 @@ static void DrawCheckerboard(SkCanvas* canvas,
                              SkColor c2,
                              int size) {
   SkPaint paint;
-  paint.setShader(CreateCheckerboardShader(c1, c2, size))->unref();
+  paint.setShader(CreateCheckerboardShader(c1, c2, size));
   canvas->drawPaint(paint);
 }
 

flow/layers/shader_mask_layer.cc

@@ -25,7 +25,7 @@ void ShaderMaskLayer::Paint(PaintContext::ScopedFrame& frame) {
 
   SkPaint paint;
   paint.setXfermodeMode(transfer_mode_);
-  paint.setShader(shader_.get());
+  paint.setShader(shader_);
   canvas.translate(mask_rect_.left(), mask_rect_.top());
   canvas.drawRect(SkRect::MakeWH(mask_rect_.width(), mask_rect_.height()), paint);
 }

flow/layers/shader_mask_layer.h

@@ -16,7 +16,7 @@ class ShaderMaskLayer : public ContainerLayer {
   ShaderMaskLayer();
   ~ShaderMaskLayer() override;
 
-  void set_shader(SkShader* shader) { shader_ = skia::SharePtr(shader); }
+  void set_shader(sk_sp<SkShader> shader) { shader_ = shader; }
 
   void set_mask_rect(const SkRect& mask_rect) {
     mask_rect_ = mask_rect;
@@ -31,7 +31,7 @@ class ShaderMaskLayer : public ContainerLayer {
   void Paint(PaintContext::ScopedFrame& frame) override;
 
  private:
-  skia::RefPtr<SkShader> shader_;
+  sk_sp<SkShader> shader_;
   SkRect mask_rect_;
   SkXfermode::Mode transfer_mode_;
 

flow/raster_cache.cc

@@ -80,7 +80,7 @@ skia::RefPtr<SkImage> RasterCache::GetPrerolledImage(GrContext* context,
                    "height", physical_size.height());
       SkImageInfo info = SkImageInfo::MakeN32Premul(physical_size);
       skia::RefPtr<SkSurface> surface = skia::AdoptRef(
-          SkSurface::NewRenderTarget(context, SkSurface::kYes_Budgeted, info));
+          SkSurface::NewRenderTarget(context, SkBudgeted::kYes, info));
       if (surface) {
         SkCanvas* canvas = surface->getCanvas();
         canvas->clear(SK_ColorTRANSPARENT);

skia/BUILD.gn

@@ -332,7 +332,6 @@ component("skia") {
     "//third_party/skia/src/utils/SkNinePatch.cpp",
     "//third_party/skia/src/utils/SkOSFile.cpp",
     "//third_party/skia/src/utils/SkParsePath.cpp",
-    "//third_party/skia/src/utils/SkTFitsIn.h",
 
     #testing
     "//third_party/skia/src/fonts/SkGScalerContext.cpp",

skia/ext/refptr.h

@@ -136,6 +136,9 @@ class RefPtr {
   template<typename U>
   friend RefPtr<U> AdoptRef(U* ptr);
 
+  template<typename U>
+  friend RefPtr<U> AdoptRef(sk_sp<U> ptr);
+
   template<typename U>
   friend RefPtr<U> SharePtr(U* ptr);
 
@@ -147,6 +150,9 @@ class RefPtr {
 template<typename T>
 RefPtr<T> AdoptRef(T* ptr) { return RefPtr<T>(ptr); }
 
+template<typename T>
+RefPtr<T> AdoptRef(sk_sp<T> ptr) { return RefPtr<T>(ptr.release()); }
+
 // For objects that are already owned. This doesn't take ownership of existing
 // references and adds a new one.
 template<typename T>

sky/engine/core/painting/CanvasGradient.cpp

@@ -51,10 +51,9 @@ void CanvasGradient::initLinear(const std::vector<Point>& end_points,
   for (const CanvasColor& color : colors)
     sk_colors.push_back(color);
 
-  SkShader* shader = SkGradientShader::CreateLinear(
+  set_shader(SkGradientShader::MakeLinear(
       sk_end_points, sk_colors.data(), color_stops.data(), sk_colors.size(),
-      tile_mode);
-  set_shader(adoptRef(shader));
+      tile_mode));
 }
 
 void CanvasGradient::initRadial(const Point& center,
@@ -69,10 +68,9 @@ void CanvasGradient::initRadial(const Point& center,
   for (const CanvasColor& color : colors)
     sk_colors.push_back(color);
 
-  SkShader* shader = SkGradientShader::CreateRadial(
+  set_shader(SkGradientShader::MakeRadial(
       center.sk_point, radius, sk_colors.data(), color_stops.data(),
-      sk_colors.size(), tile_mode);
-  set_shader(adoptRef(shader));
+      sk_colors.size(), tile_mode));
 }
 
 CanvasGradient::CanvasGradient()

sky/engine/core/painting/ImageShader.cpp

@@ -56,7 +56,7 @@ void ImageShader::initWithImage(CanvasImage* image,
   SkBitmap bitmap;
   image->image()->asLegacyBitmap(&bitmap, SkImage::kRO_LegacyBitmapMode);
 
-  set_shader(adoptRef(SkShader::CreateBitmapShader(bitmap, tmx, tmy, &sk_matrix)));
+  set_shader(SkShader::MakeBitmapShader(bitmap, tmx, tmy, &sk_matrix));
 }
 
 ImageShader::ImageShader() : Shader(nullptr) {

sky/engine/core/painting/Shader.cpp

@@ -8,7 +8,7 @@ namespace blink {
 
 IMPLEMENT_WRAPPERTYPEINFO(ui, Shader);
 
-Shader::Shader(PassRefPtr<SkShader> shader)
+Shader::Shader(sk_sp<SkShader> shader)
     : shader_(shader) {
 }
 

sky/engine/core/painting/Shader.h

@@ -17,14 +17,14 @@ class Shader : public RefCounted<Shader>, public DartWrappable {
  public:
   ~Shader() override;
 
-  SkShader* shader() { return shader_.get(); }
-  void set_shader(PassRefPtr<SkShader> shader) { shader_ = shader; }
+  sk_sp<SkShader> shader() { return shader_; }
+  void set_shader(sk_sp<SkShader> shader) { shader_ = shader; }
 
  protected:
-  Shader(PassRefPtr<SkShader> shader);
+  Shader(sk_sp<SkShader> shader);
 
  private:
-  RefPtr<SkShader> shader_;
+  sk_sp<SkShader> shader_;
 };
 
 } // namespace blink

sky/engine/platform/graphics/DecodingImageGenerator.cpp

@@ -72,15 +72,9 @@ bool DecodingImageGenerator::onGetPixels(const SkImageInfo& info, void* pixels,
     return m_frameGenerator->decodeAndScale(info, m_frameIndex, pixels, rowBytes);
 }
 
-bool DecodingImageGenerator::onGetYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3])
+bool DecodingImageGenerator::onGetYUV8Planes(const SkYUVSizeInfo& sizeInfo, void* planes[3])
 {
-    if (!planes || !planes[0]) {
-        return m_frameGenerator->getYUVComponentSizes(sizes);
-    }
-
-    TRACE_EVENT0("blink", "DecodingImageGenerator::onGetYUV8Planes");
-    bool decoded = m_frameGenerator->decodeToYUV(planes, rowBytes);
-    return decoded;
+    return false;
 }
 
 } // namespace blink

sky/engine/platform/graphics/DecodingImageGenerator.h

@@ -51,7 +51,7 @@ public:
 protected:
     virtual SkData* onRefEncodedData(GrContext* ctx = nullptr) override;
     virtual bool onGetPixels(const SkImageInfo&, void* pixels, size_t rowBytes, SkPMColor ctable[], int* ctableCount) override;
-    virtual bool onGetYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3]) override;
+    virtual bool onGetYUV8Planes(const SkYUVSizeInfo&, void* planes[3]) override;
 
 private:
     RefPtr<ImageFrameGenerator> m_frameGenerator;

sky/engine/platform/graphics/DrawLooperBuilder.cpp

@@ -32,6 +32,7 @@
 
 #include "sky/engine/platform/geometry/FloatSize.h"
 #include "sky/engine/platform/graphics/Color.h"
+#include "sky/engine/platform/graphics/skia/SkiaUtils.h"
 #include "sky/engine/wtf/RefPtr.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
@@ -53,7 +54,7 @@ PassOwnPtr<DrawLooperBuilder> DrawLooperBuilder::create()
 
 PassRefPtr<SkDrawLooper> DrawLooperBuilder::detachDrawLooper()
 {
-    return adoptRef(m_skDrawLooperBuilder.detachLooper());
+    return fromSkSp(m_skDrawLooperBuilder.detach());
 }
 
 void DrawLooperBuilder::addUnmodifiedContent()

sky/engine/platform/graphics/Gradient.cpp

@@ -242,23 +242,23 @@ SkShader* Gradient::shader()
         // 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.data(), m_r1, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix));
+            m_gradient = fromSkSp(SkGradientShader::MakeRadial(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 = adoptRef(SkGradientShader::CreateTwoPointConical(m_p0.data(), radius0, m_p1.data(), radius1, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix));
+            m_gradient = fromSkSp(SkGradientShader::MakeTwoPointConical(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 = adoptRef(SkGradientShader::CreateLinear(pts, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix));
+        m_gradient = fromSkSp(SkGradientShader::MakeLinear(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 = adoptRef(SkShader::CreateColorShader(colors[countUsed - 1]));
+        m_gradient = fromSkSp(SkShader::MakeColorShader(colors[countUsed - 1]));
     }
     return m_gradient.get();
 }

sky/engine/platform/graphics/GraphicsContext.cpp

@@ -465,7 +465,7 @@ void GraphicsContext::drawFocusRingPath(const SkPath& path, const Color& color,
     SkPaint paint;
     float cornerRadius = prepareFocusRingPaint(paint, color, width);
 
-    paint.setPathEffect(SkCornerPathEffect::Create(SkFloatToScalar(cornerRadius)))->unref();
+    paint.setPathEffect(SkCornerPathEffect::Make(SkFloatToScalar(cornerRadius)));
 
     // Outer path
     drawPath(path, paint);
@@ -642,11 +642,10 @@ void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& pt, float widt
 
     SkMatrix localMatrix;
     localMatrix.setTranslate(originX, originY);
-    RefPtr<SkShader> shader = adoptRef(SkShader::CreateBitmapShader(
-        *misspellBitmap[index], SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix));
 
     SkPaint paint;
-    paint.setShader(shader.get());
+    paint.setShader(SkShader::MakeBitmapShader(
+        *misspellBitmap[index], SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix));
 
     SkRect rect;
     rect.set(originX, originY, originX + WebCoreFloatToSkScalar(width) * deviceScaleFactor, originY + SkIntToScalar(misspellBitmap[index]->height()));
@@ -1640,7 +1639,7 @@ void GraphicsContext::preparePaintForDrawRectToRect(
     paint->setXfermodeMode(WebCoreCompositeToSkiaComposite(compositeOp, blendMode));
     paint->setColorFilter(this->colorFilter());
     paint->setAlpha(this->getNormalizedAlpha());
-    paint->setLooper(this->drawLooper());
+    paint->setLooper(toSkSp(this->drawLooper()));
     paint->setAntiAlias(shouldDrawAntiAliased(this, destRect));
 
     InterpolationQuality resampling;

sky/engine/platform/graphics/GraphicsContext.h

@@ -143,7 +143,7 @@ public:
     void setFillGradient(PassRefPtr<Gradient>);
     Gradient* fillGradient() const { return immutableState()->fillGradient(); }
 
-    SkDrawLooper* drawLooper() const { return immutableState()->drawLooper(); }
+    const RefPtr<SkDrawLooper>& drawLooper() const { return immutableState()->drawLooper(); }
 
     bool getTransformedClipBounds(FloatRect* bounds) const;
     SkMatrix getTotalMatrix() const;

sky/engine/platform/graphics/GraphicsContextState.cpp

@@ -188,15 +188,15 @@ void GraphicsContextState::clearFillPattern()
 void GraphicsContextState::setDrawLooper(PassRefPtr<SkDrawLooper> drawLooper)
 {
     m_looper = drawLooper;
-    m_strokePaint.setLooper(m_looper.get());
-    m_fillPaint.setLooper(m_looper.get());
+    m_strokePaint.setLooper(toSkSp(m_looper));
+    m_fillPaint.setLooper(toSkSp(m_looper));
 }
 
 void GraphicsContextState::clearDrawLooper()
 {
     m_looper.clear();
-    m_strokePaint.setLooper(0);
-    m_fillPaint.setLooper(0);
+    m_strokePaint.setLooper(nullptr);
+    m_fillPaint.setLooper(nullptr);
 }
 
 void GraphicsContextState::setAlphaAsFloat(float alpha)

sky/engine/platform/graphics/GraphicsContextState.h

@@ -109,7 +109,7 @@ public:
     void setFillRule(WindRule rule) { m_fillRule = rule; }
 
     // Shadow. (This will need tweaking if we use draw loopers for other things.)
-    SkDrawLooper* drawLooper() const { return m_looper.get(); }
+    const RefPtr<SkDrawLooper>& drawLooper() const { return m_looper; }
     void setDrawLooper(PassRefPtr<SkDrawLooper>);
     void clearDrawLooper();
 

sky/engine/platform/graphics/Pattern.cpp

@@ -59,9 +59,9 @@ SkShader* Pattern::shader()
 
     // If we don't have a bitmap, return a transparent shader.
     if (!m_tileImage) {
-        m_pattern = adoptRef(SkShader::CreateColorShader(SK_ColorTRANSPARENT));
+        m_pattern = fromSkSp(SkShader::MakeColorShader(SK_ColorTRANSPARENT));
     } else if (m_repeatMode == RepeatModeXY) {
-        m_pattern = adoptRef(SkShader::CreateBitmapShader(m_tileImage->bitmap(),
+        m_pattern = fromSkSp(SkShader::MakeBitmapShader(m_tileImage->bitmap(),
             SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix));
     } else {
         // Skia does not have a "draw the tile only once" option. Clamp_TileMode
@@ -93,7 +93,7 @@ SkShader* Pattern::shader()
         SkCanvas canvas(bm2);
         canvas.drawBitmap(m_tileImage->bitmap(), 0, 0);
         bm2.setImmutable();
-        m_pattern = adoptRef(SkShader::CreateBitmapShader(bm2, tileModeX, tileModeY, &localMatrix));
+        m_pattern = fromSkSp(SkShader::MakeBitmapShader(bm2, tileModeX, tileModeY, &localMatrix));
 
         // Clamp to int, since that's what the adjust function takes.
         m_externalMemoryAllocated = static_cast<int>(std::min(static_cast<size_t>(INT_MAX), bm2.getSafeSize()));

sky/engine/platform/graphics/StrokeData.cpp

@@ -27,6 +27,8 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "sky/engine/platform/graphics/StrokeData.h"
+
+#include "sky/engine/platform/graphics/skia/SkiaUtils.h"
 #include "sky/engine/wtf/OwnPtr.h"
 #include "sky/engine/wtf/PassOwnPtr.h"
 
@@ -53,7 +55,7 @@ void StrokeData::setLineDash(const DashArray& dashes, float dashOffset)
     for (unsigned i = 0; i < count; i++)
         intervals[i] = dashes[i % dashLength];
 
-    m_dash = adoptRef(SkDashPathEffect::Create(intervals.get(), count, dashOffset));
+    m_dash = fromSkSp(SkDashPathEffect::Make(intervals.get(), count, dashOffset));
 }
 
 void StrokeData::setupPaint(SkPaint* paint, int length) const
@@ -71,7 +73,7 @@ void StrokeData::setupPaintDashPathEffect(SkPaint* paint, int length) const
 {
     float width = m_thickness;
     if (m_dash) {
-        paint->setPathEffect(m_dash.get());
+        paint->setPathEffect(toSkSp(m_dash));
     } else {
         switch (m_style) {
         case NoStroke:
@@ -104,8 +106,7 @@ void StrokeData::setupPaintDashPathEffect(SkPaint* paint, int length) const
             }
             SkScalar dashLengthSk = SkIntToScalar(dashLength);
             SkScalar intervals[2] = { dashLengthSk, dashLengthSk };
-            RefPtr<SkPathEffect> pathEffect = adoptRef(SkDashPathEffect::Create(intervals, 2, SkIntToScalar(phase)));
-            paint->setPathEffect(pathEffect.get());
+            paint->setPathEffect(SkDashPathEffect::Make(intervals, 2, SkIntToScalar(phase)));
         }
     }
 }

sky/engine/platform/graphics/skia/NativeImageSkia.cpp

@@ -237,7 +237,7 @@ void NativeImageSkia::drawPattern(
     const float adjustedY = phase.y() + normSrcRect.y() * scale.height();
     localMatrix.setTranslate(SkFloatToScalar(adjustedX), SkFloatToScalar(adjustedY));
 
-    RefPtr<SkShader> shader;
+    sk_sp<SkShader> shader;
     SkFilterQuality filterLevel = static_cast<SkFilterQuality>(resampling);
 
     // Bicubic filter is only applied to defer-decoded images, see
@@ -263,11 +263,11 @@ void NativeImageSkia::drawPattern(
         // boundaries.
         SkBitmap resampled = extractScaledImageFragment(normSrcRect, scaleX, scaleY, &scaledSrcRect);
         if (repeatSpacing.isZero()) {
-            shader = adoptRef(SkShader::CreateBitmapShader(resampled, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix));
+            shader = SkShader::MakeBitmapShader(resampled, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix);
         } else {
-            shader = adoptRef(SkShader::CreateBitmapShader(
+            shader = SkShader::MakeBitmapShader(
                 createBitmapWithSpace(resampled, repeatSpacing.width() * ctmScaleX, repeatSpacing.height() * ctmScaleY),
-                SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix));
+                SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix);
         }
     } else {
         // Because no resizing occurred, the shader transform should be
@@ -278,16 +278,16 @@ void NativeImageSkia::drawPattern(
         SkBitmap srcSubset;
         bitmap().extractSubset(&srcSubset, enclosingIntRect(normSrcRect));
         if (repeatSpacing.isZero()) {
-            shader = adoptRef(SkShader::CreateBitmapShader(srcSubset, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix));
+            shader = SkShader::MakeBitmapShader(srcSubset, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix);
         } else {
-            shader = adoptRef(SkShader::CreateBitmapShader(
+            shader = SkShader::MakeBitmapShader(
                 createBitmapWithSpace(srcSubset, repeatSpacing.width() * ctmScaleX, repeatSpacing.height() * ctmScaleY),
-                SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix));
+                SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix);
         }
     }
 
     SkPaint paint;
-    paint.setShader(shader.get());
+    paint.setShader(shader);
     paint.setXfermodeMode(WebCoreCompositeToSkiaComposite(compositeOp, blendMode));
     paint.setColorFilter(context->colorFilter());
     paint.setFilterQuality(filterLevel);

sky/engine/platform/graphics/skia/SkiaUtils.h

@@ -42,6 +42,7 @@
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
+#include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 
 namespace blink {
@@ -106,6 +107,83 @@ InterpolationQuality computeInterpolationQuality(
 
 bool shouldDrawAntiAliased(const GraphicsContext*, const SkRect& destRect);
 
+// Skia's smart pointer APIs are preferable over their legacy raw pointer counterparts.
+// The following helpers ensure interoperability between Skia's SkRefCnt wrapper sk_sp<T> and
+// Blink's RefPtr<T>/PassRefPtr<T>.
+//
+//   - fromSkSp(sk_sp<T>):       adopts an sk_sp into a PassRefPtr (to be used when transferring
+//                               ownership from Skia to Blink).
+//   - toSkSp(PassRefPtr<T>):    releases a PassRefPtr into a sk_sp (to be used when transferring
+//                               ownership from Blink to Skia).
+//   - toSkSp(const RefPtr<T>&): shares a RefPtr as a new sk_sp (to be used when sharing
+//                               ownership).
+//
+// General guidelines
+//
+// When receiving ref counted objects from Skia:
+//
+//   1) use sk_sp-based Skia factories if available (e.g. SkShader::MakeFoo() instead of
+//      SkShader::CreateFoo())
+//
+//   2) use sk_sp<T> locals for temporary objects (to be immediately transferred back to Skia)
+//
+//   3) use RefPtr<T>/PassRefPtr<T> for objects to be retained in Blink, use
+//      fromSkSp(sk_sp<T>) to convert
+//
+// When passing ref counted objects to Skia:
+//
+//   1) use sk_sk-based Skia APIs when available (e.g. SkPaint::setShader(sk_sp<SkShader>)
+//      instead of SkPaint::setShader(SkShader*))
+//
+//   2) if the object ownership is being passed to Skia, use std::move(sk_sp<T>) or
+//      toSkSp(PassRefPtr<T>) to transfer without refcount churn
+//
+//   3) if the object ownership is shared with Skia (Blink retains a reference), use
+//      toSkSp(const RefPtr<T>&)
+//
+// Example (creating a SkShader and setting it on SkPaint):
+//
+// a) legacy/old style
+//
+//     RefPtr<SkShader> shader = adoptRef(SkShader::CreateFoo(...));
+//     paint.setShader(shader.get());
+//
+//  (Note: the legacy approach introduces refcount churn as Skia grabs a ref while Blink is
+//   temporarily holding on to its own)
+//
+// b) new style, ownership transferred
+//
+//     // using Skia smart pointer locals
+//     sk_sp<SkShader> shader = SkShader::MakeFoo(...);
+//     paint.setShader(std::move(shader));
+//
+//     // using Blink smart pointer locals
+//     RefPtr<SkShader> shader = fromSkSp(SkShader::MakeFoo(...));
+//     paint.setShader(toSkSp(shader.release());
+//
+//     // using no locals
+//     paint.setShader(SkShader::MakeFoo(...));
+//
+// c) new style, shared ownership
+//
+//     RefPtr<SkShader> shader = fromSkSp(SkShader::MakeFoo(...));
+//     paint.setShader(toSkSp(shader));
+//
+template <typename T> PassRefPtr<T> fromSkSp(sk_sp<T> sp)
+{
+    return adoptRef(sp.release());
+}
+
+template <typename T> sk_sp<T> toSkSp(PassRefPtr<T> ref)
+{
+    return sk_sp<T>(ref.leakRef());
+}
+
+template <typename T> sk_sp<T> toSkSp(const RefPtr<T>& ref)
+{
+    return toSkSp(PassRefPtr<T>(ref));
+}
+
 } // namespace blink
 
 #endif  // SKY_ENGINE_PLATFORM_GRAPHICS_SKIA_SKIAUTILS_H_

ui/gfx/skia_util.cc

@@ -79,7 +79,7 @@ skia::RefPtr<SkShader> CreateGradientShader(int start_point,
   grad_points[0].iset(0, start_point);
   grad_points[1].iset(0, end_point);
 
-  return skia::AdoptRef(SkGradientShader::CreateLinear(
+  return skia::AdoptRef(SkGradientShader::MakeLinear(
       grad_points, grad_colors, NULL, 2, SkShader::kRepeat_TileMode));
 }