Implementation of 2D canvas context lost/restored events

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 65 matching lines @@
         return nullptr;
     RefPtr<Canvas2DLayerBridge> layerBridge;
     OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
     layerBridge = adoptRef(new Canvas2DLayerBridge(contextProvider.release(), canvas.release(), msaaSampleCount, opacityMode));
     return layerBridge.release();
 }
 
 Canvas2DLayerBridge::Canvas2DLayerBridge(PassOwnPtr<blink::WebGraphicsContext3DProvider> contextProvider, PassOwnPtr<SkDeferredCanvas> canvas, int msaaSampleCount, OpacityMode opacityMode)
     : m_canvas(canvas)
     , m_contextProvider(contextProvider)
+    , m_imageBuffer(0)
     , m_msaaSampleCount(msaaSampleCount)
     , m_bytesAllocated(0)
     , m_didRecordDrawCommand(false)
-    , m_surfaceIsValid(true)
+    , m_isSurfaceValid(true)
     , m_framesPending(0)
     , m_framesSinceMailboxRelease(0)
     , m_destructionInProgress(false)
     , m_rateLimitingEnabled(false)
     , m_isHidden(false)
     , m_next(0)
     , m_prev(0)
     , m_lastImageId(0)
     , m_releasedMailboxInfoIndex(InvalidMailboxIndex)
 {
@@ skipping 28 matching lines @@
 #ifndef NDEBUG
     canvas2DLayerBridgeInstanceCounter.decrement();
 #endif
 }
 
 void Canvas2DLayerBridge::beginDestruction()
 {
     ASSERT(!m_destructionInProgress);
     setRateLimitingEnabled(false);
     m_canvas->silentFlush();
+    m_imageBuffer = 0;
     freeTransientResources();
     setIsHidden(true);
     m_destructionInProgress = true;
     GraphicsLayer::unregisterContentsLayer(m_layer->layer());
     m_canvas->setNotificationClient(0);
     m_canvas.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
@@ skipping 52 matching lines @@
     ++m_framesSinceMailboxRelease;
     if (releasedMailboxHasExpired()) {
         freeReleasedMailbox();
     }
 }
 
 void Canvas2DLayerBridge::prepareForDraw()
 {
     ASSERT(!m_destructionInProgress);
     ASSERT(m_layer);
-    if (!surfaceIsValid() && !recoverSurface()) {
+    if (!checkSurfaceValid()) {
         if (m_canvas) {
             // drop pending commands because there is no surface to draw to
             m_canvas->silentFlush();
         }
         return;
     }
     context()->makeContextCurrent();
 }
 
 void Canvas2DLayerBridge::storageAllocatedForRecordingChanged(size_t bytesAllocated)
@@ skipping 67 matching lines @@
     return hasReleasedMailbox() ? &m_mailboxes[m_releasedMailboxInfoIndex] : 0;
 }
 
 bool Canvas2DLayerBridge::hasReleasedMailbox() const
 {
     return m_releasedMailboxInfoIndex != InvalidMailboxIndex;
 }
 
 void Canvas2DLayerBridge::freeReleasedMailbox()
 {
-    if (m_contextProvider->context3d()->isContextLost() || !m_surfaceIsValid)
+    if (m_contextProvider->context3d()->isContextLost() || !m_isSurfaceValid)
         return;
     MailboxInfo* mailboxInfo = releasedMailboxInfo();
     if (!mailboxInfo)
         return;
 
     ASSERT(mailboxInfo->m_status == MailboxReleased);
     if (mailboxInfo->m_mailbox.syncPoint) {
         context()->waitSyncPoint(mailboxInfo->m_mailbox.syncPoint);
         mailboxInfo->m_mailbox.syncPoint = 0;
     }
     // Invalidate texture state in case the compositor altered it since the copy-on-write.
     if (mailboxInfo->m_image) {
         if (isHidden() || releasedMailboxHasExpired())
             mailboxInfo->m_image->getTexture()->resetFlag(static_cast<GrTextureFlags>(GrTexture::kReturnToCache_FlagBit));
         mailboxInfo->m_image->getTexture()->invalidateCachedState();
         mailboxInfo->m_image.clear();
     }
     mailboxInfo->m_status = MailboxAvailable;
     m_releasedMailboxInfoIndex = InvalidMailboxIndex;
     Canvas2DLayerManager::get().layerTransientResourceAllocationChanged(this);
 }
 
 blink::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 && !surfaceIsValid()) {
-        recoverSurface(); // To ensure rate limiter is disabled if context is lost.
-    }
+    if (m_layer && !m_destructionInProgress)
+        checkSurfaceValid(); // To ensure rate limiter is disabled if context is lost.
     return m_contextProvider->context3d();
 }
 
