[2D Canvas] Send GPU resources into hibernation when page is not visible

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 19 matching lines @@
 #include "platform/TraceEvent.h"
 #include "platform/graphics/CanvasMetrics.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/gpu/SharedContextRateLimiter.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebGraphicsContext3D.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
+#include "public/platform/WebScheduler.h"
+#include "public/platform/WebTraceLocation.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "wtf/RefCountedLeakCounter.h"
 
 namespace {
 enum {
     InvalidMailboxIndex = -1,
     MaxCanvasAnimationBacklog = 2, // Make sure the the GPU is never more than two animation frames behind.
 };
 
 #ifndef NDEBUG
 WTF::RefCountedLeakCounter& canvas2DLayerBridgeInstanceCounter()
 {
     DEFINE_STATIC_LOCAL(WTF::RefCountedLeakCounter, staticCanvas2DLayerBridgeInstanceCounter, ("Canvas2DLayerBridge"));
     return staticCanvas2DLayerBridgeInstanceCounter;
 }
 #endif
-}
+
+} // unnamed
 
 namespace blink {
 
 static PassRefPtr<SkSurface> createSkSurface(GrContext* gr, const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, bool* surfaceIsAccelerated)
 {
     if (gr)
         gr->resetContext();
 
     SkAlphaType alphaType = (Opaque == opacityMode) ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
     SkImageInfo info = SkImageInfo::MakeN32(size.width(), size.height(), alphaType);
@@ skipping 26 matching lines @@
     OwnPtr<WebGraphicsContext3DProvider> contextProvider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
     if (!contextProvider)
         return nullptr;
     RefPtr<Canvas2DLayerBridge> layerBridge;
     layerBridge = adoptRef(new Canvas2DLayerBridge(contextProvider.release(), size, msaaSampleCount, opacityMode, accelerationMode));
     return layerBridge.release();
 }
 
 Canvas2DLayerBridge::Canvas2DLayerBridge(PassOwnPtr<WebGraphicsContext3DProvider> contextProvider, const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, AccelerationMode accelerationMode)
     : m_contextProvider(contextProvider)
+    , m_logger(adoptPtr(new Logger))
+    , m_weakPtrFactory(this)
     , m_imageBuffer(0)
     , m_msaaSampleCount(msaaSampleCount)
     , m_bytesAllocated(0)
     , m_haveRecordedDrawCommands(false)
     , m_destructionInProgress(false)
     , m_filterQuality(kLow_SkFilterQuality)
     , m_isHidden(false)
     , m_isDeferralEnabled(true)
     , m_isRegisteredTaskObserver(false)
     , m_renderingTaskCompletedForCurrentFrame(false)
+    , m_softwareRenderingWhileHidden(false)
     , m_lastImageId(0)
     , m_lastFilter(GL_LINEAR)
     , m_accelerationMode(accelerationMode)
     , m_opacityMode(opacityMode)
     , m_size(size)
 {
     ASSERT(m_contextProvider);
     // Used by browser tests to detect the use of a Canvas2DLayerBridge.
     TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation", TRACE_EVENT_SCOPE_GLOBAL);
     startRecording();
@@ skipping 16 matching lines @@
 {
     ASSERT(m_isDeferralEnabled);
     m_recorder = adoptPtr(new SkPictureRecorder);
     m_recorder->beginRecording(m_size.width(), m_size.height(), nullptr);
     if (m_imageBuffer) {
         m_imageBuffer->resetCanvas(m_recorder->getRecordingCanvas());
     }
     m_recordingPixelCount = 0;
 }
 
+void Canvas2DLayerBridge::setLoggerForTesting(PassOwnPtr<Logger> logger)
+{
+    m_logger = logger;
+}
+
 bool Canvas2DLayerBridge::shouldAccelerate(AccelerationHint hint) const
 {
     bool accelerate;
-    if (m_accelerationMode == ForceAccelerationForTesting)
+    if (m_softwareRenderingWhileHidden)
+        accelerate = false;
+    else if (m_accelerationMode == ForceAccelerationForTesting)
         accelerate = true;
     else if (m_accelerationMode == DisableAcceleration)
         accelerate = false;
     else
         accelerate = hint == PreferAcceleration;
 
     if (accelerate && (!m_contextProvider || m_contextProvider->context3d()->isContextLost()))
         accelerate = false;
     return accelerate;
 }
 
 bool Canvas2DLayerBridge::isAccelerated() const
 {
+    if (m_softwareRenderingWhileHidden)
+        return false;
     if (m_layer) // We don't check m_surface, so this returns true if context was lost (m_surface is null) with restoration pending.
         return true;
     if (m_surface) // && !m_layer is implied
         return false;
 
     // Whether or not to accelerate is not yet resolved, determine whether immediate presentation
     // of the canvas would result in the canvas being accelerated. Presentation is assumed to be
     // a 'PreferAcceleration' operation.
     return shouldAccelerate(PreferAcceleration);
 }
 
+static void hibernateWrapper(WeakPtr<Canvas2DLayerBridge> bridge, double /*idleDeadline*/)
+{
+    if (bridge) {
+        bridge->hibernate();
+    } else {
+        Canvas2DLayerBridge::Logger localLogger;
+        localLogger.reportHibernationEvent(Canvas2DLayerBridge::HibernationAbortedDueToDestructionWhileHibernatePending);
+    }
+}
+
+void Canvas2DLayerBridge::hibernate()
+{
+    if (m_destructionInProgress) {
+        m_logger->reportHibernationEvent(HibernationAbortedDueToPendingDestruction);
+        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 faillure or exit event.

[Stephen White, 2015/12/10 16:13:10]

Nit: s/faillure/failure/

+        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 {
+        m_logger->reportHibernationEvent(HibernationAbortedDueToAllocationFailure);
+    }
+}
+
 SkSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint)
 {
-    if (!m_surface) {
-        if (m_layer)
-            return nullptr; // recreation will happen through restore()
+    if (m_surface)
+        return m_surface.get();
 
-        bool wantAccelerated = shouldAccelerate(hint);
-        bool surfaceIsAccelerated;
+    if (m_layer && !isHibernating())
+        return nullptr; // recreation will happen through restore()

[Stephen White, 2015/12/10 16:13:10]

s/recreation/re-creation/ :)

 
-        m_surface = createSkSurface(wantAccelerated ? m_contextProvider->grContext() : nullptr, m_size, m_msaaSampleCount, m_opacityMode, &surfaceIsAccelerated);
+    bool wantAccelerated = shouldAccelerate(hint);

[Stephen White, 2015/12/10 16:13:10]

naming uNit: wantAccelerated is awkward. wantAcceleration? useAcceleration?
accelerate?

+    bool surfaceIsAccelerated;
 
-        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 (isHidden() && wantAccelerated) {
+        wantAccelerated = false;
+        m_softwareRenderingWhileHidden = true;
+    }
+
+    m_surface = createSkSurface(wantAccelerated ? m_contextProvider->grContext() : nullptr, m_size, m_msaaSampleCount, m_opacityMode, &surfaceIsAccelerated);
+
+    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();
     }
     return m_surface.get();
 }
 
 SkCanvas* Canvas2DLayerBridge::canvas()
 {
     if (!m_isDeferralEnabled) {
         SkSurface* s = getOrCreateSurface();
         return s ? s->getCanvas() : nullptr;
     }
@@ skipping 11 matching lines @@
     // 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;
 
     m_isDeferralEnabled = false;
     flushRecordingOnly();
     m_recorder.clear();
     // install the current matrix/clip stack onto the immediate canvas
-    m_imageBuffer->resetCanvas(getOrCreateSurface()->getCanvas());
+    if (m_imageBuffer)
+        m_imageBuffer->resetCanvas(getOrCreateSurface()->getCanvas());
 }
 
 void Canvas2DLayerBridge::setImageBuffer(ImageBuffer* imageBuffer)
 {
     m_imageBuffer = imageBuffer;
     if (m_imageBuffer && m_isDeferralEnabled) {
         m_imageBuffer->resetCanvas(m_recorder->getRecordingCanvas());
     }
 }
 
 void Canvas2DLayerBridge::beginDestruction()
 {
-    ASSERT(!m_destructionInProgress);
+    if (m_destructionInProgress)
+        return;
+    if (isHibernating())
+        m_logger->reportHibernationEvent(HibernationEndedWithTeardown);
+    m_hibernationImage.clear();
     m_recorder.clear();
     m_imageBuffer = nullptr;
     m_destructionInProgress = true;
     setIsHidden(true);
     m_surface.clear();
 
     unregisterTaskObserver();
 
     if (m_layer) {
         GraphicsLayer::unregisterContentsLayer(m_layer->layer());
         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
         m_layer->layer()->removeFromParent();
     }
+
     ASSERT(!m_bytesAllocated);
 }
 
 void Canvas2DLayerBridge::unregisterTaskObserver()
 {
     if (m_isRegisteredTaskObserver) {
         Platform::current()->currentThread()->removeTaskObserver(this);
         m_isRegisteredTaskObserver = false;
     }
 }
 
 void Canvas2DLayerBridge::setFilterQuality(SkFilterQuality filterQuality)
 {
     ASSERT(!m_destructionInProgress);
     m_filterQuality = filterQuality;
     if (m_layer)
         m_layer->setNearestNeighbor(m_filterQuality == kNone_SkFilterQuality);
 }
 
 void Canvas2DLayerBridge::setIsHidden(bool hidden)
 {
     bool newHiddenValue = hidden || m_destructionInProgress;
     if (m_isHidden == newHiddenValue)
         return;
 
     m_isHidden = newHiddenValue;
-    if (isHidden() && !m_destructionInProgress)
-        flush();
+    if (m_surface && isHidden() && !m_destructionInProgress) {
+        if (m_layer)
+            m_layer->clearTexture();
+        m_logger->reportHibernationEvent(HibernationScheduled);
+        Platform::current()->currentThread()->scheduler()->postIdleTask(BLINK_FROM_HERE, WTF::bind<double>(&hibernateWrapper, m_weakPtrFactory.createWeakPtr()));
+    }
+    if (!isHidden() && m_softwareRenderingWhileHidden) {
+        flushRecordingOnly();
+        SkPaint copyPaint;
+        copyPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
+        RefPtr<SkSurface> oldSurface = m_surface.release();
+        m_softwareRenderingWhileHidden = false;
+        SkSurface* newSurface = getOrCreateSurface();
+        if (newSurface) {
+            oldSurface->draw(newSurface->getCanvas(), 0, 0, &copyPaint);
+        }
+    }
+    if (!isHidden() && isHibernating()) {
+        getOrCreateSurface(); // Rude awakening
+    }
 }
 
 bool Canvas2DLayerBridge::writePixels(const SkImageInfo& origInfo, const void* pixels, size_t rowBytes, int x, int y)
 {
     if (!getOrCreateSurface())
         return false;
     if (x <= 0 && y <= 0 && x + origInfo.width() >= m_size.width() && y + origInfo.height() >= m_size.height()) {
         skipQueuedDrawCommands();
     } else {
         flush();
@@ skipping 108 matching lines @@
             m_surface = surface.release();
             // FIXME: draw sad canvas picture into new buffer crbug.com/243842
         }
     }
 
     return m_surface;
 }
 
 bool Canvas2DLayerBridge::prepareMailbox(WebExternalTextureMailbox* outMailbox, WebExternalBitmap* bitmap)
 {
-    ASSERT(isAccelerated());
     if (m_destructionInProgress) {
         // It can be hit in the following sequence.
         // 1. Canvas draws something.
         // 2. The compositor begins the frame.
         // 3. Javascript makes a context be lost.
         // 4. Here.
         return false;
     }
+    ASSERT(isAccelerated() || isHibernating());
+
+    // if hibernating but not hidden, we want to wake up from
+    // hibernation
+    if (isHibernating() && isHidden())
+        return false;
+
     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.
         skipQueuedDrawCommands();
         m_lastImageId = 0;
         return false;
     }
     if (!checkSurfaceValid())
