Throttle prepaints to avoid colliding with post-load work

cc/layer_tree_host.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "cc/layer_tree_host.h"
 
 #include "Region.h"
 #include "base/debug/trace_event.h"
+#include "base/message_loop.h"
 #include "cc/font_atlas.h"
 #include "cc/graphics_context.h"
 #include "cc/heads_up_display_layer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_tree_host_client.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
@@ skipping 336 matching lines @@
 }
 
 void LayerTreeHost::setNeedsAnimate()
 {
     DCHECK(Proxy::hasImplThread());
     m_proxy->setNeedsAnimate();
 }
 
 void LayerTreeHost::setNeedsCommit()
 {
+    if (!m_prepaintCallback.IsCancelled()) {
+        TRACE_EVENT_INSTANT0("cc", "LayerTreeHost::setNeedsCommit::cancel prepaint");
+        m_prepaintCallback.Cancel();
+    }
     m_proxy->setNeedsCommit();
 }
 
 void LayerTreeHost::setNeedsRedraw()
 {
     m_proxy->setNeedsRedraw();
     if (!ThreadProxy::implThread())
         m_client->scheduleComposite();
 }
 
@@ skipping 151 matching lines @@
         }
 
         TRACE_EVENT0("cc", "LayerTreeHost::updateLayers::calcDrawEtc");
         LayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize(), m_deviceScaleFactor, m_pageScaleFactor, rendererCapabilities().maxTextureSize, updateList);
     }
 
     // Reset partial texture update requests.
     m_partialTextureUpdateRequests = 0;
 
     bool needMoreUpdates = paintLayerContents(updateList, queue);
-    if (m_triggerIdleUpdates && needMoreUpdates)
-        setNeedsCommit();
+    if (m_triggerIdleUpdates && needMoreUpdates) {
+        TRACE_EVENT0("cc", "LayerTreeHost::updateLayers::posting prepaint task");
+        m_prepaintCallback.Reset(base::Bind(&LayerTreeHost::triggerPrepaint, base::Unretained(this)));
+        static base::TimeDelta prepaintDelay = base::TimeDelta::FromMilliseconds(100);
+        MessageLoop::current()->PostDelayedTask(FROM_HERE, m_prepaintCallback.callback(), prepaintDelay);
+    }
 
     for (size_t i = 0; i < updateList.size(); ++i)
         updateList[i]->clearRenderSurface();
 }
 
+void LayerTreeHost::triggerPrepaint()
+{
+    m_prepaintCallback.Cancel();
+    TRACE_EVENT0("cc", "LayerTreeHost::triggerPrepaint");
+    setNeedsCommit();
+}
+
 void LayerTreeHost::setPrioritiesForSurfaces(size_t surfaceMemoryBytes)
 {
     // Surfaces have a place holder for their memory since they are managed
     // independantly but should still be tracked and reduce other memory usage.
     m_surfaceMemoryPlaceholder->setTextureManager(m_contentsTextureManager.get());
     m_surfaceMemoryPlaceholder->setRequestPriority(PriorityCalculator::renderSurfacePriority());
     m_surfaceMemoryPlaceholder->setToSelfManagedMemoryPlaceholder(surfaceMemoryBytes);
 }
 
 void LayerTreeHost::setPrioritiesForLayers(const LayerList& updateList)
@@ skipping 237 matching lines @@
             else
                 layer->notifyAnimationFinished(wallClockTime);
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 } // namespace cc