Make 2D canvas smarter about chosing whether or not to use GPU acceleration

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 40 matching lines @@
     MaxCanvasAnimationBacklog = 2, // Make sure the the GPU is never more than two animation frames behind.
 };
 
 DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, canvas2DLayerBridgeInstanceCounter, ("Canvas2DLayerBridge"));
 }
 
 namespace blink {
 
 static PassRefPtr<SkSurface> createSkSurface(GrContext* gr, const IntSize& size, int msaaSampleCount, OpacityMode opacityMode)
 {
-    if (!gr)
-        return nullptr;
-    gr->resetContext();
-    SkImageInfo info = SkImageInfo::MakeN32Premul(size.width(), size.height());
+    if (gr)
+        gr->resetContext();
+
+    SkAlphaType alphaType = (Opaque == opacityMode) ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
+    SkImageInfo info = SkImageInfo::MakeN32(size.width(), size.height(), alphaType);
     SkSurfaceProps disableLCDProps(0, kUnknown_SkPixelGeometry);
-    RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRenderTarget(gr, SkSurface::kNo_Budgeted, info, msaaSampleCount,
-        Opaque == opacityMode ? 0 : &disableLCDProps));
+    RefPtr<SkSurface> surface;
+
+    if (gr)
+        surface = adoptRef(SkSurface::NewRenderTarget(gr, SkSurface::kNo_Budgeted, info, msaaSampleCount, Opaque == opacityMode ? 0 : &disableLCDProps));
+
+    if (!surface)
+        surface = adoptRef(SkSurface::NewRaster(info, Opaque == opacityMode ? 0 : &disableLCDProps));
+
     if (surface) {
         if (opacityMode == Opaque) {
             surface->getCanvas()->clear(SK_ColorBLACK);
         } else {
             surface->getCanvas()->clear(SK_ColorTRANSPARENT);
         }
     }
     return surface;
 }
 
-PassRefPtr<Canvas2DLayerBridge> Canvas2DLayerBridge::create(const IntSize& size, OpacityMode opacityMode, int msaaSampleCount)
+PassRefPtr<Canvas2DLayerBridge> Canvas2DLayerBridge::create(const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, AccelerationMode accelerationMode)
 {
     TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation", TRACE_EVENT_SCOPE_GLOBAL);
     OwnPtr<WebGraphicsContext3DProvider> contextProvider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
     if (!contextProvider)
         return nullptr;
-    RefPtr<SkSurface> surface(createSkSurface(contextProvider->grContext(), size, msaaSampleCount, opacityMode));
-    if (!surface)
-        return nullptr;
     RefPtr<Canvas2DLayerBridge> layerBridge;
-    layerBridge = adoptRef(new Canvas2DLayerBridge(contextProvider.release(), surface.release(), msaaSampleCount, opacityMode));
+    layerBridge = adoptRef(new Canvas2DLayerBridge(contextProvider.release(), size, msaaSampleCount, opacityMode, accelerationMode));
     return layerBridge.release();
 }
 
-Canvas2DLayerBridge::Canvas2DLayerBridge(PassOwnPtr<WebGraphicsContext3DProvider> contextProvider, PassRefPtr<SkSurface> surface, int msaaSampleCount, OpacityMode opacityMode)
-    : m_surface(surface)
-    , m_contextProvider(contextProvider)
+Canvas2DLayerBridge::Canvas2DLayerBridge(PassOwnPtr<WebGraphicsContext3DProvider> contextProvider, const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, AccelerationMode accelerationMode)
+    : m_contextProvider(contextProvider)
     , m_imageBuffer(0)
     , m_msaaSampleCount(msaaSampleCount)
     , m_bytesAllocated(0)
     , m_haveRecordedDrawCommands(false)
     , m_destructionInProgress(false)
     , m_filterQuality(kLow_SkFilterQuality)
     , m_isHidden(false)
     , m_isDeferralEnabled(true)
     , m_isRegisteredTaskObserver(false)
     , m_renderingTaskCompletedForCurrentFrame(false)
     , m_lastImageId(0)
     , m_lastFilter(GL_LINEAR)
+    , m_accelerationMode(accelerationMode)
     , m_opacityMode(opacityMode)