-bool Canvas2DLayerBridge::surfaceIsValid()
+bool Canvas2DLayerBridge::checkSurfaceValid()
 {
     ASSERT(!m_destructionInProgress);
-    return !m_destructionInProgress && !m_contextProvider->context3d()->isContextLost() && m_surfaceIsValid;
+    if (m_destructionInProgress || !m_isSurfaceValid)
+        return false;
+    if (m_contextProvider->context3d()->isContextLost()) {
+        m_isSurfaceValid = false;
+        if (m_imageBuffer)
+            m_imageBuffer->notifySurfaceInvalid();
+        setRateLimitingEnabled(false);
+    }
+    return m_isSurfaceValid;
 }
 
-bool Canvas2DLayerBridge::recoverSurface()
+bool Canvas2DLayerBridge::restoreSurface()
 {
     ASSERT(!m_destructionInProgress);
-    ASSERT(m_layer && !surfaceIsValid());
     if (m_destructionInProgress)
         return false;
+    ASSERT(m_layer && !m_isSurfaceValid);
 
     blink::WebGraphicsContext3D* sharedContext = 0;
     // We must clear the mailboxes before calling m_layer->clearTexture() to prevent
     // re-entry via mailboxReleased from operating on defunct GrContext objects.
     m_mailboxes.clear();
     m_releasedMailboxInfoIndex = InvalidMailboxIndex;
     m_layer->clearTexture();
     m_contextProvider = adoptPtr(blink::Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
     if (m_contextProvider)
         sharedContext = m_contextProvider->context3d();
 
-    if (!sharedContext || sharedContext->isContextLost()) {
-        m_surfaceIsValid = false;
-    } else {
+    if (sharedContext && !sharedContext->isContextLost()) {
         IntSize size(m_canvas->getTopDevice()->width(), m_canvas->getTopDevice()->height());
         RefPtr<SkSurface> surface(createSkSurface(m_contextProvider->grContext(), size, m_msaaSampleCount));
         if (surface.get()) {
             m_canvas->setSurface(surface.get());
-            m_surfaceIsValid = true;
+            m_isSurfaceValid = true;
             // FIXME: draw sad canvas picture into new buffer crbug.com/243842
-        } else {
-            // Surface allocation failed. Set m_surfaceIsValid to false to
-            // trigger subsequent retry.
-            m_surfaceIsValid = false;
         }
     }
-    if (!m_surfaceIsValid)
-        setRateLimitingEnabled(false);
 
-    return m_surfaceIsValid;
+    return m_isSurfaceValid;
 }
 
 bool Canvas2DLayerBridge::prepareMailbox(blink::WebExternalTextureMailbox* outMailbox, blink::WebExternalBitmap* bitmap)
 {
     ASSERT(!m_destructionInProgress);
     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.
         m_canvas->silentFlush();
         m_lastImageId = 0;
         return false;
     }
-    if (!surfaceIsValid() && !recoverSurface())
+    if (!checkSurfaceValid())
         return false;
 
     blink::WebGraphicsContext3D* webContext = context();
 
     // Release to skia textures that were previouosly released by the
     // compositor. We do this before acquiring the next snapshot in
     // order to cap maximum gpu memory consumption.
     webContext->makeContextCurrent();
     flush();
 
@@ skipping 105 matching lines @@
 void Canvas2DLayerBridge::willUse()
 {
     ASSERT(!m_destructionInProgress);
     Canvas2DLayerManager::get().layerDidDraw(this);
     m_didRecordDrawCommand = true;
 }
 
 Platform3DObject Canvas2DLayerBridge::getBackingTexture()
 {
     ASSERT(!m_destructionInProgress);
-    if (!surfaceIsValid() && !recoverSurface())
+    if (!checkSurfaceValid())
         return 0;
     willUse();
     m_canvas->flush();
     context()->flush();
     GrRenderTarget* renderTarget = m_canvas->getTopDevice()->accessRenderTarget();
     if (renderTarget) {
         return renderTarget->asTexture()->getTextureHandle();
     }
     return 0;
 }
 
 Canvas2DLayerBridge::MailboxInfo::MailboxInfo(const MailboxInfo& other) {
     // This copy constructor should only be used for Vector reallocation
     // Assuming 'other' is to be destroyed, we transfer m_image ownership
     // rather than do a refcount dance.
     memcpy(&m_mailbox, &other.m_mailbox, sizeof(m_mailbox));
     m_image = const_cast<MailboxInfo*>(&other)->m_image.release();
     m_status = other.m_status;
 }
 
 }