Add display list fallback reason histograms for 2D canvas

third_party/WebKit/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 "platform/graphics/RecordingImageBufferSurface.h"
 
 #include "platform/graphics/CanvasMetrics.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
@@ skipping 15 matching lines @@
     , m_currentFrameHasExpensiveOp(false)
     , m_previousFrameHasExpensiveOp(false)
     , m_fallbackFactory(std::move(fallbackFactory))
 {
     initializeCurrentFrame();
 }
 
 RecordingImageBufferSurface::~RecordingImageBufferSurface()
 { }
 
-bool RecordingImageBufferSurface::initializeCurrentFrame()
+void RecordingImageBufferSurface::initializeCurrentFrame()
 {
     static SkRTreeFactory rTreeFactory;
     m_currentFrame = adoptPtr(new SkPictureRecorder);
     m_currentFrame->beginRecording(size().width(), size().height(), &rTreeFactory);
     if (m_imageBuffer) {
         m_imageBuffer->resetCanvas(m_currentFrame->getRecordingCanvas());
     }
     m_didRecordDrawCommandsInCurrentFrame = false;
     m_currentFrameHasExpensiveOp = false;
     m_currentFramePixelCount = 0;
-    return true;
 }
 
 void RecordingImageBufferSurface::setImageBuffer(ImageBuffer* imageBuffer)
 {
     m_imageBuffer = imageBuffer;
     if (m_currentFrame && m_imageBuffer) {
         m_imageBuffer->resetCanvas(m_currentFrame->getRecordingCanvas());
     }
     if (m_fallbackSurface) {
         m_fallbackSurface->setImageBuffer(imageBuffer);
     }
 }
 
 bool RecordingImageBufferSurface::writePixels(const SkImageInfo& origInfo, const void* pixels, size_t rowBytes, int x, int y)
 {
     if (!m_fallbackSurface) {
         if (x <= 0 && y <= 0 && x + origInfo.width() >= size().width() && y + origInfo.height() >= size().height()) {
             willOverwriteCanvas();
         }
-        fallBackToRasterCanvas();
+        fallBackToRasterCanvas(FallbackReasonWritePixels);
     }
     return m_fallbackSurface->writePixels(origInfo, pixels, rowBytes, x, y);
 }
 
-void RecordingImageBufferSurface::fallBackToRasterCanvas()
+void RecordingImageBufferSurface::fallBackToRasterCanvas(FallbackReason reason)
 {
     if (m_fallbackSurface) {
         ASSERT(!m_currentFrame);
         return;
     }
 
+    Platform::current()->histogramEnumeration("Canvas.DisplayListFallbackReason", reason, FallbackReasonCount);
+
     m_fallbackSurface = m_fallbackFactory->createSurface(size(), opacityMode());
     m_fallbackSurface->setImageBuffer(m_imageBuffer);
 
     if (m_previousFrame) {
         m_previousFrame->playback(m_fallbackSurface->canvas());
         m_previousFrame.clear();
     }
 
     if (m_currentFrame) {
         RefPtr<SkPicture> currentPicture = adoptRef(m_currentFrame->endRecording());
         currentPicture->playback(m_fallbackSurface->canvas());
         m_currentFrame.clear();
     }
 
     if (m_imageBuffer) {
         m_imageBuffer->resetCanvas(m_fallbackSurface->canvas());
     }
 
     CanvasMetrics::countCanvasContextUsage(CanvasMetrics::DisplayList2DCanvasFallbackToRaster);
 }
 