-    , m_size(m_surface->width(), m_surface->height())
+    , m_size(size)
 {
-    ASSERT(m_surface);
     ASSERT(m_contextProvider);
-    m_initialSurfaceSaveCount = m_surface->getCanvas()->getSaveCount();
     // Used by browser tests to detect the use of a Canvas2DLayerBridge.
     TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation", TRACE_EVENT_SCOPE_GLOBAL);
-    m_layer = adoptPtr(Platform::current()->compositorSupport()->createExternalTextureLayer(this));
-    m_layer->setOpaque(opacityMode == Opaque);
-    m_layer->setBlendBackgroundColor(opacityMode != Opaque);
-    GraphicsLayer::registerContentsLayer(m_layer->layer());
-    m_layer->setNearestNeighbor(m_filterQuality == kNone_SkFilterQuality);
     startRecording();
 #ifndef NDEBUG
     canvas2DLayerBridgeInstanceCounter.increment();
 #endif
 }
 
 Canvas2DLayerBridge::~Canvas2DLayerBridge()
 {
     ASSERT(m_destructionInProgress);
     m_layer.clear();
     ASSERT(m_mailboxes.size() == 0);
 #ifndef NDEBUG
     canvas2DLayerBridgeInstanceCounter.decrement();
 #endif
 }
 
 void Canvas2DLayerBridge::startRecording()
 {
     ASSERT(m_isDeferralEnabled);
     m_recorder = adoptPtr(new SkPictureRecorder);
     m_recorder->beginRecording(m_size.width(), m_size.height(), nullptr);
     if (m_imageBuffer) {
         m_imageBuffer->resetCanvas(m_recorder->getRecordingCanvas());
     }
     m_recordingPixelCount = 0;
 }
 
+bool Canvas2DLayerBridge::shouldAccelerate(AccelerationHint hint) const
+{
+    bool accelerate;
+    if (m_accelerationMode == ForceAccelerationForTesting)
+        accelerate = true;
+    else if (m_accelerationMode == DisableAcceleration)
+        accelerate = false;
+    else
+        accelerate = hint == PreferAcceleration;
+
+    if (accelerate && (!m_contextProvider || m_contextProvider->context3d()->isContextLost()))
+        accelerate = false;
+    return accelerate;
+}
+
+bool Canvas2DLayerBridge::isAccelerated() const
+{
+    if (m_layer) // We don't check m_surface, so this returns true if context was lost (m_surface is null) with restoration pending.
+        return true;
+    if (m_surface) // && !m_layer is implied
+        return false;
+
+    // Whether or not to accelerate is not yet resolved, determine whether immediate presentation
+    // of the canvas would result in the canvas being accelerated. Presentation is assumed to be
+    // a 'PreferAcceleration' operation.
+    return shouldAccelerate(PreferAcceleration);
+}
+
+SkSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint)
+{
+    if (!m_surface) {
+        if (m_layer)
+            return nullptr; // recreation will happen through restore()
+
+        bool accelerate = shouldAccelerate(hint);
+
+        if (accelerate && !m_layer) {
+            m_layer = adoptPtr(Platform::current()->compositorSupport()->createExternalTextureLayer(this));
+            m_layer->setOpaque(m_opacityMode == Opaque);
+            m_layer->setBlendBackgroundColor(m_opacityMode != Opaque);
+            GraphicsLayer::registerContentsLayer(m_layer->layer());
+            m_layer->setNearestNeighbor(m_filterQuality == kNone_SkFilterQuality);
+        }
+
+        m_surface = createSkSurface(accelerate ? m_contextProvider->grContext() : nullptr, m_size, m_msaaSampleCount, m_opacityMode);
+    }
+    return m_surface.get();
+}
+
 SkCanvas* Canvas2DLayerBridge::canvas()
 {
-    if (!m_isDeferralEnabled)
-        return m_surface->getCanvas();
+    if (!m_isDeferralEnabled) {
+        SkSurface* s = getOrCreateSurface();
+        return s ? s->getCanvas() : nullptr;
+    }
     return m_recorder->getRecordingCanvas();
 }
 
 void Canvas2DLayerBridge::disableDeferral()
 {
     // Disabling deferral is permanent: once triggered by disableDeferral()
     // we stay in immediate mode indefinitely. This is a performance heuristic
     // that significantly helps a number of use cases. The rationale is that if
     // immediate rendering was needed once, it is likely to be needed at least
     // once per frame, which eliminates the possibility for inter-frame
     // overdraw optimization. Furthermore, in cases where immediate mode is
     // required multiple times per frame, the repeated flushing of deferred
     // commands would cause significant overhead, so it is better to just stop
     // trying to defer altogether.
     if (!m_isDeferralEnabled)
         return;
 
     m_isDeferralEnabled = false;
     flushRecordingOnly();
     m_recorder.clear();
     // install the current matrix/clip stack onto the immediate canvas
-    m_imageBuffer->resetCanvas(m_surface->getCanvas());
+    m_imageBuffer->resetCanvas(getOrCreateSurface()->getCanvas());
 }
 
 void Canvas2DLayerBridge::setImageBuffer(ImageBuffer* imageBuffer)
 {
     m_imageBuffer = imageBuffer;
     if (m_imageBuffer && m_isDeferralEnabled) {
         m_imageBuffer->resetCanvas(m_recorder->getRecordingCanvas());
     }
 }
 
 void Canvas2DLayerBridge::beginDestruction()
 {
     ASSERT(!m_destructionInProgress);
     m_recorder.clear();
     m_imageBuffer = nullptr;
     m_destructionInProgress = true;
     setIsHidden(true);
-    GraphicsLayer::unregisterContentsLayer(m_layer->layer());
     m_surface.clear();
-    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();
-    // To anyone who ever hits this assert: Please update crbug.com/344666
-    // with repro steps.
+
     unregisterTaskObserver();
+
+    if (m_layer) {
+        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();
+    }
     ASSERT(!m_bytesAllocated);
 }
 
 void Canvas2DLayerBridge::unregisterTaskObserver()
 {
     if (m_isRegisteredTaskObserver) {
         Platform::current()->currentThread()->removeTaskObserver(this);
         m_isRegisteredTaskObserver = false;
     }
 }
