Improving canvas 2D performance by switching graphics rendering pipeline.

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 20 matching lines @@
  */
 
 #include "platform/graphics/ImageBuffer.h"
 
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBufferClient.h"
+#include "platform/graphics/RecordingImageBufferSurface.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/DrawingBuffer.h"
 #include "platform/graphics/gpu/Extensions3DUtil.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/image-encoders/JPEGImageEncoder.h"
 #include "platform/image-encoders/PNGImageEncoder.h"
 #include "platform/image-encoders/WEBPImageEncoder.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebExternalTextureMailbox.h"
@@ skipping 22 matching lines @@
 
 std::unique_ptr<ImageBuffer> ImageBuffer::create(const IntSize& size, OpacityMode opacityMode, ImageInitializationMode initializationMode)
 {
     std::unique_ptr<ImageBufferSurface> surface(wrapUnique(new UnacceleratedImageBufferSurface(size, opacityMode, initializationMode)));
     if (!surface->isValid())
         return nullptr;
     return wrapUnique(new ImageBuffer(std::move(surface)));
 }
 
 ImageBuffer::ImageBuffer(std::unique_ptr<ImageBufferSurface> surface)
-    : m_snapshotState(InitialSnapshotState)
+    : m_weakPtrFactory(this)
+    , 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;
@@ skipping 299 matching lines @@
     } 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;
     }
 }
 
+class UnacceleratedSurfaceFactory : public RecordingImageBufferFallbackSurfaceFactory {
+public:
+    virtual std::unique_ptr<ImageBufferSurface> createSurface(const IntSize& size, OpacityMode opacityMode)
+    {
+        return wrapUnique(new UnacceleratedImageBufferSurface(size, opacityMode));
+    }
+
+    virtual ~UnacceleratedSurfaceFactory() { }
+};
+
+void ImageBuffer::disableAcceleration()
+{
+    if (!isAccelerated()) {
+        return;
+    }
+
+    // Get current frame.
+    SkImage* image = m_surface->newImageSnapshot(PreferNoAcceleration, SnapshotReasonPaint).get();
+
+    // Create and configure a recording (unaccelerated) surface.
+    std::unique_ptr<RecordingImageBufferFallbackSurfaceFactory> surfaceFactory = wrapUnique(new UnacceleratedSurfaceFactory());
+    std::unique_ptr<ImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(m_surface->size(), std::move(surfaceFactory), m_surface->getOpacityMode()));
+    surface->canvas()->drawImage(image, 0, 0);
+    surface->setImageBuffer(this);
+
+    // Replace the current surface with the new surface.
+    m_surface = std::move(surface);
+
+    didDisableAcceleration();
+}
+
 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))
@@ skipping 12 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