Adaptively throttle texture uploads

cc/CCTextureUpdateControllerTest.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 "CCSchedulerTestCommon.h"
 #include "CCSingleThreadProxy.h" // For DebugScopedSetImplThread
@@ skipping 97 matching lines @@
         }
 
         m_numDanglingUploads = 0;
         m_numConsecutiveFlushes++;
         m_numTotalFlushes++;
         m_numPreviousFlushes++;
     }
 
     void onBeginUploads()
     {
+        EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
+
         m_numPreviousFlushes = 0;
         m_numPreviousUploads = 0;
         m_numBeginUploads++;
     }
 
     void onUpload()
     {
         // Check for too many consecutive uploads
         if (m_numTotalUploads < m_fullUploadCountExpected)
             EXPECT_LT(m_numDanglingUploads, kFlushPeriodFull) << "Too many consecutive full uploads detected.";
         else
             EXPECT_LT(m_numDanglingUploads, kFlushPeriodPartial) << "Too many consecutive partial uploads detected.";
 
         m_numConsecutiveFlushes = 0;
         m_numDanglingUploads++;
         m_numTotalUploads++;
         m_numPreviousUploads++;
     }
 
     void onEndUploads()
     {
-        EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
-

[brianderson, 2012/09/18 00:45:52]

onEndUploads is called before the final flush to keep it grouped with the
texture uploads, so this check can no longer be done here.  I move it to
onBeginUploads and at the end of each test.

         // Note: The m_numTotalUploads != m_fullUploadCountExpected comparison
         // allows for the quota not to be hit in the case where we are trasitioning
         // from full uploads to partial uploads.
         if (m_numTotalUploads != m_totalUploadCountExpected && m_numTotalUploads != m_fullUploadCountExpected) {
             EXPECT_EQ(m_maxUploadCountPerUpdate, m_numPreviousUploads)
                 << "endUpload() was called when there are textures to upload, but the upload quota hasn't been filled.";
         }
 
         m_numEndUploads++;
     }
