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

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/RecordingImageBufferSurface.h"
 
 #include "platform/Histogram.h"
 #include "platform/graphics/CanvasMetrics.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/GraphicsContext.h"
@@ skipping 69 matching lines @@
     }
 
     DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, canvasFallbackHistogram, new EnumerationHistogram("Canvas.DisplayListFallbackReason", FallbackReasonCount));
     canvasFallbackHistogram.count(reason);
 
     m_fallbackSurface = m_fallbackFactory->createSurface(size(), getOpacityMode(), colorSpace());
     m_fallbackSurface->setImageBuffer(m_imageBuffer);
 
     if (m_previousFrame) {
         m_previousFrame->playback(m_fallbackSurface->canvas());
-        m_previousFrame.clear();
+        m_previousFrame.reset();
     }
 
     if (m_currentFrame) {
         m_currentFrame->finishRecordingAsPicture()->playback(m_fallbackSurface->canvas());
         m_currentFrame.reset();
     }
 
     if (m_imageBuffer) {
         m_imageBuffer->resetCanvas(m_fallbackSurface->canvas());
     }
@@ skipping 28 matching lines @@
         return RecordingImageBufferSurface::FallbackReasonSnapshotForUnitTests;
     case SnapshotReasonGetCopiedImage:
         return RecordingImageBufferSurface::FallbackReasonSnapshotGetCopiedImage;
     case SnapshotReasonWebGLDrawImageIntoBuffer:
         return RecordingImageBufferSurface::FallbackReasonSnapshotWebGLDrawImageIntoBuffer;
     }
     ASSERT_NOT_REACHED();
     return RecordingImageBufferSurface::FallbackReasonUnknown;
 }
 
-PassRefPtr<SkImage> RecordingImageBufferSurface::newImageSnapshot(AccelerationHint hint, SnapshotReason reason)
+sk_sp<SkImage> RecordingImageBufferSurface::newImageSnapshot(AccelerationHint hint, SnapshotReason reason)
 {
     if (!m_fallbackSurface)
         fallBackToRasterCanvas(snapshotReasonToFallbackReason(reason));
     return m_fallbackSurface->newImageSnapshot(hint, reason);
 }
 
 SkCanvas* RecordingImageBufferSurface::canvas()
 {
     if (m_fallbackSurface)
         return m_fallbackSurface->canvas();
@@ skipping 26 matching lines @@
     ASSERT_NOT_REACHED();
     return RecordingImageBufferSurface::FallbackReasonUnknown;
 }
 
 void RecordingImageBufferSurface::disableDeferral(DisableDeferralReason reason)
 {
     if (!m_fallbackSurface)
         fallBackToRasterCanvas(disableDeferralReasonToFallbackReason(reason));
 }
 
-PassRefPtr<SkPicture> RecordingImageBufferSurface::getPicture()
+sk_sp<SkPicture> RecordingImageBufferSurface::getPicture()
 {
     if (m_fallbackSurface)
         return nullptr;
 
     FallbackReason fallbackReason = FallbackReasonUnknown;
     bool canUsePicture = finalizeFrameInternal(&fallbackReason);
     m_imageBuffer->didFinalizeFrame();
 
     ASSERT(canUsePicture || m_fallbackFactory);
 
@@ skipping 35 matching lines @@
 void RecordingImageBufferSurface::flush(FlushReason reason)
 {
     if (!m_fallbackSurface)
         fallBackToRasterCanvas(flushReasonToFallbackReason(reason));
     m_fallbackSurface->flush(reason);
 }
 
 void RecordingImageBufferSurface::willOverwriteCanvas()
 {
     m_frameWasCleared = true;
-    m_previousFrame.clear();
+    m_previousFrame.reset();
     m_previousFrameHasExpensiveOp = false;
     m_previousFramePixelCount = 0;
     if (m_didRecordDrawCommandsInCurrentFrame) {
         // Discard previous draw commands
         m_currentFrame->finishRecordingAsPicture();
         initializeCurrentFrame();
     }
 }
 
 void RecordingImageBufferSurface::didDraw(const FloatRect& rect)
 {
     m_didRecordDrawCommandsInCurrentFrame = true;
     IntRect pixelBounds = enclosingIntRect(rect);
     m_currentFramePixelCount += pixelBounds.width() * pixelBounds.height();
 }
 
 bool RecordingImageBufferSurface::finalizeFrameInternal(FallbackReason* fallbackReason)
 {
     CHECK(!m_fallbackSurface);
     CHECK(m_currentFrame);
     ASSERT(m_currentFrame->getRecordingCanvas());
     ASSERT(fallbackReason);
     ASSERT(*fallbackReason == FallbackReasonUnknown);
 
     if (!m_imageBuffer->isDirty()) {
         if (!m_previousFrame) {
             // Create an initial blank frame
-            m_previousFrame = fromSkSp(m_currentFrame->finishRecordingAsPicture());
+            m_previousFrame = m_currentFrame->finishRecordingAsPicture();
             initializeCurrentFrame();
         }
         CHECK(m_currentFrame);
         return true;
     }
 
     if (!m_frameWasCleared) {
         *fallbackReason = FallbackReasonCanvasNotClearedBetweenFrames;
         return false;
     }
 
     if (m_fallbackFactory && m_currentFrame->getRecordingCanvas()->getSaveCount() > ExpensiveCanvasHeuristicParameters::ExpensiveRecordingStackDepth) {
         *fallbackReason = FallbackReasonRunawayStateStack;
         return false;
     }
 
-    m_previousFrame = fromSkSp(m_currentFrame->finishRecordingAsPicture());
+    m_previousFrame = m_currentFrame->finishRecordingAsPicture();
     m_previousFrameHasExpensiveOp = m_currentFrameHasExpensiveOp;
     m_previousFramePixelCount = m_currentFramePixelCount;
     initializeCurrentFrame();
 
     m_frameWasCleared = false;
     return true;
 }
 
 void RecordingImageBufferSurface::draw(GraphicsContext& context, const FloatRect& destRect, const FloatRect& srcRect, SkXfermode::Mode op)
 {
     if (m_fallbackSurface) {
         m_fallbackSurface->draw(context, destRect, srcRect, op);
         return;
     }
 
-    RefPtr<SkPicture> picture = getPicture();
+    sk_sp<SkPicture> picture = getPicture();
     if (picture) {
-        context.compositePicture(picture.get(), destRect, srcRect, op);
+        context.compositePicture(std::move(picture), destRect, srcRect, op);
     } else {
         ImageBufferSurface::draw(context, destRect, srcRect, op);
     }
 }
 
 bool RecordingImageBufferSurface::isExpensiveToPaint()
 {
     if (m_fallbackSurface)
         return m_fallbackSurface->isExpensiveToPaint();
 
@@ skipping 44 matching lines @@
 
 void RecordingImageBufferSurface::setIsHidden(bool hidden)
 {
     if (m_fallbackSurface)
         m_fallbackSurface->setIsHidden(hidden);
     else
         ImageBufferSurface::setIsHidden(hidden);
 }
 
 } // namespace blink