Make disabling 2d canvas GPU acceleration for getImageData less aggressive.

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 81 matching lines @@
   if (!surface->isValid())
     return nullptr;
   return WTF::wrapUnique(new ImageBuffer(std::move(surface)));
 }
 
 ImageBuffer::ImageBuffer(std::unique_ptr<ImageBufferSurface> surface)
     : m_weakPtrFactory(this),
       m_snapshotState(InitialSnapshotState),
       m_surface(std::move(surface)),
       m_client(0),
+      m_gpuReadbackInvoked(false),

[Justin Novosad, 2017/02/16 15:27:20]

For clarity, let's call this m_gpuReadbackInvokedInCurrentFrame

[xiangze.zhang, 2017/02/17 02:13:45]

Done.

+      m_gpuReadbackSuccessiveFrames(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) {
@@ skipping 30 matching lines @@
                               int x,
                               int y) {
   return m_surface->writePixels(info, pixels, rowBytes, x, y);
 }
 
 bool ImageBuffer::isSurfaceValid() const {
   return m_surface->isValid();
 }
 
 void ImageBuffer::finalizeFrame() {
+  if (isAccelerated() &&
+      ExpensiveCanvasHeuristicParameters::GPUReadbackForcesNoAcceleration &&
+      !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled()) {
+    if (m_gpuReadbackInvoked) {
+      m_gpuReadbackSuccessiveFrames++;
+      m_gpuReadbackInvoked = false;
+    } else {
+      m_gpuReadbackSuccessiveFrames = 0;
+    }
+
+    if (m_gpuReadbackSuccessiveFrames >=
+        ExpensiveCanvasHeuristicParameters::GPUReadbackMinSuccessiveFrames) {
+      disableAcceleration();
+    }
+  }
+
   m_surface->finalizeFrame();
 }
 
 void ImageBuffer::doPaintInvalidation(const FloatRect& dirtyRect) {
   m_surface->doPaintInvalidation(dirtyRect);
 }
 
 bool ImageBuffer::restoreSurface() const {
   return m_surface->isValid() || m_surface->restore();
 }
@@ skipping 190 matching lines @@
     if (!data)
       return false;
     WTF::ArrayBufferContents result(data, allocSizeInBytes,
                                     WTF::ArrayBufferContents::NotShared);
     result.transfer(contents);
     return true;
   }
 
   DCHECK(canvas());
 
-  if (ExpensiveCanvasHeuristicParameters::GetImageDataForcesNoAcceleration &&
-      !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() ||
       rect.maxY() > m_surface->size().height();
@@ skipping 25 matching lines @@
   sk_sp<SkColorSpace> colorSpace = nullptr;
   if (m_surface->colorSpace()) {
     colorSpace = SkColorSpace::MakeSRGB();
   }
 
   SkImageInfo info = SkImageInfo::Make(rect.width(), rect.height(), colorType,
                                        alphaType, std::move(colorSpace));
 
   snapshot->readPixels(info, result.data(), bytesPerPixel * rect.width(),
                        rect.x(), rect.y());
+  m_gpuReadbackInvoked = true;
 
   if (useF16Workaround) {
     uint32_t* pixel = (uint32_t*)result.data();
     size_t pixelCount = allocSizeInBytes / sizeof(uint32_t);
     // TODO(skbug.com/5853): make readPixels support RGBA output so that we no
     // longer
     // have to do this.
     if (kN32_SkColorType == kBGRA_8888_SkColorType) {
       // Convert BGRA to RGBA if necessary on this platform.
       SkSwapRB(pixel, pixel, pixelCount);
@@ skipping 186 matching lines @@
   DCHECK(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
 
   Vector<unsigned char> result;
   if (!encodeImage(mimeType, quality, &result))
     return "data:,";
 
   return "data:" + mimeType + ";base64," + base64Encode(result);
 }
 
 }  // namespace blink