Eliminate deferral overhead with canvas to canvas draws

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 80 matching lines @@
     , m_contextProvider(contextProvider)
     , m_imageBuffer(0)
     , m_msaaSampleCount(msaaSampleCount)
     , m_bytesAllocated(0)
     , m_haveRecordedDrawCommands(false)
     , m_framesPending(0)
     , m_destructionInProgress(false)
     , m_rateLimitingEnabled(false)
     , m_filterQuality(kLow_SkFilterQuality)
     , m_isHidden(false)
+    , m_isDeferralEnabled(true)
     , m_lastImageId(0)
     , m_lastFilter(GL_LINEAR)
     , m_opacityMode(opacityMode)
     , m_size(m_surface->width(), m_surface->height())
 {
     ASSERT(m_surface);
     ASSERT(m_contextProvider);
     m_initialSurfaceSaveCount = m_surface->getCanvas()->getSaveCount();
     // Used by browser tests to detect the use of a Canvas2DLayerBridge.
     TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation", TRACE_EVENT_SCOPE_GLOBAL);
@@ skipping 14 matching lines @@
     ASSERT(m_destructionInProgress);
     m_layer.clear();
     ASSERT(m_mailboxes.size() == 0);
 #ifndef NDEBUG
     canvas2DLayerBridgeInstanceCounter.decrement();
 #endif
 }
 
 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());
     }
 }
 
 SkCanvas* Canvas2DLayerBridge::canvas()
 {
+    if (!m_isDeferralEnabled)
+        return m_surface->getCanvas();
     return m_recorder->getRecordingCanvas();
 }
 
-SkCanvas* Canvas2DLayerBridge::immediateCanvas()
+void Canvas2DLayerBridge::disableDeferral()
 {
-    if (!m_surface)
-        return nullptr;
+    // Disabling deferral is permanent: once triggered by disableDeferral()
+    // we stay in immediate mode indefinitely. This is a performance heuristic
+    // that significantly helps a number of use cases. The rationale is that if
+    // immediate rendering was needed once, it is likely to be needed at least
+    // once per frame, which eliminates the possibility for inter-frame
+    // overdraw optimization. Furthermore, in cases where immediate mode is
+    // required multiple times per frame, the repeated flushing of deferred
+    // commands would cause significant overhead, so it is better to just stop
+    // trying to defer altogether.
+    if (!m_isDeferralEnabled)
+        return;
+
+    m_isDeferralEnabled = false;
     flushRecordingOnly();
-
+    m_recorder.clear();
     // install the current matrix/clip stack onto the immediate canvas
-    m_surface->getCanvas()->restoreToCount(m_initialSurfaceSaveCount);
     m_imageBuffer->resetCanvas(m_surface->getCanvas());
-
-    return m_surface->getCanvas();
 }
 
 void Canvas2DLayerBridge::setImageBuffer(ImageBuffer* imageBuffer)
 {
     m_imageBuffer = imageBuffer;
-    if (m_imageBuffer) {
+    if (m_imageBuffer && m_isDeferralEnabled) {
         m_imageBuffer->resetCanvas(m_recorder->getRecordingCanvas());
     }
 }
 
 void Canvas2DLayerBridge::beginDestruction()
 {
     ASSERT(!m_destructionInProgress);
     setRateLimitingEnabled(false);
     m_recorder.clear();
     m_imageBuffer = nullptr;
@@ skipping 65 matching lines @@
         m_layer->setRateLimitContext(m_rateLimitingEnabled);
     }
 }
 
 void Canvas2DLayerBridge::flushRecordingOnly()
 {
     ASSERT(!m_destructionInProgress);
     if (m_haveRecordedDrawCommands && m_surface) {
         TRACE_EVENT0("cc", "Canvas2DLayerBridge::flush");
         RefPtr<SkPicture> picture = adoptRef(m_recorder->endRecording());
-        m_surface->getCanvas()->restoreToCount(m_initialSurfaceSaveCount); // In case immediateCanvas() was used
         picture->playback(m_surface->getCanvas());
-        startRecording();
+        if (m_isDeferralEnabled)
+            startRecording();
         m_haveRecordedDrawCommands = false;
     }
 }
 
 void Canvas2DLayerBridge::flush()
 {
     if (!m_surface)
         return;
     flushRecordingOnly();
     m_surface->getCanvas()->flush();
@@ skipping 210 matching lines @@
 
 WebLayer* Canvas2DLayerBridge::layer() const
 {
     ASSERT(!m_destructionInProgress);
     ASSERT(m_layer);
     return m_layer->layer();
 }
 
 void Canvas2DLayerBridge::didDraw()
 {
-    m_haveRecordedDrawCommands = true;
+    if (m_isDeferralEnabled)
+        m_haveRecordedDrawCommands = true;
 }
 
 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.
         setRateLimitingEnabled(true);
     }
     if (m_rateLimitingEnabled) {
         flush();
     }
 }
@@ skipping 16 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