Fixing laggy chrome on a multitude of accelerated canvases

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 51 matching lines @@
 #include <math.h>
 #include <v8.h>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 
 // These values come from the WhatWG spec.
-const int DefaultWidth = 300;
-const int DefaultHeight = 150;
+const int kDefaultWidth = 300;

[Justin Novosad, 2015/12/02 16:33:33]

The k prefix is a skia thing. In Blink use CapitalizedCamelCase.

[danakj, 2015/12/02 18:23:40]

It's also a chromium thing, I didn't know blink has a diff rule currently.

[danakj, 2015/12/02 18:31:09]

FWIW I only see a blink-specific rule for enums: "Enum members should use
InterCaps with an initial capital letter. [names-enum-members]"

I guess another thing to converge on though.

+const int kDefaultHeight = 150;
 
 // Firefox limits width/height to 32767 pixels, but slows down dramatically before it
 // reaches that limit. We limit by area instead, giving us larger maximum dimensions,
 // in exchange for a smaller maximum canvas size.
-const int MaxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels
+const int kMaxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels
 
 // In Skia, we will also limit width/height to 32767.
-const int MaxSkiaDim = 32767; // Maximum width/height in CSS pixels.
+const int kMaxSkiaDim = 32767; // Maximum width/height in CSS pixels.
+
+// We estimate the max limit of GPU allocated memory for canvases before Chrome becomes laggy by setting the
+// total allocated memory for accelerated canvases to be equivalent to memory used by 80 accelerated
+// canvases, each has a size of 1000*500 and 2d context.
+// Each such canvas occupies 6000000 = 1000 * 500 * 3 * 4 bytes, where 3 is the bufferCount in
+// updateExternallyAllocatedMemory() and 4 means four bytes per pixel per buffer.
+#if !OS(ANDROID)
+const int kMaxTotalExternallyAllocatedMemory = 6000000 * 80;
+#else
+// We estimate that the max limit for android phones is half of that for desktops based on local
+// experimental results on Android One; though a very slight lagginess on Android One is still expected,
+// other Android devices should work fine.
+const int kMaxTotalExternallyAllocatedMemory = 6000000 * 40;
+#endif
 
 // A default value of quality argument for toDataURL and toBlob
 // It is in an invalid range (outside 0.0 - 1.0) so that it will not be misinterpreted as a user-input value
-const int UndefinedQualityValue = -1.0;
+const int kUndefinedQualityValue = -1.0;
 
 // Default image mime type for toDataURL and toBlob functions
-const char DefaultMimeType[] = "image/png";
+const char kDefaultMimeType[] = "image/png";
 
 bool canCreateImageBuffer(const IntSize& size)
 {
     if (size.isEmpty())
         return false;
-    if (size.width() * size.height() > MaxCanvasArea)
+    if (size.width() * size.height() > kMaxCanvasArea)
         return false;
-    if (size.width() > MaxSkiaDim || size.height() > MaxSkiaDim)
+    if (size.width() > kMaxSkiaDim || size.height() > kMaxSkiaDim)
         return false;
     return true;
 }
 
 PassRefPtr<Image> createTransparentImage(const IntSize& size)
 {
     ASSERT(canCreateImageBuffer(size));
     RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterN32Premul(size.width(), size.height()));
     surface->getCanvas()->clear(SK_ColorTRANSPARENT);
     return StaticBitmapImage::create(adoptRef(surface->newImageSnapshot()));
 }
 
 } // namespace
 
 inline HTMLCanvasElement::HTMLCanvasElement(Document& document)
     : HTMLElement(canvasTag, document)
     , DocumentVisibilityObserver(document)
-    , m_size(DefaultWidth, DefaultHeight)
+    , m_size(kDefaultWidth, kDefaultHeight)
     , m_ignoreReset(false)
     , m_externallyAllocatedMemory(0)
     , m_originClean(true)
     , m_didFailToCreateImageBuffer(false)
     , m_imageBufferIsClear(false)
 {
     setHasCustomStyleCallbacks();
     CanvasMetrics::countCanvasContextUsage(CanvasMetrics::CanvasCreated);
 }
 
 DEFINE_NODE_FACTORY(HTMLCanvasElement)
 
+intptr_t HTMLCanvasElement::s_totalMemoryForAcceleratedCanvases = 0;
+
 HTMLCanvasElement::~HTMLCanvasElement()
 {
     v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
+    if (m_imageBuffer && m_imageBuffer->isAccelerated())
+        updateTotalMemoryForAcceleratedCanvases(-m_externallyAllocatedMemory);
 #if !ENABLE(OILPAN)
     // Ensure these go away before the ImageBuffer.
     m_context.clear();
 #endif
 }
 
 void HTMLCanvasElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
     if (name == widthAttr || name == heightAttr)
         reset();
