Making display list canvases fall back to gpu-accelerated when appropriate

Source/platform/graphics/RecordingImageBufferSurface.cpp

Index: Source/platform/graphics/RecordingImageBufferSurface.cpp
diff --git a/Source/platform/graphics/RecordingImageBufferSurface.cpp b/Source/platform/graphics/RecordingImageBufferSurface.cpp
index 1d57c614d757a1b03d61de4176e118b9217be992..9cacbf8c6544272517be29f64b1c599b72ed5561 100644
--- a/Source/platform/graphics/RecordingImageBufferSurface.cpp
+++ b/Source/platform/graphics/RecordingImageBufferSurface.cpp
@@ -16,11 +16,12 @@
 
 namespace blink {
 
-RecordingImageBufferSurface::RecordingImageBufferSurface(const IntSize& size, OpacityMode opacityMode)
+RecordingImageBufferSurface::RecordingImageBufferSurface(const IntSize& size, PassOwnPtr<RecordingImageBufferFallbackSurfaceFactory> fallbackFactory, OpacityMode opacityMode)
     : ImageBufferSurface(size, opacityMode)
     , m_imageBuffer(0)
     , m_initialSaveCount(0)
     , m_frameWasCleared(true)
+    , m_fallbackFactory(fallbackFactory)
 {
     initializeCurrentFrame();
 }
@@ -60,42 +61,49 @@ void RecordingImageBufferSurface::setImageBuffer(ImageBuffer* imageBuffer)
         m_imageBuffer->context()->setRegionTrackingMode(GraphicsContext::RegionTrackingOverwrite);
         m_imageBuffer->context()->resetCanvas(m_currentFrame->getRecordingCanvas());
     }