@@ skipping 11 matching lines @@
     if (m_isHidden == newHiddenValue)
         return;
 
     m_isHidden = newHiddenValue;
     if (isHidden() && !m_destructionInProgress)
         flush();
 }
 
 bool Canvas2DLayerBridge::writePixels(const SkImageInfo& origInfo, const void* pixels, size_t rowBytes, int x, int y)
 {
-    if (!m_surface)
+    if (!getOrCreateSurface())
         return false;
     if (x <= 0 && y <= 0 && x + origInfo.width() >= m_size.width() && y + origInfo.height() >= m_size.height()) {
         skipQueuedDrawCommands();
     } else {
         flush();
     }
     ASSERT(!m_haveRecordedDrawCommands);
     // call write pixels on the surface, not the recording canvas.
     // No need to call beginDirectSurfaceAccessModeIfNeeded() because writePixels
     // ignores the matrix and clip state.
-    return m_surface->getCanvas()->writePixels(origInfo, pixels, rowBytes, x, y);
+    return getOrCreateSurface()->getCanvas()->writePixels(origInfo, pixels, rowBytes, x, y);
 }
 
 void Canvas2DLayerBridge::skipQueuedDrawCommands()
 {
     if (m_haveRecordedDrawCommands) {
         adoptRef(m_recorder->endRecording());
         startRecording();
         m_haveRecordedDrawCommands = false;
     }
 
     if (m_isDeferralEnabled) {
         unregisterTaskObserver();
         if (m_rateLimiter)
             m_rateLimiter->reset();
     }
 }
 
 void Canvas2DLayerBridge::flushRecordingOnly()
 {
     ASSERT(!m_destructionInProgress);
-    if (m_haveRecordedDrawCommands && m_surface) {
+
+    if (m_haveRecordedDrawCommands && getOrCreateSurface()) {
+        TRACE_EVENT0("cc", "Canvas2DLayerBridge::flushRecordingOnly");
         RefPtr<SkPicture> picture = adoptRef(m_recorder->endRecording());
-        picture->playback(m_surface->getCanvas());
+        picture->playback(getOrCreateSurface()->getCanvas());
         if (m_isDeferralEnabled)
             startRecording();
         m_haveRecordedDrawCommands = false;
     }
 }
 
 void Canvas2DLayerBridge::flush()
 {
-    if (!m_surface)
+    if (!getOrCreateSurface())
         return;
     TRACE_EVENT0("cc", "Canvas2DLayerBridge::flush");
     flushRecordingOnly();
-    m_surface->getCanvas()->flush();
+    getOrCreateSurface()->getCanvas()->flush();
 }
 
 void Canvas2DLayerBridge::flushGpu()
 {
+    TRACE_EVENT0("cc", "Canvas2DLayerBridge::flushGpu");
     flush();
     WebGraphicsContext3D* webContext = context();
     if (isAccelerated() && webContext)
         webContext->flush();
 }
 
 
 WebGraphicsContext3D* Canvas2DLayerBridge::context()
 {
     // Check on m_layer is necessary because context() may be called during
     // the destruction of m_layer
     if (m_layer && !m_destructionInProgress)
         checkSurfaceValid(); // To ensure rate limiter is disabled if context is lost.
     return m_contextProvider ? m_contextProvider->context3d() : 0;
 }
 
 bool Canvas2DLayerBridge::checkSurfaceValid()
 {
     ASSERT(!m_destructionInProgress);
-    if (m_destructionInProgress || !m_surface)
+    if (m_destructionInProgress)
+        return false;
+    if (!m_layer)
+        return true;
+    if (!m_surface)
         return false;
     if (m_contextProvider->context3d()->isContextLost()) {
         m_surface.clear();
         for (auto mailboxInfo = m_mailboxes.begin(); mailboxInfo != m_mailboxes.end(); ++mailboxInfo) {
             if (mailboxInfo->m_image)
                 mailboxInfo->m_image.clear();
         }
         if (m_imageBuffer)
             m_imageBuffer->notifySurfaceInvalid();
     }
     return m_surface;
 }
 
 bool Canvas2DLayerBridge::restoreSurface()
 {
     ASSERT(!m_destructionInProgress);
     if (m_destructionInProgress)
         return false;
-    ASSERT(m_layer && !m_surface);
+    ASSERT(isAccelerated() && !m_surface);
 
     WebGraphicsContext3D* sharedContext = 0;
     m_layer->clearTexture();
     m_contextProvider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
     if (m_contextProvider)
         sharedContext = m_contextProvider->context3d();
 
     if (sharedContext && !sharedContext->isContextLost()) {
         GrContext* grCtx = m_contextProvider->grContext();
         RefPtr<SkSurface> surface(createSkSurface(grCtx, m_size, m_msaaSampleCount, m_opacityMode));
         if (surface.get()) {
             m_surface = surface.release();
-            m_initialSurfaceSaveCount = m_surface->getCanvas()->getSaveCount();
             // FIXME: draw sad canvas picture into new buffer crbug.com/243842
         }
     }
 
     return m_surface;
 }
 
 bool Canvas2DLayerBridge::prepareMailbox(WebExternalTextureMailbox* outMailbox, WebExternalBitmap* bitmap)
 {
+    ASSERT(isAccelerated());
     if (m_destructionInProgress) {
         // It can be hit in the following sequence.
         // 1. Canvas draws something.
         // 2. The compositor begins the frame.
         // 3. Javascript makes a context be lost.
         // 4. Here.
         return false;
     }
     if (bitmap) {
         // Using accelerated 2d canvas with software renderer, which
         // should only happen in tests that use fake graphics contexts
         // or in Android WebView in software mode. In this case, we do
         // not care about producing any results for this canvas.
         skipQueuedDrawCommands();
         m_lastImageId = 0;
         return false;
     }
     if (!checkSurfaceValid())
         return false;
 
     WebGraphicsContext3D* webContext = context();
 
-    RefPtr<SkImage> image = newImageSnapshot();
+    RefPtr<SkImage> image = newImageSnapshot(PreferAcceleration);
 
     // Early exit if canvas was not drawn to since last prepareMailbox
     GLenum filter = m_filterQuality == kNone_SkFilterQuality ? GL_NEAREST : GL_LINEAR;
     if (image->uniqueID() == m_lastImageId && filter == m_lastFilter)
         return false;
     m_lastImageId = image->uniqueID();
     m_lastFilter = filter;
 
     {
         MailboxInfo tmp;
@@ skipping 50 matching lines @@
     // Because we are changing the texture binding without going through skia,
     // we must dirty the context.
     grContext->resetContext(kTextureBinding_GrGLBackendState);
 
     *outMailbox = mailboxInfo.m_mailbox;
     return true;
 }
 
 void Canvas2DLayerBridge::mailboxReleased(const WebExternalTextureMailbox& mailbox, bool lostResource)
 {
+    ASSERT(isAccelerated());
     bool contextLost = !m_surface || m_contextProvider->context3d()->isContextLost();
     ASSERT(m_mailboxes.last().m_parentLayerBridge.get() == this);
 
     // Mailboxes are typically released in FIFO order, so we iterate
     // from the end of m_mailboxes.
     auto releasedMailboxInfo = m_mailboxes.end();
     auto firstMailbox = m_mailboxes.begin();
 
     while (true) {
         --releasedMailboxInfo;
         if (nameEquals(releasedMailboxInfo->m_mailbox, mailbox)) {
             break;
         }
-        if (releasedMailboxInfo == firstMailbox) {
-            // Reached last entry without finding a match, should never happen.
-            // FIXME: This used to be an ASSERT, and was (temporarily?) changed to a
-            // CRASH to facilitate the investigation of crbug.com/443898.
-            CRASH();
-        }
+        ASSERT(releasedMailboxInfo == firstMailbox);
     }
 
     if (!contextLost) {
         // Invalidate texture state in case the compositor altered it since the copy-on-write.
         if (releasedMailboxInfo->m_image) {
             if (mailbox.syncPoint) {
                 context()->waitSyncPoint(mailbox.syncPoint);
             }
             GrTexture* texture = releasedMailboxInfo->m_image->getTexture();
             if (texture) {
@@ skipping 37 matching lines @@
         if (m_recordingPixelCount >= (m_size.width() * m_size.height() * ExpensiveCanvasHeuristicParameters::ExpensiveOverdrawThreshold)) {
             disableDeferral();
         }
     }
     if (!m_isRegisteredTaskObserver) {
         Platform::current()->currentThread()->addTaskObserver(this);
         m_isRegisteredTaskObserver = true;
     }
 }
 
+void Canvas2DLayerBridge::prepareSurfaceForPaintingIfNeeded()
+{
+    getOrCreateSurface(PreferAcceleration);
+}
+
 void Canvas2DLayerBridge::finalizeFrame(const FloatRect &dirtyRect)
 {
     ASSERT(!m_destructionInProgress);
     m_layer->layer()->invalidateRect(enclosingIntRect(dirtyRect));
     if (m_rateLimiter)
         m_rateLimiter->reset();
     m_renderingTaskCompletedForCurrentFrame = false;
 }
 
 void Canvas2DLayerBridge::didProcessTask()
@@ skipping 21 matching lines @@
 
     m_renderingTaskCompletedForCurrentFrame = true;
     unregisterTaskObserver();
 }
 
 void Canvas2DLayerBridge::willProcessTask()
 {
     ASSERT_NOT_REACHED();
 }
 
-PassRefPtr<SkImage> Canvas2DLayerBridge::newImageSnapshot()
+PassRefPtr<SkImage> Canvas2DLayerBridge::newImageSnapshot(AccelerationHint hint)
 {
     if (!checkSurfaceValid())
         return nullptr;
+    getOrCreateSurface(hint);
     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.
-    m_surface->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode);
+    getOrCreateSurface()->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode);
     return adoptRef(m_surface->newImageSnapshot());
 }
 
 void Canvas2DLayerBridge::willOverwriteCanvas()
 {
     skipQueuedDrawCommands();
 }
 
 Canvas2DLayerBridge::MailboxInfo::MailboxInfo(const MailboxInfo& other) {
     memcpy(&m_mailbox, &other.m_mailbox, sizeof(m_mailbox));
     m_image = other.m_image;
     m_parentLayerBridge = other.m_parentLayerBridge;
 }
 
 } // namespace blink