-PassRefPtr<SkImage> RecordingImageBufferSurface::newImageSnapshot(AccelerationHint hint)
+static RecordingImageBufferSurface::FallbackReason snapshotReasonToFallbackReason(SnapshotReason reason)
+{
+    switch (reason) {
+    case SnapshotReasonUnknown:
+        return RecordingImageBufferSurface::FallbackReasonUnknown;
+    case SnapshotReasonGetImageData:
+        return RecordingImageBufferSurface::FallbackReasonSnapshotForGetImageData;
+    case SnapshotReasonCopyToWebGLTexture:
+        return RecordingImageBufferSurface::FallbackReasonSnapshotForCopyToWebGLTexture;
+    case SnapshotReasonPaint:
+        return RecordingImageBufferSurface::FallbackReasonSnapshotForPaint;
+    case SnapshotReasonToDataURL:
+        return RecordingImageBufferSurface::FallbackReasonSnapshotForToDataURL;
+    case SnapshotReasonToBlob:
+        return RecordingImageBufferSurface::FallbackReasonSnapshotForToBlob;
+    case SnapshotReasonCanvasListenerCapture:
+        return RecordingImageBufferSurface::FallbackReasonSnapshotForCanvasListenerCapture;
+    case SnapshotReasonDrawImage:
+        return RecordingImageBufferSurface::FallbackReasonSnapshotForDrawImage;
+    case SnapshotReasonCreatePattern:
+        return RecordingImageBufferSurface::FallbackReasonSnapshotForCreatePattern;
+    }
+    ASSERT_NOT_REACHED();
+    return RecordingImageBufferSurface::FallbackReasonUnknown;
+}
+
+PassRefPtr<SkImage> RecordingImageBufferSurface::newImageSnapshot(AccelerationHint hint, SnapshotReason reason)
 {
     if (!m_fallbackSurface)
-        fallBackToRasterCanvas();
-    return m_fallbackSurface->newImageSnapshot(hint);
+        fallBackToRasterCanvas(snapshotReasonToFallbackReason(reason));
+    return m_fallbackSurface->newImageSnapshot(hint, reason);
 }
 
 SkCanvas* RecordingImageBufferSurface::canvas()
 {
     if (m_fallbackSurface)
         return m_fallbackSurface->canvas();
 
     ASSERT(m_currentFrame->getRecordingCanvas());
     return m_currentFrame->getRecordingCanvas();
 }
 
-void RecordingImageBufferSurface::disableDeferral()
+static RecordingImageBufferSurface::FallbackReason disableDeferralReasonToFallbackReason(DisableDeferralReason reason)
+{
+    switch (reason) {
+    case DisableDeferralReasonUnknown:
+        return RecordingImageBufferSurface::FallbackReasonUnknown;
+    case DisableDeferralReasonExpensiveOverdrawHeuristic:
+        return RecordingImageBufferSurface::FallbackReasonExpensiveOverdrawHeuristic;
+    case DisableDeferralReasonUsingTextureBackedPattern:
+        return RecordingImageBufferSurface::FallbackReasonTextureBackedPattern;
+    case DisableDeferralReasonDrawImageOfVideo:
+        return RecordingImageBufferSurface::FallbackReasonDrawImageOfVideo;
+    case DisableDeferralReasonDrawImageOfAnimated2dCanvas:
+        return RecordingImageBufferSurface::FallbackReasonDrawImageOfAnimated2dCanvas;
+    case DisableDeferralReasonCount:
+        ASSERT_NOT_REACHED();
+        break;
+    }
+    ASSERT_NOT_REACHED();
+    return RecordingImageBufferSurface::FallbackReasonUnknown;
+}
+
+void RecordingImageBufferSurface::disableDeferral(DisableDeferralReason reason)
 {
     if (!m_fallbackSurface)
-        fallBackToRasterCanvas();
+        fallBackToRasterCanvas(disableDeferralReasonToFallbackReason(reason));
 }
 
 PassRefPtr<SkPicture> RecordingImageBufferSurface::getPicture()
 {
     if (m_fallbackSurface)
         return nullptr;
 
-    bool canUsePicture = finalizeFrameInternal();
+    FallbackReason fallbackReason = FallbackReasonUnknown;
+    bool canUsePicture = finalizeFrameInternal(&fallbackReason);
     m_imageBuffer->didFinalizeFrame();
 
     if (canUsePicture) {
         return m_previousFrame;
     }
 
     if (!m_fallbackSurface)
-        fallBackToRasterCanvas();
+        fallBackToRasterCanvas(fallbackReason);
     return nullptr;
 }
 
 void RecordingImageBufferSurface::finalizeFrame(const FloatRect &dirtyRect)
 {
     if (m_fallbackSurface) {
         m_fallbackSurface->finalizeFrame(dirtyRect);
         return;
     }
 
-    if (!finalizeFrameInternal())
-        fallBackToRasterCanvas();
+    FallbackReason fallbackReason = FallbackReasonUnknown;
+    if (!finalizeFrameInternal(&fallbackReason))
+        fallBackToRasterCanvas(fallbackReason);
 }
 
