Stop unnecessary flushing in Canvas2DLayerBridge

third_party/WebKit/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 767 matching lines @@
     TRACE_EVENT0("cc", "Canvas2DLayerBridge::flushRecordingOnly");
     m_recorder->finishRecordingAsPicture()->playback(
         getOrCreateSurface()->getCanvas());
     if (m_isDeferralEnabled)
       startRecording();
     m_haveRecordedDrawCommands = false;
   }
 }
 
 void Canvas2DLayerBridge::flush() {
+  if (!m_didDrawSinceLastFlush)

[xlai (Olivia), 2017/01/16 16:58:19]

I have a second thought about this CL: how about we add a small unit test to it
to verifies it works and prevent future code change from modifying the behavior?
There is an extra code branch introduced here and a unit test seems to be
necessary in this case.

+    return;
+  TRACE_EVENT0("cc", "Canvas2DLayerBridge::flush");
   if (!getOrCreateSurface())
     return;
-  TRACE_EVENT0("cc", "Canvas2DLayerBridge::flush");
   flushRecordingOnly();
   getOrCreateSurface()->getCanvas()->flush();
+  m_didDrawSinceLastFlush = false;
 }
 
 void Canvas2DLayerBridge::flushGpu() {
-  TRACE_EVENT0("cc", "Canvas2DLayerBridge::flushGpu");
   flush();
   gpu::gles2::GLES2Interface* gl = contextGL();
-  if (isAccelerated() && gl)
+  if (isAccelerated() && gl && m_didDrawSinceLastGpuFlush) {
+    TRACE_EVENT0("cc", "Canvas2DLayerBridge::flushGpu");
     gl->Flush();
+    m_didDrawSinceLastGpuFlush = false;
+  }
 }
 
 gpu::gles2::GLES2Interface* Canvas2DLayerBridge::contextGL() {
   // Check on m_layer is necessary because contextGL() may be called during
   // the destruction of m_layer
   if (m_layer && m_accelerationMode != DisableAcceleration &&
       !m_destructionInProgress) {
     // Call checkSurfaceValid to ensure the rate limiter is disabled if the
     // context is lost.
     if (!checkSurfaceValid())
@@ skipping 235 matching lines @@
     if (m_recordingPixelCount >=
         (m_size.width() * m_size.height() *
          ExpensiveCanvasHeuristicParameters::ExpensiveOverdrawThreshold)) {
       disableDeferral(DisableDeferralReasonExpensiveOverdrawHeuristic);
     }
   }
   if (!m_isRegisteredTaskObserver) {
     Platform::current()->currentThread()->addTaskObserver(this);
     m_isRegisteredTaskObserver = true;
   }
+  m_didDrawSinceLastFlush = true;
+  m_didDrawSinceLastGpuFlush = true;
 }
 
 void Canvas2DLayerBridge::prepareSurfaceForPaintingIfNeeded() {
   getOrCreateSurface(PreferAcceleration);
 }
 
 void Canvas2DLayerBridge::finalizeFrame(const FloatRect& dirtyRect) {
   DCHECK(!m_destructionInProgress);
   if (m_layer && m_accelerationMode != DisableAcceleration)
     m_layer->layer()->invalidateRect(enclosingIntRect(dirtyRect));
@@ skipping 76 matching lines @@
     default;
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(
     HibernationEvent event) {
   DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernationHistogram,
                       ("Canvas.HibernationEvents", HibernationEventCount));
   hibernationHistogram.count(event);
 }
 
 }  // namespace blink