cc: Only use upload throttling when performing full texture uploads.

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 16 matching lines @@
 
 } // anonymous namespace
 
 namespace cc {
 
 size_t CCTextureUpdateController::maxPartialTextureUpdates()
 {
     return textureUpdatesPerTick;
 }
 
-void CCTextureUpdateController::updateTextures(CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader, CCTextureUpdateQueue* queue, size_t count)
+void CCTextureUpdateController::updateTextures(CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader, CCTextureUpdateQueue* queue)
 {
-    if (queue->fullUploadSize() || queue->partialUploadSize()) {
-        if (uploader->isBusy())
-            return;
-
-        uploader->beginUploads();
-
-        size_t fullUploadCount = 0;
-        while (queue->fullUploadSize() && fullUploadCount < count) {
-            uploader->uploadTexture(resourceProvider, queue->takeFirstFullUpload());
-            fullUploadCount++;
-            if (!(fullUploadCount % textureUploadFlushPeriod))
-                resourceProvider->shallowFlushIfSupported();
-        }
-
-        // Make sure there are no dangling uploads without a flush.
-        if (fullUploadCount % textureUploadFlushPeriod)
+    size_t uploadCount = 0;
+    while (queue->fullUploadSize()) {
+        if (!(uploadCount % textureUploadFlushPeriod) && uploadCount)
             resourceProvider->shallowFlushIfSupported();
 
-        bool moreUploads = queue->fullUploadSize();
+        uploader->uploadTexture(
+            resourceProvider, queue->takeFirstFullUpload());
+        uploadCount++;
+    }
 
-        ASSERT(queue->partialUploadSize() <= count);
-        // We need another update batch if the number of updates remaining
-        // in |count| is greater than the remaining partial entries.
-        if ((count - fullUploadCount) < queue->partialUploadSize())
-            moreUploads = true;
-
-        if (moreUploads) {
-            uploader->endUploads();
-            return;
-        }
-
-        size_t partialUploadCount = 0;
-        while (queue->partialUploadSize()) {
-            uploader->uploadTexture(resourceProvider, queue->takeFirstPartialUpload());
-            partialUploadCount++;
-            if (!(partialUploadCount % textureUploadFlushPeriod))
-                resourceProvider->shallowFlushIfSupported();
-        }
-
-        // Make sure there are no dangling partial uploads without a flush.
-        if (partialUploadCount % textureUploadFlushPeriod)
+    while (queue->partialUploadSize()) {
+        if (!(uploadCount % textureUploadFlushPeriod) && uploadCount)
             resourceProvider->shallowFlushIfSupported();
 
-        uploader->endUploads();
+        uploader->uploadTexture(
+            resourceProvider, queue->takeFirstPartialUpload());
+        uploadCount++;
     }
 
-    size_t copyCount = 0;
-    while (queue->copySize()) {
-        copier->copyTexture(queue->takeFirstCopy());
-        copyCount++;
+    if (uploadCount)

[nduca, 2012/09/18 06:03:58]

I'm so confused, how do you even have incremental uploads for the full case?
This patch looks like you disabled everything completely.

[reveman, 2012/09/18 06:26:03]

Incremental uploads are now done in
CCTextureUpdateController::updateMoreTexturesNow(). This is only used by the
single thread proxy and when finalize is called.

+        resourceProvider->shallowFlushIfSupported();
+
+    if (queue->copySize()) {
+        while (queue->copySize())
+            copier->copyTexture(queue->takeFirstCopy());
+
+        // 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();
     }
-
-    // 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(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)
@@ skipping 24 matching lines @@
         if (!updateMoreTexturesIfEnoughTimeRemaining())
             m_timer->startOneShot(0);
 
         m_firstUpdateAttempt = false;
     } else
         updateMoreTexturesNow();
 }
 
 void CCTextureUpdateController::finalize()
 {
-    while (m_queue->hasMoreUpdates())
-        updateTextures(m_resourceProvider, m_copier, m_uploader, m_queue.get(),
-                       updateMoreTexturesSize());
+    updateTextures(m_resourceProvider, m_copier, m_uploader, m_queue.get());
 }
 
 void CCTextureUpdateController::onTimerFired()
 {
     if (!updateMoreTexturesIfEnoughTimeRemaining())
         m_client->readyToFinalizeTextureUpdates();
 }
 
 double CCTextureUpdateController::monotonicTimeNow() const
 {
@@ skipping 52 matching lines @@
     }
 
     // Make sure there are no dangling partial uploads without a flush.
     if (uploadCount % textureUploadFlushPeriod)
         m_resourceProvider->shallowFlushIfSupported();
 
     m_uploader->endUploads();
 }
 
 }