Add an heuristic for promoting canvases to GPU acceleration

third_party/WebKit/Source/core/html/HTMLCanvasElement.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. 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.
@@ skipping 774 matching lines @@
 
 bool HTMLCanvasElement::originClean() const {
   if (document().settings() &&
       document().settings()->getDisableReadingFromCanvas())
     return false;
   if (placeholderFrame())
     return placeholderFrame()->originClean();
   return m_originClean;
 }
 
-bool HTMLCanvasElement::shouldAccelerate(const IntSize& size) const {
+bool HTMLCanvasElement::shouldAccelerate(AccelerationCriteria criteria) const {
   if (m_context && !m_context->is2d())
     return false;
 
   if (RuntimeEnabledFeatures::forceDisplayList2dCanvasEnabled())
     return false;
 
   if (!RuntimeEnabledFeatures::accelerated2dCanvasEnabled())
     return false;
 
   // The following is necessary for handling the special case of canvases in the
   // dev tools overlay, which run in a process that supports accelerated 2d
   // canvas but in a special compositing context that does not.
   if (layoutBox() && !layoutBox()->hasAcceleratedCompositing())
     return false;
 
-  CheckedNumeric<int> checkedCanvasPixelCount = size.width();
-  checkedCanvasPixelCount *= size.height();
+  CheckedNumeric<int> checkedCanvasPixelCount = size().width();
+  checkedCanvasPixelCount *= size().height();
   if (!checkedCanvasPixelCount.IsValid())
     return false;
   int canvasPixelCount = checkedCanvasPixelCount.ValueOrDie();
 
   if (RuntimeEnabledFeatures::displayList2dCanvasEnabled()) {
 #if 0
         // TODO(junov): re-enable this code once we solve the problem of recording
         // GPU-backed images to an SkPicture for cross-context rendering crbug.com/490328
 
         // If the compositor provides GPU acceleration to display list canvases, we
         // prefer that over direct acceleration.
         if (document().viewportDescription().matchesHeuristicsForGpuRasterization())
             return false;
 #endif
     // If the GPU resources would be very expensive, prefer a display list.
     if (canvasPixelCount > ExpensiveCanvasHeuristicParameters::
                                PreferDisplayListOverGpuSizeThreshold)
       return false;
   }
 
   // Do not use acceleration for small canvas.
-  Settings* settings = document().settings();
-  if (!settings ||
-      canvasPixelCount < settings->getMinimumAccelerated2dCanvasSize())
-    return false;
+  if (criteria != IgnoreCanvasSizeAccelerationCriteria) {
+    Settings* settings = document().settings();
+    if (!settings ||
+        canvasPixelCount < settings->getMinimumAccelerated2dCanvasSize())
+      return false;
+  }
 
   // When GPU allocated memory runs low (due to having created too many
   // accelerated canvases), the compositor starves and browser becomes laggy.
   // Thus, we should stop allocating more GPU memory to new canvases created
   // when the current memory usage exceeds the threshold.
   if (ImageBuffer::getGlobalGPUMemoryUsage() >= MaxGlobalGPUMemoryUsage)
     return false;
 
   // Allocating too many GPU resources can makes us run into the driver's
   // resource limits. So we need to keep the number of texture resources
@@ skipping 17 matching lines @@
       SkColorType colorType) {
     return WTF::wrapUnique(new UnacceleratedImageBufferSurface(
         size, opacityMode, InitializeImagePixels, colorSpace, colorType));
   }
 
   virtual ~UnacceleratedSurfaceFactory() {}
 };
 
 }  // namespace
 
