Add an heuristic for promoting canvases to GPU acceleration

third_party/WebKit/Source/platform/graphics/ImageBuffer.cpp

 /*
  * Copyright (c) 2008, Google Inc. All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * 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:
  *
  *     * Redistributions of source code must retain the above copyright
@@ skipping 128 matching lines @@
 }
 
 bool ImageBuffer::isSurfaceValid() const {
   return m_surface->isValid();
 }
 
 bool ImageBuffer::isDirty() {
   return m_client ? m_client->isDirty() : false;
 }
 
-void ImageBuffer::didDisableAcceleration() const {
-  DCHECK(m_gpuMemoryUsage);
-  DCHECK_GT(s_globalAcceleratedImageBufferCount, 0u);
-  if (m_client)
-    m_client->didDisableAcceleration();
-  s_globalAcceleratedImageBufferCount--;
-  s_globalGPUMemoryUsage -= m_gpuMemoryUsage;
-  m_gpuMemoryUsage = 0;
-}
-
 void ImageBuffer::didFinalizeFrame() {
   if (m_client)
     m_client->didFinalizeFrame();
 }
 
 void ImageBuffer::finalizeFrame(const FloatRect& dirtyRect) {
   m_surface->finalizeFrame(dirtyRect);
   didFinalizeFrame();
 }
 
@@ skipping 191 matching lines @@
       return false;
     WTF::ArrayBufferContents result(data, allocSizeInBytes,
                                     WTF::ArrayBufferContents::NotShared);
     result.transfer(contents);
     return true;
   }
 
   DCHECK(canvas());
 
   if (ExpensiveCanvasHeuristicParameters::GetImageDataForcesNoAcceleration &&
-      !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled())
+      !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled()) {
     const_cast<ImageBuffer*>(this)->disableAcceleration();
+  }
 
   sk_sp<SkImage> snapshot = m_surface->newImageSnapshot(
       PreferNoAcceleration, SnapshotReasonGetImageData);
   if (!snapshot)
     return false;
 
   const bool mayHaveStrayArea =
       m_surface->isAccelerated()  // GPU readback may fail silently
       || rect.x() < 0 || rect.y() < 0 ||
       rect.maxX() > m_surface->size().width() ||
@@ skipping 53 matching lines @@
 }
 
 void ImageBuffer::putByteArray(Multiply multiplied,
                                const unsigned char* source,
                                const IntSize& sourceSize,
                                const IntRect& sourceRect,
                                const IntPoint& destPoint) {
   if (!isSurfaceValid())
     return;
 
-  ASSERT(sourceRect.width() > 0);
-  ASSERT(sourceRect.height() > 0);
+  DCHECK_GT(sourceRect.width(), 0);
+  DCHECK_GT(sourceRect.height(), 0);
 
   int originX = sourceRect.x();
   int destX = destPoint.x() + sourceRect.x();
-  ASSERT(destX >= 0);
-  ASSERT(destX < m_surface->size().width());
-  ASSERT(originX >= 0);
-  ASSERT(originX < sourceRect.maxX());
+  DCHECK_GE(destX, 0);
+  DCHECK_LT(destX, m_surface->size().width());
+  DCHECK_GE(originX, 0);
+  DCHECK_LT(originX, sourceRect.maxX());
 
   int originY = sourceRect.y();
   int destY = destPoint.y() + sourceRect.y();
-  ASSERT(destY >= 0);
-  ASSERT(destY < m_surface->size().height());
-  ASSERT(originY >= 0);
-  ASSERT(originY < sourceRect.maxY());
+  DCHECK_GE(destY, 0);
+  DCHECK_LT(destY, m_surface->size().height());
+  DCHECK_GE(originY, 0);
+  DCHECK_LT(originY, sourceRect.maxY());
 
   const size_t srcBytesPerRow = 4 * sourceSize.width();
   const void* srcAddr = source + originY * srcBytesPerRow + originX * 4;
   SkAlphaType alphaType = (multiplied == Premultiplied) ? kPremul_SkAlphaType
                                                         : kUnpremul_SkAlphaType;
   SkImageInfo info = SkImageInfo::Make(
       sourceRect.width(), sourceRect.height(), kRGBA_8888_SkColorType,
       alphaType, SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named));
 
   m_surface->writePixels(info, srcAddr, srcBytesPerRow, destX, destY);
@@ skipping 14 matching lines @@
 
     s_globalGPUMemoryUsage += (gpuMemoryUsage - m_gpuMemoryUsage);
     m_gpuMemoryUsage = gpuMemoryUsage;
   } else if (m_gpuMemoryUsage) {
     // In case of switching from accelerated to non-accelerated mode,
     // the GPU memory usage needs to be updated too.
     DCHECK_GT(s_globalAcceleratedImageBufferCount, 0u);
     s_globalAcceleratedImageBufferCount--;
     s_globalGPUMemoryUsage -= m_gpuMemoryUsage;
     m_gpuMemoryUsage = 0;
+
+    if (m_client)
+      m_client->didDisableAcceleration();
   }
 }
 
 namespace {
 
 class UnacceleratedSurfaceFactory
     : public RecordingImageBufferFallbackSurfaceFactory {
  public:
   virtual std::unique_ptr<ImageBufferSurface> createSurface(
       const IntSize& size,
       OpacityMode opacityMode,
       sk_sp<SkColorSpace> colorSpace,
       SkColorType colorType) {
     return WTF::wrapUnique(new UnacceleratedImageBufferSurface(
         size, opacityMode, InitializeImagePixels, std::move(colorSpace),
         colorType));
   }
 
   virtual ~UnacceleratedSurfaceFactory() {}
 };
 
 }  // namespace
 
 void ImageBuffer::disableAcceleration() {
   if (!isAccelerated())
     return;
 
-  sk_sp<SkImage> image =
-      m_surface->newImageSnapshot(PreferNoAcceleration, SnapshotReasonPaint);
-  // Using a GPU-backed image with RecordingImageBufferSurface
-  // will fail at playback time.
-  image = image->makeNonTextureImage();
-
   // Create and configure a recording (unaccelerated) surface.
   std::unique_ptr<RecordingImageBufferFallbackSurfaceFactory> surfaceFactory =
       WTF::makeUnique<UnacceleratedSurfaceFactory>();
   std::unique_ptr<ImageBufferSurface> surface =
       WTF::wrapUnique(new RecordingImageBufferSurface(
           m_surface->size(), std::move(surfaceFactory),
           m_surface->getOpacityMode(), m_surface->colorSpace()));
+  setSurface(std::move(surface));
+}
+
+void ImageBuffer::setSurface(std::unique_ptr<ImageBufferSurface> surface) {
+  sk_sp<SkImage> image =
+      m_surface->newImageSnapshot(PreferNoAcceleration, SnapshotReasonPaint);
+
+  if (surface->isRecording()) {
+    // Using a GPU-backed image with RecordingImageBufferSurface
+    // will fail at playback time.
+    image = image->makeNonTextureImage();
+  }
+
   surface->canvas()->drawImage(image.get(), 0, 0);
   surface->setImageBuffer(this);
   if (m_client)
     m_client->restoreCanvasMatrixClipStack(surface->canvas());
   m_surface = std::move(surface);
 
-  didDisableAcceleration();
+  updateGPUMemoryUsage();
 }
 
 bool ImageDataBuffer::encodeImage(const String& mimeType,
                                   const double& quality,
                                   Vector<unsigned char>* encodedImage) const {
   if (mimeType == "image/jpeg") {
     if (!JPEGImageEncoder::encode(*this, quality, encodedImage))
       return false;
   } else if (mimeType == "image/webp") {
     int compressionQuality = WEBPImageEncoder::DefaultCompressionQuality;
     if (quality >= 0.0 && quality <= 1.0)
       compressionQuality = static_cast<int>(quality * 100 + 0.5);
     if (!WEBPImageEncoder::encode(*this, compressionQuality, encodedImage))
       return false;
   } else {
     if (!PNGImageEncoder::encode(*this, encodedImage))
       return false;
-    ASSERT(mimeType == "image/png");
+    DCHECK_EQ(mimeType, "image/png");
   }
 
   return true;
 }
 
 String ImageDataBuffer::toDataURL(const String& mimeType,
                                   const double& quality) const {
-  ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
+  DCHECK(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
 
   Vector<unsigned char> result;
   if (!encodeImage(mimeType, quality, &result))
     return "data:,";
 
   return "data:" + mimeType + ";base64," + base64Encode(result);
 }
 
 }  // namespace blink