cc: Scheduler will never process a commit until it receives a vsync tick.

cc/CCThreadProxy.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 "CCThreadProxy.h"
 
 #include "CCDelayBasedTimeSource.h"
 #include "CCDrawQuad.h"
 #include "CCFrameRateController.h"
 #include "CCGraphicsContext.h"
 #include "CCInputHandler.h"
 #include "CCLayerTreeHost.h"
 #include "CCScheduler.h"
 #include "CCScopedThreadProxy.h"
-#include "CCTextureUpdateController.h"
 #include "CCThreadTask.h"
 #include "TraceEvent.h"
 #include <public/WebSharedGraphicsContext3D.h>
 #include <wtf/CurrentTime.h>
 
 using namespace WTF;
 
 using WebKit::WebSharedGraphicsContext3D;
 namespace {
 
@@ skipping 559 matching lines @@
         m_resetContentsTexturesPurgedAfterCommitOnImplThread = true;
     } else if (m_layerTreeHostImpl->contentsTexturesPurged()) {
         // We purged the content textures on the impl thread between the time we
         // posted the beginFrame task and now, meaning we have a bunch of
         // uploads that are now invalid. Clear the uploads (they all go to
         // content textures), and kick another commit to fill them again.
         queue->clearUploads();
         setNeedsCommitOnImplThread();
     }
 
-    m_currentTextureUpdateControllerOnImplThread = CCTextureUpdateController::create(CCProxy::implThread(), queue, m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader());
+    bool hasResourceUpdates = queue->hasMoreUpdates();
+    if (hasResourceUpdates)
+        m_currentTextureUpdateControllerOnImplThread = CCTextureUpdateController::create(this, CCProxy::implThread(), queue, m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader());
     m_commitCompletionEventOnImplThread = completion;
 
-    m_schedulerOnImplThread->beginFrameComplete();
+    m_schedulerOnImplThread->beginFrameComplete(hasResourceUpdates);
 }
 
 void CCThreadProxy::beginFrameAbortedOnImplThread()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::beginFrameAbortedOnImplThread");
     ASSERT(isImplThread());
     ASSERT(m_schedulerOnImplThread);
     ASSERT(m_schedulerOnImplThread->commitPending());
 
     m_schedulerOnImplThread->beginFrameAborted();
 }
 
-bool CCThreadProxy::hasMoreResourceUpdates() const
-{
-    if (!m_currentTextureUpdateControllerOnImplThread)
-        return false;
-    return m_currentTextureUpdateControllerOnImplThread->hasMoreUpdates();
-}
-
 void CCThreadProxy::scheduledActionUpdateMoreResources(double monotonicTimeLimit)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::scheduledActionUpdateMoreResources");
     ASSERT(m_currentTextureUpdateControllerOnImplThread);
     m_currentTextureUpdateControllerOnImplThread->updateMoreTextures(monotonicTimeLimit);
 }
 
 void CCThreadProxy::scheduledActionCommit()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::scheduledActionCommit");
     ASSERT(isImplThread());
-    ASSERT(!hasMoreResourceUpdates());
     ASSERT(m_commitCompletionEventOnImplThread);
 
     m_currentTextureUpdateControllerOnImplThread.clear();
 
     m_layerTreeHostImpl->beginCommit();
 
     m_layerTreeHost->beginCommitOnImplThread(m_layerTreeHostImpl.get());
     m_layerTreeHost->finishCommitOnImplThread(m_layerTreeHostImpl.get());
 
     if (m_resetContentsTexturesPurgedAfterCommitOnImplThread) {
@@ skipping 119 matching lines @@
 CCScheduledActionDrawAndSwapResult CCThreadProxy::scheduledActionDrawAndSwapIfPossible()
 {
     return scheduledActionDrawAndSwapInternal(false);
 }
 
 CCScheduledActionDrawAndSwapResult CCThreadProxy::scheduledActionDrawAndSwapForced()
 {
     return scheduledActionDrawAndSwapInternal(true);
 }
 
+void CCThreadProxy::updateTexturesCompleted()
+{
+    ASSERT(isImplThread());
+    m_schedulerOnImplThread->updateResourcesComplete();
+}
+
 void CCThreadProxy::didCommitAndDrawFrame()
 {
     ASSERT(isMainThread());
     if (!m_layerTreeHost)
         return;
     m_layerTreeHost->didCommitAndDrawFrame();
 }
 
 void CCThreadProxy::didCompleteSwapBuffers()
 {
@@ skipping 133 matching lines @@
 }
 
 void CCThreadProxy::implSideRenderingStatsOnImplThread(CCCompletionEvent* completion, CCRenderingStats* stats)
 {
     ASSERT(isImplThread());
     m_layerTreeHostImpl->renderingStats(*stats);
     completion->signal();
 }
 
 } // namespace WebCore