+    if (m_fallbackSurface) {
+        m_fallbackSurface->setImageBuffer(imageBuffer);
+    }
 }
 
 void RecordingImageBufferSurface::willAccessPixels()
 {
-    fallBackToRasterCanvas();
+    if (m_fallbackSurface)
+        m_fallbackSurface->willAccessPixels();
+    else
+        fallBackToRasterCanvas();
 }
 
 void RecordingImageBufferSurface::fallBackToRasterCanvas()
 {
-    if (m_rasterCanvas) {
+    if (m_fallbackSurface) {
         ASSERT(!m_currentFrame);
         return;
     }
 
-    m_rasterCanvas = adoptPtr(SkCanvas::NewRasterN32(size().width(), size().height()));
+    m_fallbackSurface = m_fallbackFactory->createSurface(size(), opacityMode());
+    m_fallbackSurface->setImageBuffer(m_imageBuffer);
 
     if (m_previousFrame) {
-        m_previousFrame->draw(m_rasterCanvas.get());
+        m_previousFrame->draw(m_fallbackSurface->canvas());
         m_previousFrame.clear();
     }
     if (m_currentFrame) {
         RefPtr<SkPicture> currentPicture = adoptRef(m_currentFrame->endRecording());
-        currentPicture->draw(m_rasterCanvas.get());
+        currentPicture->draw(m_fallbackSurface->canvas());
         m_currentFrame.clear();
     }
 
     if (m_imageBuffer) {
         m_imageBuffer->context()->setRegionTrackingMode(GraphicsContext::RegionTrackingDisabled);
-        m_imageBuffer->context()->resetCanvas(m_rasterCanvas.get());
+        m_imageBuffer->context()->resetCanvas(m_fallbackSurface->canvas());
     }
 }
 
 SkCanvas* RecordingImageBufferSurface::canvas() const
 {
-    if (m_rasterCanvas)
-        return m_rasterCanvas.get();
+    if (m_fallbackSurface)
+        return m_fallbackSurface->canvas();
 
     ASSERT(m_currentFrame->getRecordingCanvas());
     return m_currentFrame->getRecordingCanvas();
@@ -103,6 +111,9 @@ SkCanvas* RecordingImageBufferSurface::canvas() const
 
 PassRefPtr<SkPicture> RecordingImageBufferSurface::getPicture()
 {
+    if (m_fallbackSurface)
+        return nullptr;
+
     bool canUsePicture = finalizeFrameInternal();
     m_imageBuffer->didFinalizeFrame();
 
@@ -110,14 +121,16 @@ PassRefPtr<SkPicture> RecordingImageBufferSurface::getPicture()
         return m_previousFrame;
     }
 
-    if (!m_rasterCanvas)
+    if (!m_fallbackSurface)
         fallBackToRasterCanvas();
     return nullptr;
 }
 
-void RecordingImageBufferSurface::finalizeFrame(const FloatRect &)
+void RecordingImageBufferSurface::finalizeFrame(const FloatRect &dirtyRect)
 {
-    if (!finalizeFrameInternal() && !m_rasterCanvas) {
+    if (m_fallbackSurface) {
+        m_fallbackSurface->finalizeFrame(dirtyRect);

[Stephen White, 2014/10/16 14:37:13]

Nit: could be an early-return here.

+    } else if (!finalizeFrameInternal()) {
         fallBackToRasterCanvas();
     }
 }
@@ -125,10 +138,14 @@ void RecordingImageBufferSurface::finalizeFrame(const FloatRect &)
 void RecordingImageBufferSurface::didClearCanvas()
 {
     m_frameWasCleared = true;
+    if (m_fallbackSurface)
+        m_fallbackSurface->didClearCanvas();

[Stephen White, 2014/10/16 14:37:13]

Since we don't care about setting m_frameWasCleared in the fallback case, maybe
we should move this above that statement, and make it an early-return.

 }
 
 bool RecordingImageBufferSurface::finalizeFrameInternal()
 {
+    ASSERT(!m_fallbackSurface);
+
     if (!m_imageBuffer->isDirty()) {
         if (m_currentFrame && !m_previousFrame) {
             // Create an initial blank frame
@@ -138,10 +155,6 @@ bool RecordingImageBufferSurface::finalizeFrameInternal()
         return m_currentFrame;
     }
 
-    if (!m_currentFrame) {
-        return false;
-    }
-
     IntRect canvasRect(IntPoint(0, 0), size());
     if (!m_frameWasCleared && !m_imageBuffer->context()->opaqueRegion().asRect().contains(canvasRect)) {
         return false;
@@ -194,4 +207,79 @@ void RecordingImageBufferSurface::setCurrentState(SkCanvas* dstCanvas, StateStac
     dstCanvas->setMatrix(stateStack->peek().m_ctm);
 }
 
+// Fallback passthroughs
+
+const SkBitmap& RecordingImageBufferSurface::bitmap()
+{
+    if (m_fallbackSurface)
+        return m_fallbackSurface->bitmap();
+    return INHERITTED::bitmap();

[Stephen White, 2014/10/16 14:37:13]

We don't use INHERITED (or INHERITTED :) ) in Blink. I'd just use the base class
name here.

+}
+
+bool RecordingImageBufferSurface::restore()
+{
+    if (m_fallbackSurface)
+        return m_fallbackSurface->restore();
+    return INHERITTED::restore();
+}
+
+WebLayer* RecordingImageBufferSurface::layer() const
+{
+    if (m_fallbackSurface)
+        return m_fallbackSurface->layer();
+    return INHERITTED::layer();
+}
+
+bool RecordingImageBufferSurface::isAccelerated() const
+{
+    if (m_fallbackSurface)
+        return m_fallbackSurface->isAccelerated();
+    return INHERITTED::isAccelerated();
+}
+
+Platform3DObject RecordingImageBufferSurface::getBackingTexture() const
+{
+    if (m_fallbackSurface)
+        return m_fallbackSurface->getBackingTexture();
+    return INHERITTED::getBackingTexture();
+}
+
+bool RecordingImageBufferSurface::cachedBitmapEnabled() const
+{
+    if (m_fallbackSurface)
+        return m_fallbackSurface->cachedBitmapEnabled();
+    return INHERITTED::cachedBitmapEnabled();
+}
+
+const SkBitmap& RecordingImageBufferSurface::cachedBitmap() const
+{
+    if (m_fallbackSurface)
+        return m_fallbackSurface->cachedBitmap();
+    return INHERITTED::cachedBitmap();
+}
+
+void RecordingImageBufferSurface::invalidateCachedBitmap()
+{
+    if (m_fallbackSurface)
+        m_fallbackSurface->invalidateCachedBitmap();
+    else
+        INHERITTED::invalidateCachedBitmap();
+}
+
+void RecordingImageBufferSurface::updateCachedBitmapIfNeeded()
+{
+    if (m_fallbackSurface)
+        m_fallbackSurface->updateCachedBitmapIfNeeded();
+    else
+        INHERITTED::updateCachedBitmapIfNeeded();
+}
+
+void RecordingImageBufferSurface::setIsHidden(bool hidden)
+{
+    if (m_fallbackSurface)
+        m_fallbackSurface->setIsHidden(hidden);
+    else
+        INHERITTED::setIsHidden(hidden);
+}
+
 } // namespace blink