@@ skipping 65 matching lines @@
     // Because we are changing the texture binding without going through skia,
     // we must dirty the context.
     grContext->resetContext(kTextureBinding_GrGLBackendState);
 
     *outMailbox = mailboxInfo.m_mailbox;
     return true;
 }
 
 void Canvas2DLayerBridge::mailboxReleased(const WebExternalTextureMailbox& mailbox, bool lostResource)
 {
-    ASSERT(isAccelerated());
-    bool contextLost = !m_surface || m_contextProvider->context3d()->isContextLost();
+    ASSERT(isAccelerated() || isHibernating());
+    bool contextLost = !isHibernating() && (!m_surface || m_contextProvider->context3d()->isContextLost());
     ASSERT(m_mailboxes.last().m_parentLayerBridge.get() == this);
 
     // Mailboxes are typically released in FIFO order, so we iterate
     // from the end of m_mailboxes.
     auto releasedMailboxInfo = m_mailboxes.end();
     auto firstMailbox = m_mailboxes.begin();
 
     while (true) {
         --releasedMailboxInfo;
         if (nameEquals(releasedMailboxInfo->m_mailbox, mailbox)) {
@@ skipping 123 matching lines @@
     skipQueuedDrawCommands();
 }
 
 Canvas2DLayerBridge::MailboxInfo::MailboxInfo(const MailboxInfo& other)
 {
     memcpy(&m_mailbox, &other.m_mailbox, sizeof(m_mailbox));
     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