cc: Remove resource updates from scheduler.

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"
 #include "TextureUploader.h"
 #include "TraceEvent.h"
 #include <limits>
-#include <wtf/CurrentTime.h>
 
 namespace {
 
 // Number of partial updates we allow.
 static const size_t partialTextureUpdatesMax = 12;
 
 // Measured in seconds.
 static const double textureUpdateTickRate = 0.004;
 
 // Measured in seconds.
@@ skipping 17 matching lines @@
     size_t texturesPerTick = floor(textureUpdateTickRate * texturesPerSecond);
     return texturesPerTick ? texturesPerTick : 1;
 }
 
 CCTextureUpdateController::CCTextureUpdateController(CCTextureUpdateControllerClient* client, CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureUploader* uploader)
     : m_client(client)
     , m_timer(adoptPtr(new CCTimer(thread, this)))
     , m_queue(queue)
     , m_resourceProvider(resourceProvider)
     , m_uploader(uploader)
-    , m_monotonicTimeLimit(0)
     , m_textureUpdatesPerTick(maxFullUpdatesPerTick(uploader))
-    , m_firstUpdateAttempt(true)
 {
 }
 
 CCTextureUpdateController::~CCTextureUpdateController()
 {
 }
 
-void CCTextureUpdateController::performMoreUpdates(
-    double monotonicTimeLimit)
+void CCTextureUpdateController::start()
 {
-    ASSERT(monotonicTimeLimit >= m_monotonicTimeLimit);
-    m_monotonicTimeLimit = monotonicTimeLimit;
-
-    // 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) {
-        // Post a 0-delay task when no updates were left. When it runs,
-        // readyToFinalizeTextureUpdates() will be called.
-        if (!updateMoreTexturesIfEnoughTimeRemaining())
-            m_timer->startOneShot(0);
-
-        m_firstUpdateAttempt = false;
-    } else
-        updateMoreTexturesNow();
+    // Post a 0-delay task when no updates were left. When it runs,
+    // updateTexturesCompleted() will be called.
+    if (!updateMoreTextures())
+        m_timer->startOneShot(0);
 }
 
 void CCTextureUpdateController::discardUploadsToEvictedResources()
 {
     m_queue->clearUploadsToEvictedResources();
 }
 
 void CCTextureUpdateController::finalize()
 {
     size_t uploadCount = 0;
@@ skipping 26 matching lines @@
         // 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.
         copier->flush();
     }
 }
 
 void CCTextureUpdateController::onTimerFired()
 {
-    if (!updateMoreTexturesIfEnoughTimeRemaining())
+    if (!updateMoreTextures())
         m_client->readyToFinalizeTextureUpdates();
 }
 
-double CCTextureUpdateController::monotonicTimeNow() const
-{
-    return monotonicallyIncreasingTime();
-}
-
 double CCTextureUpdateController::updateMoreTexturesTime() const
 {
     return textureUpdateTickRate;
 }
 
 size_t CCTextureUpdateController::updateMoreTexturesSize() const
 {
     return m_textureUpdatesPerTick;
 }
 
-bool CCTextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
+// Performs lazy texture updates. Currently only full uploads.
+bool CCTextureUpdateController::updateMoreTextures()
 {
     // Uploader might be busy when we're too aggressive in our upload time
     // estimate. We use a different timeout here to prevent unnecessary
     // amounts of idle time.
     if (m_uploader->isBusy()) {
         m_timer->startOneShot(uploaderBusyTickRate);
         return true;
     }
 
     if (!m_queue->fullUploadSize())
         return false;
 
-    bool hasTimeRemaining = monotonicTimeNow() < m_monotonicTimeLimit - updateMoreTexturesTime();
-    if (hasTimeRemaining)
-        updateMoreTexturesNow();
-
-    return true;
-}
-
-void CCTextureUpdateController::updateMoreTexturesNow()
-{
     size_t uploads = std::min(
         m_queue->fullUploadSize(), updateMoreTexturesSize());
     m_timer->startOneShot(
         updateMoreTexturesTime() / updateMoreTexturesSize() * uploads);
 
-    if (!uploads)
-        return;
+    ASSERT(uploads);
 
     size_t uploadCount = 0;
     m_uploader->beginUploads();
     while (m_queue->fullUploadSize() && uploadCount < uploads) {
         if (!(uploadCount % textureUploadFlushPeriod) && uploadCount)
             m_resourceProvider->shallowFlushIfSupported();
         m_uploader->uploadTexture(m_resourceProvider, m_queue->takeFirstFullUpload());
         uploadCount++;
     }
     m_uploader->endUploads();
     m_resourceProvider->shallowFlushIfSupported();
+    return true;
 }
 
 }