-void RecordingImageBufferSurface::flush()
+static RecordingImageBufferSurface::FallbackReason flushReasonToFallbackReason(FlushReason reason)
+{
+    switch (reason) {
+    case FlushReasonUnknown:
+        return RecordingImageBufferSurface::FallbackReasonUnknown;
+    case FlushReasonInitialClear:
+        return RecordingImageBufferSurface::FallbackReasonFlushInitialClear;
+    case FlushReasonDrawImageOfWebGL:
+        return RecordingImageBufferSurface::FallbackReasonFlushForDrawImageOfWebGL;
+    }
+    ASSERT_NOT_REACHED();
+    return RecordingImageBufferSurface::FallbackReasonUnknown;
+}
+
+void RecordingImageBufferSurface::flush(FlushReason reason)
 {
     if (!m_fallbackSurface)
-        fallBackToRasterCanvas();
-    m_fallbackSurface->flush();
+        fallBackToRasterCanvas(flushReasonToFallbackReason(reason));
+    m_fallbackSurface->flush(reason);
 }
 
 void RecordingImageBufferSurface::willOverwriteCanvas()
 {
     m_frameWasCleared = true;
     m_previousFrame.clear();
     m_previousFrameHasExpensiveOp = false;
     m_previousFramePixelCount = 0;
     if (m_didRecordDrawCommandsInCurrentFrame) {
         // Discard previous draw commands
         adoptRef(m_currentFrame->endRecording());
         initializeCurrentFrame();
     }
 }
 
 void RecordingImageBufferSurface::didDraw(const FloatRect& rect)
 {
     m_didRecordDrawCommandsInCurrentFrame = true;
     IntRect pixelBounds = enclosingIntRect(rect);
     m_currentFramePixelCount += pixelBounds.width() * pixelBounds.height();
 }
 
-bool RecordingImageBufferSurface::finalizeFrameInternal()
+bool RecordingImageBufferSurface::finalizeFrameInternal(FallbackReason* fallbackReason)
 {
     ASSERT(!m_fallbackSurface);
     ASSERT(m_currentFrame);
     ASSERT(m_currentFrame->getRecordingCanvas());
+    ASSERT(fallbackReason);
+    ASSERT(*fallbackReason == FallbackReasonUnknown);
 
     if (!m_imageBuffer->isDirty()) {
         if (!m_previousFrame) {
             // Create an initial blank frame
             m_previousFrame = adoptRef(m_currentFrame->endRecording());
             initializeCurrentFrame();
         }
         return m_currentFrame;
     }
 
-    if (!m_frameWasCleared || m_currentFrame->getRecordingCanvas()->getSaveCount() > ExpensiveCanvasHeuristicParameters::ExpensiveRecordingStackDepth) {
+    if (!m_frameWasCleared) {
+        *fallbackReason = FallbackReasonCanvasNotClearedBetweenFrames;
+        return false;
+    }
+
+    if (m_currentFrame->getRecordingCanvas()->getSaveCount() > ExpensiveCanvasHeuristicParameters::ExpensiveRecordingStackDepth) {
+        *fallbackReason = FallbackReasonRunawayStateStack;
         return false;
     }
 
     m_previousFrame = adoptRef(m_currentFrame->endRecording());
     m_previousFrameHasExpensiveOp = m_currentFrameHasExpensiveOp;
     m_previousFramePixelCount = m_currentFramePixelCount;
-    if (!initializeCurrentFrame())
-        return false;
+    initializeCurrentFrame();
 
     m_frameWasCleared = false;
     return true;
 }
 
 void RecordingImageBufferSurface::draw(GraphicsContext& context, const FloatRect& destRect, const FloatRect& srcRect, SkXfermode::Mode op)
 {
     if (m_fallbackSurface) {
         m_fallbackSurface->draw(context, destRect, srcRect, op);
         return;
@@ skipping 59 matching lines @@
 
 void RecordingImageBufferSurface::setIsHidden(bool hidden)
 {
     if (m_fallbackSurface)
         m_fallbackSurface->setIsHidden(hidden);
     else
         ImageBufferSurface::setIsHidden(hidden);
 }
 
 } // namespace blink