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

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

 /*
  * Copyright (C) 2012 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 42 matching lines @@
 
 namespace {
 enum {
     InvalidMailboxIndex = -1,
     MaxCanvasAnimationBacklog = 2, // Make sure the the GPU is never more than two animation frames behind.
 };
 } // namespace
 
 namespace blink {
 
-static PassRefPtr<SkSurface> createSkSurface(GrContext* gr, const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, sk_sp<SkColorSpace> colorSpace, bool* surfaceIsAccelerated)
+static sk_sp<SkSurface> createSkSurface(GrContext* gr, const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, sk_sp<SkColorSpace> colorSpace, bool* surfaceIsAccelerated)
 {
     if (gr)
         gr->resetContext();
 
     SkAlphaType alphaType = (Opaque == opacityMode) ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
     SkImageInfo info = SkImageInfo::MakeN32(size.width(), size.height(), alphaType, colorSpace);
     SkSurfaceProps disableLCDProps(0, kUnknown_SkPixelGeometry);
     sk_sp<SkSurface> surface;
 
     if (gr) {
         *surfaceIsAccelerated = true;
         surface = SkSurface::MakeRenderTarget(gr, SkBudgeted::kNo, info, msaaSampleCount, Opaque == opacityMode ? 0 : &disableLCDProps);
     }
 
     if (!surface) {
         *surfaceIsAccelerated = false;
         surface = SkSurface::MakeRaster(info, Opaque == opacityMode ? 0 : &disableLCDProps);
     }
 
     if (surface) {
         if (opacityMode == Opaque) {
             surface->getCanvas()->clear(SK_ColorBLACK);
         } else {
             surface->getCanvas()->clear(SK_ColorTRANSPARENT);
         }
     }
-    return fromSkSp(surface);
+    return surface;
 }
 
 Canvas2DLayerBridge::Canvas2DLayerBridge(std::unique_ptr<WebGraphicsContext3DProvider> contextProvider, const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, AccelerationMode accelerationMode, sk_sp<SkColorSpace> colorSpace)
     : m_contextProvider(std::move(contextProvider))
     , m_logger(wrapUnique(new Logger))
     , m_weakPtrFactory(this)
     , m_imageBuffer(0)
     , m_msaaSampleCount(msaaSampleCount)
     , m_bytesAllocated(0)
     , m_haveRecordedDrawCommands(false)
@@ skipping 184 matching lines @@
 }
 #endif // USE_IOSURFACE_FOR_2D_CANVAS
 
 void Canvas2DLayerBridge::createMailboxInfo()
 {
     MailboxInfo tmp;
     tmp.m_parentLayerBridge = this;
     m_mailboxes.prepend(tmp);
 }
 
-bool Canvas2DLayerBridge::prepareMailboxFromImage(PassRefPtr<SkImage> image,
+bool Canvas2DLayerBridge::prepareMailboxFromImage(sk_sp<SkImage> image,
     cc::TextureMailbox* outMailbox)
 {
     createMailboxInfo();
     MailboxInfo& mailboxInfo = m_mailboxes.first();
 
     GrContext* grContext = m_contextProvider->grContext();
     if (!grContext) {
-        mailboxInfo.m_image = image;
+        mailboxInfo.m_image = std::move(image);
         return true; // for testing: skip gl stuff when using a mock graphics context.
     }
 
 #if USE_IOSURFACE_FOR_2D_CANVAS
     if (RuntimeEnabledFeatures::canvas2dImageChromiumEnabled()) {
         if (prepareIOSurfaceMailboxFromImage(image.get(), outMailbox))
             return true;
         // Note: if IOSurface backed texture creation failed we fall back to the
         // non-IOSurface path.
     }
 #endif // USE_IOSURFACE_FOR_2D_CANVAS
 
-    mailboxInfo.m_image = image;
+    mailboxInfo.m_image = std::move(image);
 
     if (RuntimeEnabledFeatures::forceDisable2dCanvasCopyOnWriteEnabled())
         m_surface->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode);
 
     // Need to flush skia's internal queue because texture is about to be accessed directly
     grContext->flush();
 
     // Because of texture sharing with the compositor, we must invalidate
     // the state cached in skia so that the deferred copy on write
     // in SkSurface_Gpu does not make any false assumptions.
@@ skipping 11 matching lines @@
     gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
     gpu::Mailbox mailbox;
     gl->GenMailboxCHROMIUM(mailbox.name);
     gl->ProduceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
 
     gpu::SyncToken syncToken;
     if (isHidden()) {
         // With hidden canvases, we release the SkImage immediately because
         // there is no need for animations to be double buffered.
-        mailboxInfo.m_image.clear();
+        mailboxInfo.m_image.reset();
     } else {
         // FIXME: We'd rather insert a syncpoint than perform a flush here,
         // but currently the canvas will flicker if we don't flush here.
         const GLuint64 fenceSync = gl->InsertFenceSyncCHROMIUM();
         gl->Flush();
         gl->GenSyncTokenCHROMIUM(fenceSync, syncToken.GetData());
     }
     mailboxInfo.m_mailbox = mailbox;
     *outMailbox = cc::TextureMailbox(mailbox, syncToken, GL_TEXTURE_2D);
 
@@ skipping 64 matching lines @@
     // exactly one failure or exit event.
     flushRecordingOnly();
     // The following checks that the flush succeeded, which should always be the
     // case because flushRecordingOnly should only fail it it fails to allocate
     // a surface, and we have an early exit at the top of this function for when
     // 'this' does not already have a surface.
     DCHECK(!m_haveRecordedDrawCommands);
     SkPaint copyPaint;
     copyPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
     m_surface->draw(tempHibernationSurface->getCanvas(), 0, 0, &copyPaint); // GPU readback
-    m_hibernationImage = fromSkSp(tempHibernationSurface->makeImageSnapshot());
-    m_surface.clear(); // destroy the GPU-backed buffer
+    m_hibernationImage = tempHibernationSurface->makeImageSnapshot();
+    m_surface.reset(); // destroy the GPU-backed buffer
     m_layer->clearTexture();
 #if USE_IOSURFACE_FOR_2D_CANVAS
     clearCHROMIUMImageCache();
 #endif // USE_IOSURFACE_FOR_2D_CANVAS
     m_logger->didStartHibernating();
 }
 
 void Canvas2DLayerBridge::reportSurfaceCreationFailure()
 {
     if (!m_surfaceCreationFailedAtLeastOnce) {
@@ skipping 40 matching lines @@
         } else {
             if (isHidden())
                 m_logger->reportHibernationEvent(HibernationEndedWithSwitchToBackgroundRendering);
             else
                 m_logger->reportHibernationEvent(HibernationEndedWithFallbackToSW);
         }
 
         SkPaint copyPaint;
         copyPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
         m_surface->getCanvas()->drawImage(m_hibernationImage.get(), 0, 0, &copyPaint);
-        m_hibernationImage.clear();
+        m_hibernationImage.reset();
 
         if (m_imageBuffer)
             m_imageBuffer->updateGPUMemoryUsage();
 
         if (m_imageBuffer && !m_isDeferralEnabled)
             m_imageBuffer->resetCanvas(m_surface->getCanvas());
     }
 
     return m_surface.get();
 }
@@ skipping 44 matching lines @@
         m_imageBuffer->resetCanvas(m_recorder->getRecordingCanvas());
     }
 }
 
 void Canvas2DLayerBridge::beginDestruction()
 {
     if (m_destructionInProgress)
         return;
     if (isHibernating())
         m_logger->reportHibernationEvent(HibernationEndedWithTeardown);
-    m_hibernationImage.clear();
+    m_hibernationImage.reset();
     m_recorder.reset();
     m_imageBuffer = nullptr;
     m_destructionInProgress = true;
     setIsHidden(true);
-    m_surface.clear();
+    m_surface.reset();
 
     unregisterTaskObserver();
 
     if (m_layer && m_accelerationMode != DisableAcceleration) {
         GraphicsLayer::unregisterContentsLayer(m_layer->layer());
         m_layer->clearTexture();
         // Orphaning the layer is required to trigger the recration of a new layer
         // in the case where destruction is caused by a canvas resize. Test:
         // virtual/gpu/fast/canvas/canvas-resize-after-paint-without-layout.html
         m_layer->layer()->removeFromParent();
@@ skipping 29 matching lines @@
         if (m_layer)
             m_layer->clearTexture();
         m_logger->reportHibernationEvent(HibernationScheduled);
         m_hibernationScheduled = true;
         Platform::current()->currentThread()->scheduler()->postIdleTask(BLINK_FROM_HERE, WTF::bind(&hibernateWrapper, m_weakPtrFactory.createWeakPtr()));
     }
     if (!isHidden() && m_softwareRenderingWhileHidden) {
         flushRecordingOnly();
         SkPaint copyPaint;
         copyPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
-        RefPtr<SkSurface> oldSurface = m_surface.release();
+
+        sk_sp<SkSurface> oldSurface = std::move(m_surface);
+        m_surface.reset();
+
         m_softwareRenderingWhileHidden = false;
         SkSurface* newSurface = getOrCreateSurface(PreferAccelerationAfterVisibilityChange);
         if (newSurface) {
             if (oldSurface)
                 oldSurface->draw(newSurface->getCanvas(), 0, 0, &copyPaint);
             if (m_imageBuffer && !m_isDeferralEnabled) {
                 m_imageBuffer->resetCanvas(m_surface->getCanvas());
             }
         }
     }
@@ skipping 82 matching lines @@
     DCHECK(!m_destructionInProgress);
     if (m_destructionInProgress)
         return false;
     if (isHibernating())
         return true;
     if (!m_layer || m_accelerationMode == DisableAcceleration)
         return true;
     if (!m_surface)
         return false;
     if (m_contextProvider->contextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
-        m_surface.clear();
+        m_surface.reset();
         for (auto mailboxInfo = m_mailboxes.begin(); mailboxInfo != m_mailboxes.end(); ++mailboxInfo) {
             if (mailboxInfo->m_image)
-                mailboxInfo->m_image.clear();
+                mailboxInfo->m_image.reset();
         }
         if (m_imageBuffer)
             m_imageBuffer->notifySurfaceInvalid();
         CanvasMetrics::countCanvasContextUsage(CanvasMetrics::Accelerated2DCanvasGPUContextLost);
     }
     return m_surface.get();
 }
 
 bool Canvas2DLayerBridge::restoreSurface()
 {
     DCHECK(!m_destructionInProgress);
     if (m_destructionInProgress)
         return false;
     DCHECK(isAccelerated() && !m_surface);
 
     gpu::gles2::GLES2Interface* sharedGL = nullptr;
     m_layer->clearTexture();
     m_contextProvider = wrapUnique(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
     if (m_contextProvider)
         sharedGL = m_contextProvider->contextGL();
 
     if (sharedGL && sharedGL->GetGraphicsResetStatusKHR() == GL_NO_ERROR) {
         GrContext* grCtx = m_contextProvider->grContext();
         bool surfaceIsAccelerated;
-        RefPtr<SkSurface> surface(createSkSurface(grCtx, m_size, m_msaaSampleCount, m_opacityMode, m_colorSpace, &surfaceIsAccelerated));
+        sk_sp<SkSurface> surface(createSkSurface(grCtx, m_size, m_msaaSampleCount, m_opacityMode, m_colorSpace, &surfaceIsAccelerated));
 
         if (!m_surface)
             reportSurfaceCreationFailure();
 
         // Current paradigm does support switching from accelerated to non-accelerated, which would be tricky
         // due to changes to the layer tree, which can only happen at specific times during the document lifecycle.
         // Therefore, we can only accept the restored surface if it is accelerated.
         if (surface && surfaceIsAccelerated) {
-            m_surface = surface.release();
+            m_surface = std::move(surface);
             // FIXME: draw sad canvas picture into new buffer crbug.com/243842
         }
     }
     if (m_imageBuffer)
         m_imageBuffer->updateGPUMemoryUsage();
 
     return m_surface.get();
 }
 
 static gfx::ColorSpace SkColorSpaceToColorSpace(const SkColorSpace* skColorSpace)
@@ skipping 39 matching lines @@
     // hibernation
     if ((isHibernating() || m_softwareRenderingWhileHidden) && isHidden())
         return false;
 
     // If the context is lost, we don't know if we should be producing GPU or
     // software frames, until we get a new context, since the compositor will
     // be trying to get a new context and may change modes.
     if (m_contextProvider->contextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR)
         return false;
 
-    RefPtr<SkImage> image = newImageSnapshot(PreferAcceleration, SnapshotReasonUnknown);
+    sk_sp<SkImage> image = newImageSnapshot(PreferAcceleration, SnapshotReasonUnknown);
     if (!image || !image->getTexture())
         return false;
 
     // Early exit if canvas was not drawn to since last prepareMailbox.
     GLenum filter = getGLFilter();
     if (image->uniqueID() == m_lastImageId && filter == m_lastFilter)
         return false;
     m_lastImageId = image->uniqueID();
     m_lastFilter = filter;
 
-    if (!prepareMailboxFromImage(image.release(), outMailbox))
+    if (!prepareMailboxFromImage(std::move(image), outMailbox))
         return false;
     outMailbox->set_nearest_neighbor(getGLFilter() == GL_NEAREST);
     gfx::ColorSpace colorSpace = SkColorSpaceToColorSpace(m_colorSpace.get());
     outMailbox->set_color_space(colorSpace);
 
     auto func = WTF::bind(&Canvas2DLayerBridge::mailboxReleased,
         m_weakPtrFactory.createWeakPtr(),
         outMailbox->mailbox());
     *outReleaseCallback = cc::SingleReleaseCallback::Create(
         convertToBaseCallback(std::move(func)));
@@ skipping 131 matching lines @@
 
     m_renderingTaskCompletedForCurrentFrame = true;
     unregisterTaskObserver();
 }
 
 void Canvas2DLayerBridge::willProcessTask()
 {
     NOTREACHED();
 }
 
-PassRefPtr<SkImage> Canvas2DLayerBridge::newImageSnapshot(AccelerationHint hint, SnapshotReason)
+sk_sp<SkImage> Canvas2DLayerBridge::newImageSnapshot(AccelerationHint hint, SnapshotReason)
 {
     if (isHibernating())
         return m_hibernationImage;
     if (!checkSurfaceValid())
         return nullptr;
     if (!getOrCreateSurface(hint))
         return nullptr;
     flush();
     // A readback operation may alter the texture parameters, which may affect
     // the compositor's behavior. Therefore, we must trigger copy-on-write
     // even though we are not technically writing to the texture, only to its
     // parameters.
     getOrCreateSurface()->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode);
-    return fromSkSp(m_surface->makeImageSnapshot());
+    return m_surface->makeImageSnapshot();
 }
 
 void Canvas2DLayerBridge::willOverwriteCanvas()
 {
     skipQueuedDrawCommands();
 }
 
 #if USE_IOSURFACE_FOR_2D_CANVAS
 Canvas2DLayerBridge::ImageInfo::ImageInfo(GLuint imageId, GLuint textureId) : m_imageId(imageId), m_textureId(textureId)
 {
@@ skipping 10 matching lines @@
 Canvas2DLayerBridge::MailboxInfo::MailboxInfo() = default;
 Canvas2DLayerBridge::MailboxInfo::MailboxInfo(const MailboxInfo& other) = default;
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(HibernationEvent event)
 {
     DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernationHistogram, ("Canvas.HibernationEvents", HibernationEventCount));
     hibernationHistogram.count(event);
 }
 
 } // namespace blink