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

cc/CCTextureUpdateController.cpp

 // Copyright 2012 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 "CCTextureUpdateController.h"
 
 #include "GraphicsContext3D.h"
 #include "TextureCopier.h"
@@ skipping 74 matching lines @@
         copyCount++;
     }
 
     // If we've performed any texture copies, we need to insert a flush here into the compositor context
     // before letting the main thread proceed as it may make draw calls to the source texture of one of
     // our copy operations.
     if (copyCount)
         copier->flush();
 }
 
-CCTextureUpdateController::CCTextureUpdateController(CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
-    : m_timer(adoptPtr(new CCTimer(thread, this)))
+CCTextureUpdateController::CCTextureUpdateController(CCTextureUpdateControllerClient* client, CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
+    : m_client(client)
+    , m_timer(adoptPtr(new CCTimer(thread, this)))
     , m_queue(queue)
     , m_resourceProvider(resourceProvider)
     , m_copier(copier)
     , m_uploader(uploader)
     , m_monotonicTimeLimit(0)
     , m_firstUpdateAttempt(true)
 {
 }
 
 CCTextureUpdateController::~CCTextureUpdateController()
 {
 }
 
-bool CCTextureUpdateController::hasMoreUpdates() const
-{
-    return m_queue->hasMoreUpdates();
-}
-
 void CCTextureUpdateController::updateMoreTextures(double monotonicTimeLimit)
 {
+    ASSERT(monotonicTimeLimit >= m_monotonicTimeLimit);
     m_monotonicTimeLimit = monotonicTimeLimit;
 
-    if (!m_queue->hasMoreUpdates())
+    // Update already in progress.
+    if (m_timer->isActive())
         return;
 
     // Call updateMoreTexturesNow() directly unless it's the first update
     // attempt. This ensures that we empty the update queue in a finite
     // amount of time.
     if (m_firstUpdateAttempt) {
-        updateMoreTexturesIfEnoughTimeRemaining();
+        // Post a 0-delay task when no updates were left. When it runs,
+        // updateTexturesCompleted() will be called.
+        if (!updateMoreTexturesIfEnoughTimeRemaining())
+            m_timer->startOneShot(0);
+
         m_firstUpdateAttempt = false;
     } else
         updateMoreTexturesNow();
 }
 
 void CCTextureUpdateController::onTimerFired()
 {
-    if (!m_queue->hasMoreUpdates())
-        return;
-
-    updateMoreTexturesIfEnoughTimeRemaining();
+    if (!updateMoreTexturesIfEnoughTimeRemaining())
+        m_client->updateTexturesCompleted();
 }
 
 double CCTextureUpdateController::monotonicTimeNow() const
 {
     return monotonicallyIncreasingTime();
 }
 
 double CCTextureUpdateController::updateMoreTexturesTime() const
 {
     return textureUpdateTickRate;
 }
 
 size_t CCTextureUpdateController::updateMoreTexturesSize() const
 {
     return textureUpdatesPerTick;
 }
 
-void CCTextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
+bool CCTextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
 {
+    if (!m_queue->hasMoreUpdates())
+        return false;
+
     bool hasTimeRemaining = monotonicTimeNow() < m_monotonicTimeLimit - updateMoreTexturesTime();
     if (hasTimeRemaining)
         updateMoreTexturesNow();
+
+    return true;
 }
 
 void CCTextureUpdateController::updateMoreTexturesNow()
 {
     m_timer->startOneShot(updateMoreTexturesTime());
     updateTextures(m_resourceProvider, m_copier, m_uploader, m_queue.get(), updateMoreTexturesSize());
 }
 
 }