@@ skipping 200 matching lines @@
     if (m_ignoreReset)
         return;
 
     m_dirtyRect = FloatRect();
 
     bool ok;
     bool hadImageBuffer = hasImageBuffer();
 
     int w = getAttribute(widthAttr).toInt(&ok);
     if (!ok || w < 0)
-        w = DefaultWidth;
+        w = kDefaultWidth;
 
     int h = getAttribute(heightAttr).toInt(&ok);
     if (!ok || h < 0)
-        h = DefaultHeight;
+        h = kDefaultHeight;
 
     if (m_context && m_context->is2d())
         m_context->reset();
 
     IntSize oldSize = size();
     IntSize newSize(w, h);
 
     // If the size of an existing buffer matches, we can just clear it instead of reallocating.
     // This optimization is only done for 2D canvases for now.
     if (hadImageBuffer && oldSize == newSize && m_context && m_context->is2d() && !buffer()->isRecording()) {
@@ skipping 79 matching lines @@
         m_context->didSetSurfaceSize();
     }
 }
 
 String HTMLCanvasElement::toEncodingMimeType(const String& mimeType)
 {
     String lowercaseMimeType = mimeType.lower();
 
     // FIXME: Make isSupportedImageMIMETypeForEncoding threadsafe (to allow this method to be used on a worker thread).
     if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(lowercaseMimeType))
-        lowercaseMimeType = DefaultMimeType;
+        lowercaseMimeType = kDefaultMimeType;
 
     return lowercaseMimeType;
 }
 
 const AtomicString HTMLCanvasElement::imageSourceURL() const
 {
-    return AtomicString(toDataURLInternal(DefaultMimeType, 0, FrontBuffer));
+    return AtomicString(toDataURLInternal(kDefaultMimeType, 0, FrontBuffer));
 }
 
 void HTMLCanvasElement::prepareSurfaceForPaintingIfNeeded() const
 {
     ASSERT(m_context && m_context->is2d()); // This function is called by the 2d context
     if (buffer())
         m_imageBuffer->prepareSurfaceForPaintingIfNeeded();
 }
 
 ImageData* HTMLCanvasElement::toImageData(SourceDrawingBuffer sourceBuffer) const
@@ skipping 42 matching lines @@
 
     return ImageDataBuffer(imageData->size(), imageData->data()->data()).toDataURL(encodingMimeType, quality);
 }
 
 String HTMLCanvasElement::toDataURL(const String& mimeType, const ScriptValue& qualityArgument, ExceptionState& exceptionState) const
 {
     if (!originClean()) {
         exceptionState.throwSecurityError("Tainted canvases may not be exported.");
         return String();
     }
-    double quality = UndefinedQualityValue;
+    double quality = kUndefinedQualityValue;
     if (!qualityArgument.isEmpty()) {
         v8::Local<v8::Value> v8Value = qualityArgument.v8Value();
         if (v8Value->IsNumber()) {
             quality = v8Value.As<v8::Number>()->Value();
         }
     }
     return toDataURLInternal(mimeType, quality, BackBuffer);
 }
 
 void HTMLCanvasElement::toBlob(FileCallback* callback, const String& mimeType, const ScriptValue& qualityArgument, ExceptionState& exceptionState)
 {
     if (!originClean()) {
         exceptionState.throwSecurityError("Tainted canvases may not be exported.");
         return;
     }
 
     if (!isPaintable()) {
         // If the canvas element's bitmap has no pixels
         Platform::current()->mainThread()->taskRunner()->postTask(BLINK_FROM_HERE, bind(&FileCallback::handleEvent, callback, nullptr));
         return;
     }
 
-    double quality = UndefinedQualityValue;
+    double quality = kUndefinedQualityValue;
     if (!qualityArgument.isEmpty()) {
         v8::Local<v8::Value> v8Value = qualityArgument.v8Value();
         if (v8Value->IsNumber()) {
             quality = v8Value.As<v8::Number>()->Value();
         }
     }
 
     String encodingMimeType = toEncodingMimeType(mimeType);
 
     ImageData* imageData = toImageData(BackBuffer);
     // imageData unref its data, which we still keep alive for the async toBlob thread
     ScopedDisposal<ImageData> disposer(imageData);
     // Add a ref to keep image data alive until completion of encoding
     RefPtr<DOMUint8ClampedArray> imageDataRef(imageData->data());
 
     RefPtr<CanvasAsyncBlobCreator> asyncCreatorRef = CanvasAsyncBlobCreator::create(imageDataRef.release(), encodingMimeType, imageData->size(), callback);
-    if (Platform::current()->isThreadedCompositingEnabled() && (encodingMimeType == DefaultMimeType)) {
+    if (Platform::current()->isThreadedCompositingEnabled() && (encodingMimeType == kDefaultMimeType)) {
         asyncCreatorRef->scheduleAsyncBlobCreation(true);
     } else {
         asyncCreatorRef->scheduleAsyncBlobCreation(false, quality);
     }
 }
 
 SecurityOrigin* HTMLCanvasElement::securityOrigin() const
 {
     return document().securityOrigin();
 }
@@ skipping 34 matching lines @@
             return false;
     }
 
     // Do not use acceleration for small canvas.
     if (canvasPixelCount < settings->minimumAccelerated2dCanvasSize())
         return false;
 
     if (!Platform::current()->canAccelerate2dCanvas())
         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 (s_totalMemoryForAcceleratedCanvases >= kMaxTotalExternallyAllocatedMemory)