@@ skipping 107 matching lines @@
 {
     appendFullUploadsToUpdateQueue(1);
     appendPartialUploadsToUpdateQueue(0);
     DebugScopedSetImplThread implThread;
     CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(1, m_numPreviousFlushes);
     EXPECT_EQ(1, m_numPreviousUploads);
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
 TEST_F(CCTextureUpdateControllerTest, OnePartialUpload)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(1);
     DebugScopedSetImplThread implThread;
     CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(1, m_numPreviousFlushes);
     EXPECT_EQ(1, m_numPreviousUploads);
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
 TEST_F(CCTextureUpdateControllerTest, OneFullOnePartialUpload)
 {
     appendFullUploadsToUpdateQueue(1);
     appendPartialUploadsToUpdateQueue(1);
     DebugScopedSetImplThread implThread;
     CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     // We expect the full uploads to be followed by a flush
     // before the partial uploads begin.
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(2, m_numPreviousFlushes);
     EXPECT_EQ(2, m_numPreviousUploads);
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
 
 // NO REMAINDER TESTS
 // This class of tests upload a number of textures that is a multiple of the flush period.
 const int fullUploadFlushMultipler = 7;
 const int fullNoRemainderCount = fullUploadFlushMultipler * kFlushPeriodFull;
 
 const int partialUploadFlushMultipler = 11;
 const int partialNoRemainderCount = partialUploadFlushMultipler * kFlushPeriodPartial;
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullUploadsNoRemainder)
 {
     appendFullUploadsToUpdateQueue(fullNoRemainderCount);
     appendPartialUploadsToUpdateQueue(0);
     DebugScopedSetImplThread implThread;
     CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(fullUploadFlushMultipler, m_numPreviousFlushes);
     EXPECT_EQ(fullNoRemainderCount, m_numPreviousUploads);
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
 TEST_F(CCTextureUpdateControllerTest, ManyPartialUploadsNoRemainder)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(partialNoRemainderCount);
     DebugScopedSetImplThread implThread;
     CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(partialUploadFlushMultipler, m_numPreviousFlushes);
     EXPECT_EQ(partialNoRemainderCount, m_numPreviousUploads);
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullManyPartialUploadsNoRemainder)
 {
     appendFullUploadsToUpdateQueue(fullNoRemainderCount);
     appendPartialUploadsToUpdateQueue(partialNoRemainderCount);
     DebugScopedSetImplThread implThread;
     CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(fullUploadFlushMultipler + partialUploadFlushMultipler, m_numPreviousFlushes);
     EXPECT_EQ(fullNoRemainderCount + partialNoRemainderCount, m_numPreviousUploads);
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
 
 // MIN/MAX REMAINDER TESTS
 // This class of tests mix and match uploading 1 more and 1 less texture
 // than a multiple of the flush period.
 
 const int fullMinRemainderCount = fullNoRemainderCount + 1;
 const int fullMaxRemainderCount = fullNoRemainderCount - 1;
 const int partialMinRemainderCount = partialNoRemainderCount + 1;
 const int partialMaxRemainderCount = partialNoRemainderCount - 1;
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullAndPartialMinRemainder)
 {
     appendFullUploadsToUpdateQueue(fullMinRemainderCount);
     appendPartialUploadsToUpdateQueue(partialMinRemainderCount);
     DebugScopedSetImplThread implThread;
     CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(fullUploadFlushMultipler + partialUploadFlushMultipler + 2, m_numPreviousFlushes);
     EXPECT_EQ(fullMinRemainderCount + partialMinRemainderCount, m_numPreviousUploads);
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullAndPartialUploadsMaxRemainder)
 {
     appendFullUploadsToUpdateQueue(fullMaxRemainderCount);
     appendPartialUploadsToUpdateQueue(partialMaxRemainderCount);
     DebugScopedSetImplThread implThread;
     CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(fullUploadFlushMultipler + partialUploadFlushMultipler, m_numPreviousFlushes);
     EXPECT_EQ(fullMaxRemainderCount + partialMaxRemainderCount, m_numPreviousUploads);
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullMinRemainderManyPartialMaxRemainder)
 {
     appendFullUploadsToUpdateQueue(fullMinRemainderCount);
     appendPartialUploadsToUpdateQueue(partialMaxRemainderCount);
     DebugScopedSetImplThread implThread;
     CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ((fullUploadFlushMultipler+1) + partialUploadFlushMultipler, m_numPreviousFlushes);
     EXPECT_EQ(fullMinRemainderCount + partialMaxRemainderCount, m_numPreviousUploads);
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullMaxRemainderManyPartialMinRemainder)
 {
     appendFullUploadsToUpdateQueue(fullMaxRemainderCount);
     appendPartialUploadsToUpdateQueue(partialMinRemainderCount);
     DebugScopedSetImplThread implThread;
     CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(fullUploadFlushMultipler + (partialUploadFlushMultipler+1), m_numPreviousFlushes);
     EXPECT_EQ(fullMaxRemainderCount + partialMinRemainderCount, m_numPreviousUploads);
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
 
 // MULTIPLE UPDATE TESTS
 // These tests attempt to upload too many textures at once, requiring
 // multiple calls to update().
 
 int expectedFlushes(int uploads, int flushPeriod)
 {
     return (uploads + flushPeriod - 1) / flushPeriod;
@@ skipping 44 matching lines @@
     EXPECT_EQ(3, m_numEndUploads);
 
     expectedPreviousFlushes = expectedFlushes(kFullUploads-kMaxUploadsPerUpdate*2, kFlushPeriodFull) +
                               expectedFlushes(kPartialUploads, kFlushPeriodPartial);
     EXPECT_EQ(expectedPreviousFlushes, m_numPreviousFlushes);
 
     expectedPreviousUploads = (kFullUploads-kMaxUploadsPerUpdate*2)+kPartialUploads;
     EXPECT_EQ(expectedPreviousUploads, m_numPreviousUploads);
 
     // Final sanity checks
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
     EXPECT_EQ(kFullUploads + kPartialUploads, m_numTotalUploads);
 }
 
 TEST_F(CCTextureUpdateControllerTest, TripleUpdateFinalUpdateAllPartial)
 {
     const int kMaxUploadsPerUpdate = 40;
     const int kFullUploads = 70;
     const int kPartialUploads = 30;
 
     int expectedPreviousFlushes = 0;
@@ skipping 28 matching lines @@
 
     // Third update (30 partial OR 20 partial if 10 partial uploaded in second update)
     CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
 
     EXPECT_EQ(3, m_numBeginUploads);
     EXPECT_EQ(3, m_numEndUploads);
     EXPECT_LE(m_numPreviousUploads, kMaxUploadsPerUpdate);
     // Be lenient on the exact number of flushes here as well.
 
     // Final sanity checks
+    EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
     EXPECT_EQ(kFullUploads + kPartialUploads, m_numTotalUploads);
 }
 
 class FakeCCTextureUpdateControllerClient : public cc::CCTextureUpdateControllerClient {
 public:
     FakeCCTextureUpdateControllerClient() { reset(); }
     void reset() { m_readyToFinalizeCalled = false; }
     bool readyToFinalizeCalled() const { return m_readyToFinalizeCalled; }
 
     virtual void readyToFinalizeTextureUpdates() OVERRIDE { m_readyToFinalizeCalled = true; }
 
 protected:
     bool m_readyToFinalizeCalled;
 };
 
 class FakeCCTextureUpdateController : public cc::CCTextureUpdateController {
 public:
-    static PassOwnPtr<FakeCCTextureUpdateController> create(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
+    static PassOwnPtr<FakeCCTextureUpdateController> create(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader, size_t maxPartialTextureUpdates)
     {
-        return adoptPtr(new FakeCCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader));
+        return adoptPtr(new FakeCCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader, maxPartialTextureUpdates));
     }
 
     void setMonotonicTimeNow(double time) { m_monotonicTimeNow = time; }
     virtual double monotonicTimeNow() const OVERRIDE { return m_monotonicTimeNow; }
     void setUpdateMoreTexturesTime(double time) { m_updateMoreTexturesTime = time; }
     virtual double updateMoreTexturesTime() const OVERRIDE { return m_updateMoreTexturesTime; }
     void setUpdateMoreTexturesSize(size_t size) { m_updateMoreTexturesSize = size; }
     virtual size_t updateMoreTexturesSize() const OVERRIDE { return m_updateMoreTexturesSize; }
 
 protected:
-    FakeCCTextureUpdateController(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
-        : cc::CCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader)
+    FakeCCTextureUpdateController(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader, size_t maxPartialTextureUpdates)
+        : cc::CCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader, maxPartialTextureUpdates)
         , m_monotonicTimeNow(0)
         , m_updateMoreTexturesTime(0)
         , m_updateMoreTexturesSize(0) { }
 
     double m_monotonicTimeNow;
     double m_updateMoreTexturesTime;
     size_t m_updateMoreTexturesSize;
 };
 
 static void runPendingTask(FakeCCThread* thread, FakeCCTextureUpdateController* controller)
 {
     EXPECT_TRUE(thread->hasPendingTask());
     controller->setMonotonicTimeNow(controller->monotonicTimeNow() + thread->pendingDelayMs() / 1000.0);
     thread->runPendingTask();
 }
 
 TEST_F(CCTextureUpdateControllerTest, UpdateMoreTextures)
 {
     FakeCCTextureUpdateControllerClient client;
     FakeCCThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(3);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_copier, &m_uploader));
