2D Canvas: disable rendering deferral in cases with a lot of overdraw

Source/platform/graphics/Canvas2DLayerBridge.cpp

 /*
  * Copyright (C) 2012 Google Inc. 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.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 14 matching lines @@
 
 #include "config.h"
 
 #include "platform/graphics/Canvas2DLayerBridge.h"
 
 #include "GrContext.h"
 #include "SkDevice.h"
 #include "SkSurface.h"
 
 #include "platform/TraceEvent.h"
+#include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebGraphicsContext3D.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "wtf/RefCountedLeakCounter.h"
@@ skipping 87 matching lines @@
 }
 
 void Canvas2DLayerBridge::startRecording()
 {
     ASSERT(m_isDeferralEnabled);
     m_recorder = adoptPtr(new SkPictureRecorder);
     m_recorder->beginRecording(m_size.width(), m_size.height(), nullptr);
     if (m_imageBuffer) {
         m_imageBuffer->resetCanvas(m_recorder->getRecordingCanvas());
     }
+    m_recordingPixelCount = 0;
 }
 
 SkCanvas* Canvas2DLayerBridge::canvas()
 {
     if (!m_isDeferralEnabled)
         return m_surface->getCanvas();
     return m_recorder->getRecordingCanvas();
 }
 
 void Canvas2DLayerBridge::disableDeferral()
@@ skipping 330 matching lines @@
     m_mailboxes.remove(releasedMailboxInfo);
 }
 
 WebLayer* Canvas2DLayerBridge::layer() const
 {
     ASSERT(!m_destructionInProgress);
     ASSERT(m_layer);
     return m_layer->layer();
 }
 
-void Canvas2DLayerBridge::didDraw()
+void Canvas2DLayerBridge::didDraw(const FloatRect& rect)
 {
-    if (m_isDeferralEnabled)
+    if (m_isDeferralEnabled) {
         m_haveRecordedDrawCommands = true;
+        IntRect pixelBounds = enclosingIntRect(rect);
+        m_recordingPixelCount += pixelBounds.width() * pixelBounds.height();
+        if (m_recordingPixelCount >= (m_size.width() * m_size.height() * ExpensiveCanvasHeuristicParameters::ExpensiveOverdrawThreshold))
+            disableDeferral();
+    }
 }
 
 void Canvas2DLayerBridge::finalizeFrame(const FloatRect &dirtyRect)
 {
     ASSERT(!m_destructionInProgress);
     m_layer->layer()->invalidateRect(enclosingIntRect(dirtyRect));
     m_framesPending++;
     if (m_framesPending > 1) {
         // Turn on the rate limiter if this layer tends to accumulate a
         // non-discardable multi-frame backlog of draw commands.
@@ skipping 22 matching lines @@
     skipQueuedDrawCommands();
 }
 
 Canvas2DLayerBridge::MailboxInfo::MailboxInfo(const MailboxInfo& other) {
     memcpy(&m_mailbox, &other.m_mailbox, sizeof(m_mailbox));
     m_image = other.m_image;
     m_parentLayerBridge = other.m_parentLayerBridge;
 }
 
 } // namespace blink