Reland: Make 2D canvas disable gpu acceleration when getImageData is called

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 153 matching lines @@
     else
         accelerate = hint == PreferAcceleration || hint == PreferAccelerationAfterVisibilityChange;
 
     if (accelerate && (!m_contextProvider || m_contextProvider->contextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR))
         accelerate = false;
     return accelerate;
 }
 
 bool Canvas2DLayerBridge::isAccelerated() const
 {
+    if (m_accelerationMode == DisableAcceleration)
+        return false;
     if (isHibernating())
         return false;
     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
@@ skipping 273 matching lines @@
 {
     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;
     }
 }
 
+void Canvas2DLayerBridge::disableAcceleration()
+{
+    DCHECK(isAccelerated());
+    bool surfaceIsAccelerated;
+    RefPtr<SkSurface> newSurface = createSkSurface(nullptr, m_size, m_msaaSampleCount, m_opacityMode, &surfaceIsAccelerated);
+    if (newSurface) {
+        DCHECK(!surfaceIsAccelerated);
+        flush();
+        SkPaint copyPaint;
+        copyPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
+        m_surface->draw(newSurface->getCanvas(), 0, 0, &copyPaint); // GPU readback here
+        m_accelerationMode = DisableAcceleration; // Acceleration gets permanently disabled
+        GraphicsLayer::unregisterContentsLayer(m_layer->layer());
+        m_layer->clearTexture();
+        m_layer->layer()->removeFromParent();
+        m_surface = newSurface;
+        if (m_imageBuffer)
+            m_imageBuffer->didDisableAcceleration();
+    }
+}
+
 SkSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint)
 {
-    if (m_surface)
+    if (m_surface) {
+        // Note: in layout tests, canvas2dFixedRenderingMode is set to true to inhibit
+        // mode switching so that we continue to get test coverage for GPU acceleration
+        // despite the use of getImageData in tests
+        if (hint == ForceNoAcceleration && isAccelerated() && !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled())
+            disableAcceleration();
         return m_surface.get();
+    }
 
-    if (m_layer && !isHibernating() && hint == PreferAcceleration) {
+    if (m_layer && !isHibernating() && hint == PreferAcceleration && m_accelerationMode != DisableAcceleration) {
         return nullptr; // re-creation will happen through restore()
     }
 
     bool wantAcceleration = shouldAccelerate(hint);
-    bool surfaceIsAccelerated;
     if (CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU && isHidden() && wantAcceleration) {
         wantAcceleration = false;
         m_softwareRenderingWhileHidden = true;
     }
 
+    bool surfaceIsAccelerated;
     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 = wrapUnique(Platform::current()->compositorSupport()->createExternalTextureLayer(this));
         m_layer->setOpaque(m_opacityMode == Opaque);
         m_layer->setBlendBackgroundColor(m_opacityMode != Opaque);
         GraphicsLayer::registerContentsLayer(m_layer->layer());
@@ skipping 80 matching lines @@
         m_logger->reportHibernationEvent(HibernationEndedWithTeardown);
     m_hibernationImage.clear();
     m_recorder.reset();
     m_imageBuffer = nullptr;
     m_destructionInProgress = true;
     setIsHidden(true);
     m_surface.clear();
 
     unregisterTaskObserver();
 
-    if (m_layer) {
+    if (m_layer && m_accelerationMode != DisableAcceleration) {
         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();
     }
 
     DCHECK(!m_bytesAllocated);
 }
@@ skipping 108 matching lines @@
     gpu::gles2::GLES2Interface* gl = contextGL();
     if (isAccelerated() && gl)
         gl->Flush();
 }
 
 
 gpu::gles2::GLES2Interface* Canvas2DLayerBridge::contextGL()
 {
     // Check on m_layer is necessary because contextGL() may be called during
     // the destruction of m_layer
-    if (m_layer && !m_destructionInProgress) {
+    if (m_layer && m_accelerationMode != DisableAcceleration && !m_destructionInProgress) {
         // Call checkSurfaceValid to ensure rate limiter is disabled if context is lost.
         if (!checkSurfaceValid())
             return nullptr;
     }
     return m_contextProvider ? m_contextProvider->contextGL() : nullptr;
 }
 
 bool Canvas2DLayerBridge::checkSurfaceValid()
 {
     DCHECK(!m_destructionInProgress);
     if (m_destructionInProgress)
         return false;
     if (isHibernating())
         return true;
-    if (!m_layer)
+    if (!m_layer || m_accelerationMode == DisableAcceleration)
         return true;
     if (!m_surface)
         return false;
     if (m_contextProvider->contextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
         m_surface.clear();
         for (auto mailboxInfo = m_mailboxes.begin(); mailboxInfo != m_mailboxes.end(); ++mailboxInfo) {
             if (mailboxInfo->m_image)
                 mailboxInfo->m_image.clear();
         }
         if (m_imageBuffer)
@@ skipping 130 matching lines @@
         // to postpone destruction until the end of this function.
         selfRef = this;
     }
 
     // The destruction of 'releasedMailboxInfo' will:
     // 1) Release the self reference held by the mailboxInfo, which may trigger
     //    the self-destruction of this Canvas2DLayerBridge
     // 2) Release the SkImage, which will return the texture to skia's scratch
     //    texture pool.
     m_mailboxes.remove(releasedMailboxInfo);
+
+    if (m_mailboxes.isEmpty() && m_accelerationMode == DisableAcceleration)
+        m_layer.reset();
 }
 
 WebLayer* Canvas2DLayerBridge::layer() const
 {
     DCHECK(!m_destructionInProgress);
     DCHECK(m_layer);
     return m_layer->layer();
 }
 
 void Canvas2DLayerBridge::didDraw(const FloatRect& rect)
@@ skipping 13 matching lines @@
 }
 
 void Canvas2DLayerBridge::prepareSurfaceForPaintingIfNeeded()
 {
     getOrCreateSurface(PreferAcceleration);
 }
 
 void Canvas2DLayerBridge::finalizeFrame(const FloatRect &dirtyRect)
 {
     DCHECK(!m_destructionInProgress);
-    if (m_layer)
+    if (m_layer && m_accelerationMode != DisableAcceleration)
         m_layer->layer()->invalidateRect(enclosingIntRect(dirtyRect));
     if (m_rateLimiter)
         m_rateLimiter->reset();
     m_renderingTaskCompletedForCurrentFrame = false;
 }
 
 void Canvas2DLayerBridge::didProcessTask()
 {
     TRACE_EVENT0("cc", "Canvas2DLayerBridge::didProcessTask");
     DCHECK(m_isRegisteredTaskObserver);
@@ skipping 74 matching lines @@
 #endif // USE_IOSURFACE_FOR_2D_CANVAS
 }
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(HibernationEvent event)
 {
     DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernationHistogram, ("Canvas.HibernationEvents", HibernationEventCount));
     hibernationHistogram.count(event);
 }
 
 } // namespace blink