+    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_copier, &m_uploader, 0));
 
     controller->setMonotonicTimeNow(0);
     controller->setUpdateMoreTexturesTime(0.1);
     controller->setUpdateMoreTexturesSize(1);
     // Not enough time for any updates.
     controller->performMoreUpdates(0.09);
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_EQ(0, m_numBeginUploads);
     EXPECT_EQ(0, m_numEndUploads);
 
@@ skipping 25 matching lines @@
 TEST_F(CCTextureUpdateControllerTest, NoMoreUpdates)
 {
     FakeCCTextureUpdateControllerClient client;
     FakeCCThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(2);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_copier, &m_uploader));
+    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_copier, &m_uploader, 0));
 
     controller->setMonotonicTimeNow(0);
     controller->setUpdateMoreTexturesTime(0.1);
     controller->setUpdateMoreTexturesSize(1);
     // Enough time for 3 updates but only 2 necessary.
     controller->performMoreUpdates(0.31);
     runPendingTask(&thread, controller.get());
     runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
@@ skipping 18 matching lines @@
 TEST_F(CCTextureUpdateControllerTest, UpdatesCompleteInFiniteTime)
 {
     FakeCCTextureUpdateControllerClient client;
     FakeCCThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(2);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_copier, &m_uploader));
+    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_copier, &m_uploader, 0));
 
     controller->setMonotonicTimeNow(0);
     controller->setUpdateMoreTexturesTime(0.5);
     controller->setUpdateMoreTexturesSize(1);
 
     for (int i = 0; i < 100; i++) {
         if (client.readyToFinalizeCalled())
             break;
 
         // Not enough time for any updates.
         controller->performMoreUpdates(0.4);
 
         if (thread.hasPendingTask())
             runPendingTask(&thread, controller.get());
     }
 
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numBeginUploads);
     EXPECT_EQ(2, m_numEndUploads);
     EXPECT_EQ(2, m_numTotalUploads);
 }
 
 } // namespace