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

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

 /*
  * 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 35 matching lines @@
 #include "third_party/skia/include/core/SkStream.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/HexNumber.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/Base64.h"
 #include "wtf/text/TextEncoding.h"
 #include <memory>
 
 namespace blink {
 
-PictureSnapshot::PictureSnapshot(PassRefPtr<const SkPicture> picture)
+PictureSnapshot::PictureSnapshot(sk_sp<const SkPicture> picture)
     : m_picture(picture)

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

std::move(picture)

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

Done.

 {
 }
 
 static bool decodeBitmap(const void* data, size_t length, SkBitmap* result)
 {
     // No need to copy the data; this decodes immediately.
     RefPtr<SegmentReader> segmentReader = SegmentReader::createFromSkData(SkData::MakeWithoutCopy(data, length));
     std::unique_ptr<ImageDecoder> imageDecoder = ImageDecoder::create(segmentReader.release(), true,
         ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileIgnored);
     if (!imageDecoder)
@@ skipping 16 matching lines @@
         SkMemoryStream stream(tileStream->data.begin(), tileStream->data.size());
         sk_sp<SkPicture> picture = SkPicture::MakeFromStream(&stream, decodeBitmap);
         if (!picture)
             return nullptr;
         FloatRect cullRect(picture->cullRect());
         cullRect.moveBy(tileStream->layerOffset);
         unionRect.unite(cullRect);
         pictures.append(std::move(picture));
     }
     if (tiles.size() == 1)
-        return adoptRef(new PictureSnapshot(fromSkSp(std::move(pictures[0]))));
+        return adoptRef(new PictureSnapshot(std::move(pictures[0])));
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(unionRect.width(), unionRect.height(), 0, 0);
     for (size_t i = 0; i < pictures.size(); ++i) {
         canvas->save();
         canvas->translate(tiles[i]->layerOffset.x() - unionRect.x(), tiles[i]->layerOffset.y() - unionRect.y());
         pictures[i]->playback(canvas, 0);
         canvas->restore();
     }
-    return adoptRef(new PictureSnapshot(fromSkSp(recorder.finishRecordingAsPicture())));
+    return adoptRef(new PictureSnapshot(recorder.finishRecordingAsPicture()));
 }
 
 bool PictureSnapshot::isEmpty() const
 {
     return m_picture->cullRect().isEmpty();
 }
 
 std::unique_ptr<Vector<char>> PictureSnapshot::replay(unsigned fromStep, unsigned toStep, double scale) const
 {
     const SkIRect bounds = m_picture->cullRect().roundOut();
@@ skipping 10 matching lines @@
         SkAutoCanvasRestore autoRestore(&canvas, false);
         canvas.saveLayer(nullptr, nullptr);
 
         canvas.scale(scale, scale);
         canvas.resetStepCount();
         m_picture->playback(&canvas, &canvas);
     }
     std::unique_ptr<Vector<char>> base64Data = wrapUnique(new Vector<char>());
     Vector<char> encodedImage;
 
-    RefPtr<SkImage> image = fromSkSp(SkImage::MakeFromBitmap(bitmap));
+    sk_sp<SkImage> image = SkImage::MakeFromBitmap(bitmap);
     if (!image)
         return nullptr;
 
     ImagePixelLocker pixelLocker(image, kUnpremul_SkAlphaType, kRGBA_8888_SkColorType);
     ImageDataBuffer imageData(IntSize(image->width(), image->height()),
         static_cast<const unsigned char*>(pixelLocker.pixels()));
     if (!PNGImageEncoder::encode(imageData, reinterpret_cast<Vector<unsigned char>*>(&encodedImage)))
         return nullptr;
 
     base64Encode(encodedImage, *base64Data);
@@ skipping 30 matching lines @@
 
 std::unique_ptr<JSONArray> PictureSnapshot::snapshotCommandLog() const
 {
     const SkIRect bounds = m_picture->cullRect().roundOut();
     LoggingCanvas canvas(bounds.width(), bounds.height());
     m_picture->playback(&canvas);
     return canvas.log();
 }
 
 } // namespace blink