Fixing laggy chrome on a multitude of accelerated canvases

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 61 matching lines @@
     OwnPtr<ImageBufferSurface> surface(adoptPtr(new UnacceleratedImageBufferSurface(size, opacityMode, initializationMode)));
     if (!surface->isValid())
         return nullptr;
     return adoptPtr(new ImageBuffer(surface.release()));
 }
 
 ImageBuffer::ImageBuffer(PassOwnPtr<ImageBufferSurface> surface)
     : m_snapshotState(InitialSnapshotState)
     , m_surface(surface)
     , m_client(0)
+    , m_gpuMemoryUsage(0)
 {
     m_surface->setImageBuffer(this);
+    updateGPUMemoryUsage();
 }
 
+intptr_t ImageBuffer::s_globalGPUMemoryUsage = 0;
+
 ImageBuffer::~ImageBuffer()
 {
+    ImageBuffer::s_globalGPUMemoryUsage -= m_gpuMemoryUsage;
 }
 
 SkCanvas* ImageBuffer::canvas() const
 {
     return m_surface->canvas();
 }
 
 void ImageBuffer::disableDeferral() const
 {
     return m_surface->disableDeferral();
@@ skipping 238 matching lines @@
     ASSERT(originY >= 0);
     ASSERT(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);
     m_surface->writePixels(info, srcAddr, srcBytesPerRow, destX, destY);
 }
 
+void ImageBuffer::updateGPUMemoryUsage() const
+{
+    if (this->isAccelerated()) {
+        // If image buffer is accelerated, we should keep track of GPU memory usage.
+        int gpuBufferCount = 2;
+        Checked<intptr_t, RecordOverflow> checkedGPUUsage = 4 * gpuBufferCount;
+        checkedGPUUsage *= this->size().width();
+        checkedGPUUsage *= this->size().height();
+        intptr_t gpuMemoryUsage;
+        if (checkedGPUUsage.safeGet(gpuMemoryUsage) == CheckedState::DidOverflow)
+            gpuMemoryUsage = std::numeric_limits<intptr_t>::max();
+
+        s_globalGPUMemoryUsage += (gpuMemoryUsage - m_gpuMemoryUsage);
+        m_gpuMemoryUsage = gpuMemoryUsage;
+    } else if (m_gpuMemoryUsage > 0) {
+        // In case of switching from accelerated to non-accelerated mode,
+        // the GPU memory usage needs to be updated too.
+        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") {
         int compressionQuality = JPEGImageEncoder::DefaultCompressionQuality;
         if (quality >= 0.0 && quality <= 1.0)
             compressionQuality = static_cast<int>(quality * 100 + 0.5);
         if (!JPEGImageEncoder::encode(*this, compressionQuality, encodedImage))
             return false;
     } else if (mimeType == "image/webp") {
         int compressionQuality = WEBPImageEncoder::DefaultCompressionQuality;
@@ skipping 15 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