[Justin Novosad, 2015/12/02 16:33:34]

Constant should be named in a way that reflects the fact that is is about GPU
memeory, and not externally allocated.  The notion of "externally allocated" is
a V8 concept that has nothing to do with this.

+        return false;
+
     return true;
 }
 
 class UnacceleratedSurfaceFactory : public RecordingImageBufferFallbackSurfaceFactory {
 public:
     virtual PassOwnPtr<ImageBufferSurface> createSurface(const IntSize& size, OpacityMode opacityMode)
     {
         return adoptPtr(new UnacceleratedImageBufferSurface(size, opacityMode));
     }
 
@@ skipping 140 matching lines @@
     if (is3D())
         checkedExternallyAllocatedMemory += m_context->externallyAllocatedBytesPerPixel();
 
     checkedExternallyAllocatedMemory *= width();
     checkedExternallyAllocatedMemory *= height();
     intptr_t externallyAllocatedMemory;
     if (checkedExternallyAllocatedMemory.safeGet(externallyAllocatedMemory) == CheckedState::DidOverflow)
         externallyAllocatedMemory = std::numeric_limits<intptr_t>::max();
 
     // Subtracting two intptr_t that are known to be positive will never underflow.
-    v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(externallyAllocatedMemory - m_externallyAllocatedMemory);
+    intptr_t diffFromCurrAllocatedMemory = externallyAllocatedMemory - m_externallyAllocatedMemory;
+    v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(diffFromCurrAllocatedMemory);
     m_externallyAllocatedMemory = externallyAllocatedMemory;
+
+    if (m_imageBuffer && m_imageBuffer->isAccelerated())
+        updateTotalMemoryForAcceleratedCanvases(diffFromCurrAllocatedMemory);

[Justin Novosad, 2015/12/02 16:33:34]

This is wrong. You need to track gpu allocated memory independently of
externally allocated memory otherwise your total will drift when you have a
canvas that switches between accelerated and non-accelerated (for example when
it is resized).

+}
+
+void HTMLCanvasElement::updateTotalMemoryForAcceleratedCanvases(intptr_t diffFromCurrAllocatedMemory)
+{
+    ASSERT(isMainThread());
+
+    Checked<intptr_t, RecordOverflow> checkedExternallyAllocatedMemory = s_totalMemoryForAcceleratedCanvases;

[Justin Novosad, 2015/12/02 16:33:33]

Don't use the term "ExternallyAllocated" here, it is confusing.

+    checkedExternallyAllocatedMemory += diffFromCurrAllocatedMemory;
+    intptr_t externallyAllocatedMemory;
+    if (checkedExternallyAllocatedMemory.safeGet(externallyAllocatedMemory) == CheckedState::DidOverflow)
+        externallyAllocatedMemory = std::numeric_limits<intptr_t>::max();
+
+    s_totalMemoryForAcceleratedCanvases = externallyAllocatedMemory;
 }
 
 SkCanvas* HTMLCanvasElement::drawingCanvas() const
 {
     return buffer() ? m_imageBuffer->canvas() : nullptr;
 }
 
 void HTMLCanvasElement::disableDeferral() const
 {
     if (buffer())
@@ skipping 161 matching lines @@
     }
     return ImageBitmapSource::fulfillImageBitmap(scriptState, isPaintable() ? ImageBitmap::create(this, IntRect(sx, sy, sw, sh)) : nullptr);
 }
 
 bool HTMLCanvasElement::isOpaque() const
 {
     return m_context && !m_context->hasAlpha();
 }
 
 } // blink