Limit the number of accelerated canvases that can exist in a render process

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 69 matching lines @@
     : m_snapshotState(InitialSnapshotState)
     , m_surface(std::move(surface))
     , m_client(0)
     , m_gpuMemoryUsage(0)
 {
     m_surface->setImageBuffer(this);
     updateGPUMemoryUsage();
 }
 
 intptr_t ImageBuffer::s_globalGPUMemoryUsage = 0;
+unsigned ImageBuffer::s_globalAcceleratedImageBufferCount = 0;
 
 ImageBuffer::~ImageBuffer()
 {
+    if (m_gpuMemoryUsage) {
+        DCHECK_GT(s_globalAcceleratedImageBufferCount, 0u);
+        s_globalAcceleratedImageBufferCount--;
+    }
     ImageBuffer::s_globalGPUMemoryUsage -= m_gpuMemoryUsage;
 }
 
 SkCanvas* ImageBuffer::canvas() const
 {
     return m_surface->canvas();
 }
 
 void ImageBuffer::disableDeferral(DisableDeferralReason reason) const
 {
@@ skipping 189 matching lines @@
         size_t allocSizeInBytes = rect.width() * rect.height() * 4;
         void* data;
         WTF::ArrayBufferContents::allocateMemoryOrNull(allocSizeInBytes, WTF::ArrayBufferContents::ZeroInitialize, data);
         if (!data)
             return false;
         WTF::ArrayBufferContents result(data, allocSizeInBytes, WTF::ArrayBufferContents::NotShared);
         result.transfer(contents);
         return true;
     }
 
-    ASSERT(canvas());
+    DCHECK(canvas());
     RefPtr<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()
         || rect.maxY() > m_surface->size().height();
@@ skipping 45 matching lines @@
 void ImageBuffer::updateGPUMemoryUsage() const
 {
     if (this->isAccelerated()) {
         // If image buffer is accelerated, we should keep track of GPU memory usage.
         int gpuBufferCount = 2;
         CheckedNumeric<intptr_t> checkedGPUUsage = 4 * gpuBufferCount;
         checkedGPUUsage *= this->size().width();
         checkedGPUUsage *= this->size().height();
         intptr_t gpuMemoryUsage = checkedGPUUsage.ValueOrDefault(std::numeric_limits<intptr_t>::max());
 
+        if (!m_gpuMemoryUsage) // was not accelerated before
+            s_globalAcceleratedImageBufferCount++;
+
         s_globalGPUMemoryUsage += (gpuMemoryUsage - m_gpuMemoryUsage);
         m_gpuMemoryUsage = gpuMemoryUsage;
-    } else if (m_gpuMemoryUsage > 0) {
+    } 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;
     }
 }
 
 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;
@@ skipping 17 matching lines @@
     ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
 
     Vector<unsigned char> result;
     if (!encodeImage(mimeType, quality, &result))
         return "data:,";
 
     return "data:" + mimeType + ";base64," + base64Encode(result);
 }
 
 } // namespace blink