Fix crash in Canvas2DLayerBridge flushing + reliability metrics

third_party/WebKit/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 187 matching lines @@
         bridge->hibernate();
     } else {
         Canvas2DLayerBridge::Logger localLogger;
         localLogger.reportHibernationEvent(Canvas2DLayerBridge::HibernationAbortedDueToDestructionWhileHibernatePending);
     }
 }
 
 void Canvas2DLayerBridge::hibernate()
 {
     ASSERT(!isHibernating());
+
     if (m_destructionInProgress) {
         m_logger->reportHibernationEvent(HibernationAbortedDueToPendingDestruction);
         return;
     }
 
+    if (!m_surface) {
+        m_logger->reportHibernationEvent(HibernationAbortedBecauseNoSurface);
+        return;
+    }
+
     if (!isHidden()) {
         m_logger->reportHibernationEvent(HibernationAbortedDueToVisibilityChange);
         return;
     }
 
     if (!checkSurfaceValid()) {
         m_logger->reportHibernationEvent(HibernationAbortedDueGpuContextLoss);
         return;
     }
 
     if (!isAccelerated()) {
         m_logger->reportHibernationEvent(HibernationAbortedDueToSwitchToUnacceleratedRendering);
         return;
     }
 
     TRACE_EVENT0("cc", "Canvas2DLayerBridge::hibernate");
     RefPtr<SkSurface> tempHibernationSurface = adoptRef(SkSurface::NewRasterN32Premul(m_size.width(), m_size.height()));
-    if (tempHibernationSurface) {
-        // No HibernationEvent reported on success. This is on purppose to avoid
-        // non-complementary stats. Each HibernationScheduled event is paired with
-        // exactly one failure or exit event.
-        flushRecordingOnly();
-        SkPaint copyPaint;
-        copyPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
-        m_surface->draw(tempHibernationSurface->getCanvas(), 0, 0, &copyPaint); // GPU readback
-        m_hibernationImage = adoptRef(tempHibernationSurface->newImageSnapshot());
-        m_surface.clear(); // destroy the GPU-backed buffer
-        m_layer->clearTexture();
-        m_logger->didStartHibernating();
-    } else {
+    if (!tempHibernationSurface) {
         m_logger->reportHibernationEvent(HibernationAbortedDueToAllocationFailure);
+        return;
+    }
+    // No HibernationEvent reported on success. This is on purppose to avoid
+    // non-complementary stats. Each HibernationScheduled event is paired with
+    // exactly one failure or exit event.
+    flushRecordingOnly();
+    // The following checks that the flush succeeded, which should always be the
+    // case because flushRecordingOnly should only fail it it fails to allocate
+    // a surface, and we have an early exit at the top of this function for when
+    // 'this' does not already have a surface.
+    ASSERT(!m_haveRecordedDrawCommands);
+    SkPaint copyPaint;
+    copyPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
+    m_surface->draw(tempHibernationSurface->getCanvas(), 0, 0, &copyPaint); // GPU readback
+    m_hibernationImage = adoptRef(tempHibernationSurface->newImageSnapshot());
+    m_surface.clear(); // destroy the GPU-backed buffer
+    m_layer->clearTexture();
+    m_logger->didStartHibernating();
+
+}
+
+void Canvas2DLayerBridge::reportSurfaceCreationFailure()
+{
+    if (!m_surfaceCreationFailedAtLeastOnce) {
+        // Only count the failure once per instance so that the histogram may
+        // reflect the proportion of Canvas2DLayerBridge instances with surface
+        // allocation failures.
+        CanvasMetrics::countCanvasContextUsage(CanvasMetrics::GPUAccelerated2DCanvasSurfaceCreationFailed);
+        m_surfaceCreationFailedAtLeastOnce = true;
     }
 }
 
 SkSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint)
 {
     if (m_surface)
         return m_surface.get();
 
     if (m_layer && !isHibernating() && hint == PreferAcceleration) {
         return nullptr; // re-creation will happen through restore()
     }
 
     bool wantAcceleration = shouldAccelerate(hint);
     bool surfaceIsAccelerated;
 
     if (isHidden() && wantAcceleration) {
         wantAcceleration = false;
         m_softwareRenderingWhileHidden = true;
     }
 
     m_surface = createSkSurface(wantAcceleration ? m_contextProvider->grContext() : nullptr, m_size, m_msaaSampleCount, m_opacityMode, &surfaceIsAccelerated);
 
+    if (!m_surface)
+        reportSurfaceCreationFailure();
+
     if (m_surface && surfaceIsAccelerated && !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);
     }
 
     if (m_surface && isHibernating()) {
         if (surfaceIsAccelerated) {
             m_logger->reportHibernationEvent(HibernationEndedNormally);
         } else {
             if (isHidden())
                 m_logger->reportHibernationEvent(HibernationEndedWithSwitchToBackgroundRendering);
             else
                 m_logger->reportHibernationEvent(HibernationEndedWithFallbackToSW);
         }
 
         SkPaint copyPaint;
         copyPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
         m_surface->getCanvas()->drawImage(m_hibernationImage.get(), 0, 0, &copyPaint);
         m_hibernationImage.clear();
 
         if (m_imageBuffer)
             m_imageBuffer->updateGPUMemoryUsage();
 
         if (m_imageBuffer && !m_isDeferralEnabled)
             m_imageBuffer->resetCanvas(m_surface->getCanvas());
     }
+
     return m_surface.get();
 }
 
 SkCanvas* Canvas2DLayerBridge::canvas()
 {
     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;
 
+    CanvasMetrics::countCanvasContextUsage(CanvasMetrics::GPUAccelerated2DCanvasDeferralDisabled);
+    flushRecordingOnly();
+    // Because we will be discarding the recorder, if the flush failed
+    // content will be lost -> force m_haveRecordedDrawCommands to false
+    m_haveRecordedDrawCommands = false;
+
     m_isDeferralEnabled = false;
-    flushRecordingOnly();
     m_recorder.clear();
     // install the current matrix/clip stack onto the immediate canvas
     SkSurface* surface = getOrCreateSurface();
     if (m_imageBuffer && surface)
         m_imageBuffer->resetCanvas(surface->getCanvas());
 }
 
 void Canvas2DLayerBridge::setImageBuffer(ImageBuffer* imageBuffer)
 {
     m_imageBuffer = imageBuffer;
@@ skipping 182 matching lines @@
     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();
         bool surfaceIsAccelerated;
         RefPtr<SkSurface> surface(createSkSurface(grCtx, m_size, m_msaaSampleCount, m_opacityMode, &surfaceIsAccelerated));
+
+        if (!m_surface)
+            reportSurfaceCreationFailure();
+
         // Current paradigm does support switching from accelerated to non-accelerated, which would be tricky
         // due to changes to the layer tree, which can only happen at specific times during the document lifecycle.
         // Therefore, we can only accept the restored surface if it is accelerated.
         if (surface && surfaceIsAccelerated) {
             m_surface = surface.release();
             // FIXME: draw sad canvas picture into new buffer crbug.com/243842
         }
     }
     if (m_imageBuffer)
         m_imageBuffer->updateGPUMemoryUsage();
@@ skipping 248 matching lines @@
     m_image = other.m_image;
     m_parentLayerBridge = other.m_parentLayerBridge;
 }
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(HibernationEvent event)
 {
     blink::Platform::current()->histogramEnumeration("Canvas.HibernationEvents", event, HibernationEventCount);
 }
 
 } // namespace blink