cc: Remove partial texture 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 <wtf/CurrentTime.h>
 
 namespace {
 
 // Number of textures to update with each call to updateMoreTexturesIfEnoughTimeRemaining().
 static const size_t textureUpdatesPerTick = 12;
 
 // Measured in seconds.
 static const double textureUpdateTickRate = 0.004;
 
+// Measured in seconds.
+static const double uploaderBusyTickRate = 0.001;
+
 // Flush interval when performing texture uploads.
 static const int textureUploadFlushPeriod = 4;
 
 } // anonymous namespace
 
 namespace cc {
 
 size_t CCTextureUpdateController::maxPartialTextureUpdates()
 {
     return textureUpdatesPerTick;
@@ skipping 92 matching lines @@
         // 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::updateAllTexturesNow()
+{
+    while (m_queue->hasMoreUpdates())
+        updateTextures(m_resourceProvider, m_copier, m_uploader, m_queue.get(),
+                       updateMoreTexturesSize());
+}
+
 void CCTextureUpdateController::onTimerFired()
 {
     if (!updateMoreTexturesIfEnoughTimeRemaining())
         m_client->updateTexturesCompleted();
 }
 
 double CCTextureUpdateController::monotonicTimeNow() const
 {
     return monotonicallyIncreasingTime();
 }
 
 double CCTextureUpdateController::updateMoreTexturesTime() const
 {
     return textureUpdateTickRate;
 }
 
 size_t CCTextureUpdateController::updateMoreTexturesSize() const
 {
     return textureUpdatesPerTick;
 }
 
 bool CCTextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
 {
-    if (!m_queue->hasMoreUpdates())
+    // Uploader might be busy when we're too aggressive in our upload time
+    // estimate. We use a different timeout here to prevent unnecessary
+    // amounts 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()

[nduca, 2012/09/17 18:26:15]

I think you could make this whole patch a lot cleaner. This does what its
supposed to do, but the abstraction of control is smeared between the controller
and the proxy.

Can you make the only public interfaces on this be hasMoreFullUpdates,
doMoreFullUpdates, doAllPartialUpdates()?

 {
-    m_timer->startOneShot(updateMoreTexturesTime());
-    updateTextures(m_resourceProvider, m_copier, m_uploader, m_queue.get(), updateMoreTexturesSize());
+    size_t uploads = std::min(
+        m_queue->fullUploadSize(), updateMoreTexturesSize());
+    m_timer->startOneShot(
+        updateMoreTexturesTime() / updateMoreTexturesSize() * uploads);
+
+    if (!uploads)
+        return;
+
+    m_uploader->beginUploads();
+
+    size_t uploadCount = 0;
+    while (uploads--) {
+        m_uploader->uploadTexture(
+            m_resourceProvider, m_queue->takeFirstFullUpload());
+        uploadCount++;
+        if (!(uploadCount % textureUploadFlushPeriod))
+            m_resourceProvider->shallowFlushIfSupported();
+    }
+
+    // Make sure there are no dangling partial uploads without a flush.
+    if (uploadCount % textureUploadFlushPeriod)
+        m_resourceProvider->shallowFlushIfSupported();
+
+    m_uploader->endUploads();
 }
 
 }