-bool HTMLCanvasElement::shouldUseDisplayList(const IntSize& deviceSize) {
+bool HTMLCanvasElement::shouldUseDisplayList() {
   if (m_context->colorSpace() != kLegacyCanvasColorSpace)
     return false;
 
   if (RuntimeEnabledFeatures::forceDisplayList2dCanvasEnabled())
     return true;
 
   if (!RuntimeEnabledFeatures::displayList2dCanvasEnabled())
     return false;
 
   return true;
 }
 
 std::unique_ptr<ImageBufferSurface>
-HTMLCanvasElement::createWebGLImageBufferSurface(const IntSize& deviceSize,
-                                                 OpacityMode opacityMode) {
+HTMLCanvasElement::createWebGLImageBufferSurface(OpacityMode opacityMode) {
   DCHECK(is3D());
   // If 3d, but the use of the canvas will be for non-accelerated content
   // then make a non-accelerated ImageBuffer. This means copying the internal
   // Image will require a pixel readback, but that is unavoidable in this case.
   auto surface = WTF::wrapUnique(new AcceleratedImageBufferSurface(
-      deviceSize, opacityMode, m_context->skColorSpace(),
-      m_context->colorType()));
+      size(), opacityMode, m_context->skColorSpace(), m_context->colorType()));
   if (surface->isValid())
     return std::move(surface);
   return nullptr;
 }
 
 std::unique_ptr<ImageBufferSurface>
 HTMLCanvasElement::createAcceleratedImageBufferSurface(
-    const IntSize& deviceSize,
     OpacityMode opacityMode,
     int* msaaSampleCount) {
-  if (!shouldAccelerate(deviceSize))
-    return nullptr;
-
   if (document().settings()) {
     *msaaSampleCount =
         document().settings()->getAccelerated2dCanvasMSAASampleCount();
   }
 
   // Avoid creating |contextProvider| until we're sure we want to try use it,
   // since it costs us GPU memory.
   std::unique_ptr<WebGraphicsContext3DProvider> contextProvider(
       Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
   if (!contextProvider) {
     CanvasMetrics::countCanvasContextUsage(
         CanvasMetrics::Accelerated2DCanvasGPUContextLost);
     return nullptr;
   }
 
   if (contextProvider->isSoftwareRendering())
     return nullptr;  // Don't use accelerated canvas with swiftshader.
 
   std::unique_ptr<ImageBufferSurface> surface =
       WTF::wrapUnique(new Canvas2DImageBufferSurface(
-          std::move(contextProvider), deviceSize, *msaaSampleCount, opacityMode,
+          std::move(contextProvider), size(), *msaaSampleCount, opacityMode,
           Canvas2DLayerBridge::EnableAcceleration, m_context->skColorSpace(),
           m_context->colorType()));
   if (!surface->isValid()) {
     CanvasMetrics::countCanvasContextUsage(
         CanvasMetrics::GPUAccelerated2DCanvasImageBufferCreationFailed);
     return nullptr;
   }
 
   CanvasMetrics::countCanvasContextUsage(
       CanvasMetrics::GPUAccelerated2DCanvasImageBufferCreated);
   return surface;
 }
 
 std::unique_ptr<ImageBufferSurface>
 HTMLCanvasElement::createUnacceleratedImageBufferSurface(
-    const IntSize& deviceSize,
     OpacityMode opacityMode) {
-  if (shouldUseDisplayList(deviceSize)) {
+  if (shouldUseDisplayList()) {
     auto surface = WTF::wrapUnique(new RecordingImageBufferSurface(
-        deviceSize, WTF::wrapUnique(new UnacceleratedSurfaceFactory),
-        opacityMode, m_context->skColorSpace(), m_context->colorType()));
+        size(), WTF::wrapUnique(new UnacceleratedSurfaceFactory), opacityMode,
+        m_context->skColorSpace(), m_context->colorType()));
     if (surface->isValid()) {
       CanvasMetrics::countCanvasContextUsage(
           CanvasMetrics::DisplayList2DCanvasImageBufferCreated);
       return std::move(surface);
     }
     // We fallback to a non-display-list surface without recording a metric
     // here.
   }
 
   auto surfaceFactory = WTF::makeUnique<UnacceleratedSurfaceFactory>();
-  auto surface = surfaceFactory->createSurface(deviceSize, opacityMode,
-                                               m_context->skColorSpace(),
-                                               m_context->colorType());
+  auto surface = surfaceFactory->createSurface(
+      size(), opacityMode, m_context->skColorSpace(), m_context->colorType());
   if (surface->isValid()) {
     CanvasMetrics::countCanvasContextUsage(
         CanvasMetrics::Unaccelerated2DCanvasImageBufferCreated);
     return surface;
   }
 
   CanvasMetrics::countCanvasContextUsage(
       CanvasMetrics::Unaccelerated2DCanvasImageBufferCreationFailed);
   return nullptr;
 }
@@ skipping 16 matching lines @@
 
   OpacityMode opacityMode =
       !m_context || m_context->creationAttributes().alpha() ? NonOpaque
                                                             : Opaque;
   int msaaSampleCount = 0;
   std::unique_ptr<ImageBufferSurface> surface;
   if (externalSurface) {
     if (externalSurface->isValid())
       surface = std::move(externalSurface);
   } else if (is3D()) {
-    surface = createWebGLImageBufferSurface(size(), opacityMode);
+    surface = createWebGLImageBufferSurface(opacityMode);
   } else {
-    surface = createAcceleratedImageBufferSurface(size(), opacityMode,
-                                                  &msaaSampleCount);
+    if (shouldAccelerate(NormalAccelerationCriteria)) {
+      surface =
+          createAcceleratedImageBufferSurface(opacityMode, &msaaSampleCount);
+    }
     if (!surface) {
-      surface = createUnacceleratedImageBufferSurface(size(), opacityMode);
+      surface = createUnacceleratedImageBufferSurface(opacityMode);
     }
   }
   if (!surface)
     return;
   DCHECK(surface->isValid());
   m_imageBuffer = ImageBuffer::create(std::move(surface));
   DCHECK(m_imageBuffer);
   m_imageBuffer->setClient(this);
 
   m_didFailToCreateImageBuffer = false;
 
   updateExternallyAllocatedMemory();
 
   if (is3D()) {
     // Early out for WebGL canvases
     return;
   }
 
