Change (Pass)RefPtr<SkXxx> into sk_sp<SkXxx>.

third_party/WebKit/Source/platform/graphics/GraphicsContext.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 59 matching lines @@
 {
     if (metaData)
         m_metaData = *metaData;
 
     // FIXME: Do some tests to determine how many states are typically used, and allocate
     // several here.
     m_paintStateStack.append(GraphicsContextState::create());
     m_paintState = m_paintStateStack.last().get();
 
     if (contextDisabled()) {
-        DEFINE_STATIC_REF(SkCanvas, nullCanvas, (adoptRef(SkCreateNullCanvas())));
+        DEFINE_STATIC_LOCAL(SkCanvas*, nullCanvas, (SkCreateNullCanvas()));
         m_canvas = nullCanvas;
     }
 }
 
 GraphicsContext::~GraphicsContext()
 {
 #if DCHECK_IS_ON()
     if (!m_disableDestructionChecks) {
         ASSERT(!m_paintStateIndex);
         ASSERT(!m_paintState->saveCount());
@@ skipping 138 matching lines @@
 }
 
 void GraphicsContext::beginLayer(float opacity, SkXfermode::Mode xfermode, const FloatRect* bounds, ColorFilter colorFilter, sk_sp<SkImageFilter> imageFilter)
 {
     if (contextDisabled())
         return;
 
     SkPaint layerPaint;
     layerPaint.setAlpha(static_cast<unsigned char>(opacity * 255));
     layerPaint.setXfermodeMode(xfermode);
-    layerPaint.setColorFilter(toSkSp(WebCoreColorFilterToSkiaColorFilter(colorFilter)));
+    layerPaint.setColorFilter(WebCoreColorFilterToSkiaColorFilter(colorFilter));
     layerPaint.setImageFilter(std::move(imageFilter));
 
     if (bounds) {
         SkRect skBounds = *bounds;
         saveLayer(&skBounds, &layerPaint);
     } else {
         saveLayer(nullptr, &layerPaint);
     }
 
 #if DCHECK_IS_ON()
@@ skipping 16 matching lines @@
     if (contextDisabled())
         return;
 
     m_canvas = m_pictureRecorder.beginRecording(bounds, nullptr);
     if (m_hasMetaData)
         skia::GetMetaData(*m_canvas) = m_metaData;
 }
 
 namespace {
 
-PassRefPtr<SkPicture> createEmptyPicture()
+sk_sp<SkPicture> createEmptyPicture()
 {
     SkPictureRecorder recorder;
     recorder.beginRecording(SkRect::MakeEmpty(), nullptr);
-    return fromSkSp(recorder.finishRecordingAsPicture());
+    return recorder.finishRecordingAsPicture();
 }
 
 } // anonymous namespace
 
-PassRefPtr<SkPicture> GraphicsContext::endRecording()
+sk_sp<SkPicture> GraphicsContext::endRecording()
 {
     if (contextDisabled()) {
         // Clients expect endRecording() to always return a non-null picture.
         // Cache an empty SKP to minimize overhead when disabled.
-        DEFINE_STATIC_REF(SkPicture, emptyPicture, createEmptyPicture());
+        DEFINE_STATIC_LOCAL(sk_sp<SkPicture>, emptyPicture, (createEmptyPicture()));
         return emptyPicture;
     }
 
-    RefPtr<SkPicture> picture = fromSkSp(m_pictureRecorder.finishRecordingAsPicture());
+    sk_sp<SkPicture> picture = m_pictureRecorder.finishRecordingAsPicture();
     m_canvas = nullptr;
     ASSERT(picture);
-    return picture.release();
+    return picture;
 }
 
 void GraphicsContext::drawPicture(const SkPicture* picture)
 {
     if (contextDisabled() || !picture || picture->cullRect().isEmpty())
         return;
 
     ASSERT(m_canvas);
     m_canvas->drawPicture(picture);
 }
 
-void GraphicsContext::compositePicture(PassRefPtr<SkPicture> picture, const FloatRect& dest, const FloatRect& src, SkXfermode::Mode op)
+void GraphicsContext::compositePicture(sk_sp<SkPicture> picture, const FloatRect& dest, const FloatRect& src, SkXfermode::Mode op)
 {
     if (contextDisabled() || !picture)
         return;
     ASSERT(m_canvas);
 
     SkPaint picturePaint;
     picturePaint.setXfermodeMode(op);
     m_canvas->save();
     SkRect sourceBounds = src;
     SkRect skBounds = dest;
     SkMatrix pictureTransform;
     pictureTransform.setRectToRect(sourceBounds, skBounds, SkMatrix::kFill_ScaleToFit);
     m_canvas->concat(pictureTransform);
-    picturePaint.setImageFilter(SkPictureImageFilter::MakeForLocalSpace(toSkSp(picture), sourceBounds, static_cast<SkFilterQuality>(imageInterpolationQuality())));
+    picturePaint.setImageFilter(SkPictureImageFilter::MakeForLocalSpace(picture, sourceBounds, static_cast<SkFilterQuality>(imageInterpolationQuality())));

[f(malita), 2016/09/01 03:55:38]

std::move(picture)

[Łukasz Anforowicz, 2016/09/01 20:50:58]

Done.

     m_canvas->saveLayer(&sourceBounds, &picturePaint);
     m_canvas->restore();
     m_canvas->restore();
 }
 
 void GraphicsContext::drawFocusRingPath(const SkPath& path, const Color& color, int width)
 {
     drawPlatformFocusRing(path, m_canvas, color.rgb(), width);
 }
 
@@ skipping 885 matching lines @@
             p1.setX(p1.x() + 0.5f);
             p2.setX(p2.x() + 0.5f);
         } else {
             // We're a horizontal line. Adjust our y.
             p1.setY(p1.y() + 0.5f);
             p2.setY(p2.y() + 0.5f);
         }
     }
 }
 
-PassRefPtr<SkColorFilter> GraphicsContext::WebCoreColorFilterToSkiaColorFilter(ColorFilter colorFilter)
+sk_sp<SkColorFilter> GraphicsContext::WebCoreColorFilterToSkiaColorFilter(ColorFilter colorFilter)
 {
     switch (colorFilter) {
     case ColorFilterLuminanceToAlpha:
-        return fromSkSp(SkLumaColorFilter::Make());
+        return SkLumaColorFilter::Make();
     case ColorFilterLinearRGBToSRGB:
         return ColorSpaceUtilities::createColorSpaceFilter(ColorSpaceLinearRGB, ColorSpaceDeviceRGB);
     case ColorFilterSRGBToLinearRGB:
         return ColorSpaceUtilities::createColorSpaceFilter(ColorSpaceDeviceRGB, ColorSpaceLinearRGB);
     case ColorFilterNone:
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
@@ skipping 87 matching lines @@
     static const SkPMColor colors[] = {
         SkPreMultiplyARGB(0x60, 0xFF, 0x00, 0x00), // More transparent red
         SkPreMultiplyARGB(0x60, 0xC0, 0xC0, 0xC0)  // More transparent gray
     };
 
     return colors[index];
 }
 #endif
 
 } // namespace blink