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

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 "config.h"
 
 #include "platform/graphics/RecordingImageBufferSurface.h"
 
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "public/platform/Platform.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 
 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();
 }
 
 RecordingImageBufferSurface::~RecordingImageBufferSurface()
 { }
 
 bool RecordingImageBufferSurface::initializeCurrentFrame()
 {
     StateStack stateStack;
@@ skipping 19 matching lines @@
     return true;
 }
 
 void RecordingImageBufferSurface::setImageBuffer(ImageBuffer* imageBuffer)
 {
     m_imageBuffer = imageBuffer;
     if (m_currentFrame && m_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();
 }
 
 PassRefPtr<SkPicture> RecordingImageBufferSurface::getPicture()
 {
+    if (m_fallbackSurface)
+        return nullptr;
+
     bool canUsePicture = finalizeFrameInternal();
     m_imageBuffer->didFinalizeFrame();
 
     if (canUsePicture) {
         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();
     }
 }
 
 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
             m_previousFrame = adoptRef(m_currentFrame->endRecording());
             initializeCurrentFrame();
         }
         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;
     }
 
     m_previousFrame = adoptRef(m_currentFrame->endRecording());
     if (!initializeCurrentFrame())
         return false;
 
 
@@ skipping 32 matching lines @@
         dstCanvas->setMatrix(stateStack->peek().m_ctm);
         dstCanvas->save();
         stateStack->pop();
     }
 
     dstCanvas->resetMatrix();
     dstCanvas->clipRect(SkRect::MakeFromIRect(stateStack->peek().m_clip));
     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