-  m_imageBuffer->setClient(this);
   // Enabling MSAA overrides a request to disable antialiasing. This is true
   // regardless of whether the rendering mode is accelerated or not. For
   // consistency, we don't want to apply AA in accelerated canvases but not in
   // unaccelerated canvases.
   if (!msaaSampleCount && document().settings() &&
       !document().settings()->getAntialiased2dCanvasEnabled())
     m_context->setShouldAntialias(false);
 
   if (m_context)
     setNeedsCompositingUpdate();
@@ skipping 27 matching lines @@
       // Adding 2 is a pessimistic but relevant estimate.
       // Note: These buffers might be allocated in GPU memory.
       bufferCount += 2;
     }
   }
   if (m_copiedImage)
     bufferCount++;
 
   // Four bytes per pixel per buffer.
   CheckedNumeric<intptr_t> checkedExternallyAllocatedMemory = 4 * bufferCount;
-  if (is3D())
+  if (is3D()) {
     checkedExternallyAllocatedMemory +=
         m_context->externallyAllocatedBytesPerPixel();
+  }
 
   checkedExternallyAllocatedMemory *= width();
   checkedExternallyAllocatedMemory *= height();
   intptr_t externallyAllocatedMemory =
       checkedExternallyAllocatedMemory.ValueOrDefault(
           std::numeric_limits<intptr_t>::max());
 
   // Subtracting two intptr_t that are known to be positive will never
   // underflow.
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(
@@ skipping 119 matching lines @@
   if (m_context)
     m_context->styleDidChange(oldStyle, newStyle);
 }
 
 void HTMLCanvasElement::didMoveToNewDocument(Document& oldDocument) {
   ContextLifecycleObserver::setContext(&document());
   PageVisibilityObserver::setContext(document().page());
   HTMLElement::didMoveToNewDocument(oldDocument);
 }
 
+void HTMLCanvasElement::willDrawImageTo2DContext(CanvasImageSource* source) {
+  if (ExpensiveCanvasHeuristicParameters::EnableAccelerationToAvoidReadbacks &&
+      source->isAccelerated() && !buffer()->isAccelerated() &&
+      shouldAccelerate(IgnoreCanvasSizeAccelerationCriteria)) {
+    OpacityMode opacityMode =
+        m_context->creationAttributes().alpha() ? NonOpaque : Opaque;
+    int msaaSampleCount = 0;
+    std::unique_ptr<ImageBufferSurface> surface =
+        createAcceleratedImageBufferSurface(opacityMode, &msaaSampleCount);
+    if (surface) {
+      buffer()->setSurface(std::move(surface));
+    }
+  }
+}
+
 PassRefPtr<Image> HTMLCanvasElement::getSourceImageForCanvas(
     SourceImageStatus* status,
     AccelerationHint hint,
     SnapshotReason reason,
     const FloatSize&) const {
   if (!width() || !height()) {
     *status = ZeroSizeCanvasSourceImageStatus;
     return nullptr;
   }
 
@@ skipping 27 matching lines @@
     if (hasImageBuffer()) {
       skImage = buffer()->newSkImageSnapshot(hint, reason);
     } else {
       skImage = createTransparentSkImage(size());
     }
   } else {
     if (ExpensiveCanvasHeuristicParameters::
             DisableAccelerationToAvoidReadbacks &&
         !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled() &&
         hint == PreferNoAcceleration && m_context->isAccelerated() &&
-        hasImageBuffer())
+        hasImageBuffer()) {
       buffer()->disableAcceleration();
+    }
     RefPtr<Image> image = renderingContext()->getImage(hint, reason);
     if (image) {
       skImage =
           image->imageForCurrentFrame(ColorBehavior::transformToGlobalTarget());
     } else {
       skImage = createTransparentSkImage(size());
     }
   }
 
   if (skImage) {
@@ skipping 138 matching lines @@
   m_surfaceLayerBridge = WTF::wrapUnique(new CanvasSurfaceLayerBridge(this));
   // Creates a placeholder layer first before Surface is created.
   m_surfaceLayerBridge->createSolidColorLayer();
 }
 
 void HTMLCanvasElement::OnWebLayerReplaced() {
   setNeedsCompositingUpdate();
 }
 
 }  // namespace blink