Adaptively throttle texture uploads

cc/CCSingleThreadProxy.cpp

 // 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 "CCSingleThreadProxy.h"
 
 #include "CCDrawQuad.h"
 #include "CCGraphicsContext.h"
 #include "CCLayerTreeHost.h"
 #include "CCTextureUpdateController.h"
 #include "CCTimer.h"
 #include "TraceEvent.h"
 #include <wtf/CurrentTime.h>
 
 using namespace WTF;
 
+namespace {
+
+// We don't need to split texture uploads into multiple batches if we are single threaded.
+const size_t maxTextureUpdates = std::numeric_limits<size_t>::max();
+
+}
+
 namespace WebCore {
 
 PassOwnPtr<CCProxy> CCSingleThreadProxy::create(CCLayerTreeHost* layerTreeHost)
 {
     return adoptPtr(new CCSingleThreadProxy(layerTreeHost));
 }
 
 CCSingleThreadProxy::CCSingleThreadProxy(CCLayerTreeHost* layerTreeHost)
     : m_layerTreeHost(layerTreeHost)
     , m_contextLost(false)
@@ skipping 157 matching lines @@
         m_layerTreeHostImpl->beginCommit();
 
         m_layerTreeHost->beginCommitOnImplThread(m_layerTreeHostImpl.get());
 
         // CCTextureUpdateController::updateTextures is non-blocking and will
         // return without updating any textures if the uploader is busy. This
         // shouldn't be a problem here as the throttled uploader isn't used in
         // single thread mode. For correctness, loop until no more updates are
         // pending.
         while (queue.hasMoreUpdates())
-            CCTextureUpdateController::updateTextures(m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader(), &queue, maxPartialTextureUpdates());
+            CCTextureUpdateController::updateTextures(m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader(), &queue, maxTextureUpdates);
 
         m_layerTreeHost->finishCommitOnImplThread(m_layerTreeHostImpl.get());
 
         m_layerTreeHostImpl->commitComplete();
 
 #if !ASSERT_DISABLED
         // In the single-threaded case, the scroll deltas should never be
         // touched on the impl layer tree.
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
         ASSERT(!scrollInfo->scrolls.size());
@@ skipping 73 matching lines @@
     if (!m_layerTreeHost->initializeRendererIfNeeded())
         return false;
 
     if (m_layerTreeHostImpl->contentsTexturesPurged()) {
         m_layerTreeHost->unlinkAllContentTextures();
         DebugScopedSetImplThreadAndMainThreadBlocked implAndMainBlocked;
         m_layerTreeHost->deleteUnlinkedTextures();
     }
 
     CCTextureUpdateQueue queue;
-    m_layerTreeHost->updateLayers(queue, m_layerTreeHostImpl->memoryAllocationLimitBytes());
+    m_layerTreeHost->updateLayers(queue, m_layerTreeHostImpl->memoryAllocationLimitBytes(), maxTextureUpdates);
     m_layerTreeHostImpl->resetContentsTexturesPurged();
 
     m_layerTreeHost->willCommit();
     doCommit(queue);
     bool result = doComposite();
     m_layerTreeHost->didBeginFrame();
     return result;
 }
 
 bool CCSingleThreadProxy::doComposite()
@@ skipping 32 matching lines @@
 
 void CCSingleThreadProxy::didSwapFrame()
 {
     if (m_nextFrameIsNewlyCommittedFrame) {
         m_nextFrameIsNewlyCommittedFrame = false;
         m_layerTreeHost->didCommitAndDrawFrame();
     }
 }
 
 }