cc: Remove partial texture updates from scheduler.

The texture update controller now completes when all full size texture
uploads are done and the texture uploader isn't busy. All partial
texture updates are now done at the same time as commit.

BUG=149194
TEST=cc_unittests

Review URL: https://codereview.chromium.org/10917265

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@157220 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 75 insertions, 30 deletions

diff --git a/cc/CCTextureUpdateController.cpp b/cc/CCTextureUpdateController.cpp
index 73e22c7..22207de 100644
--- a/cc/CCTextureUpdateController.cpp
+++ b/cc/CCTextureUpdateController.cpp
@@ -19,6 +19,9 @@ 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;
 
@@ -108,7 +111,8 @@ CCTextureUpdateController::~CCTextureUpdateController()
 {
 }
 
-void CCTextureUpdateController::updateMoreTextures(double monotonicTimeLimit)
+void CCTextureUpdateController::performMoreUpdates(
+    double monotonicTimeLimit)
 {
     ASSERT(monotonicTimeLimit >= m_monotonicTimeLimit);
     m_monotonicTimeLimit = monotonicTimeLimit;
@@ -122,7 +126,7 @@ void CCTextureUpdateController::updateMoreTextures(double monotonicTimeLimit)
     // amount of time.
     if (m_firstUpdateAttempt) {
         // Post a 0-delay task when no updates were left. When it runs,
-        // updateTexturesCompleted() will be called.
+        // readyToFinalizeTextureUpdates() will be called.
         if (!updateMoreTexturesIfEnoughTimeRemaining())
             m_timer->startOneShot(0);
 
@@ -131,10 +135,17 @@ void CCTextureUpdateController::updateMoreTextures(double monotonicTimeLimit)
         updateMoreTexturesNow();
 }
 
+void CCTextureUpdateController::finalize()
+{
+    while (m_queue->hasMoreUpdates())
+        updateTextures(m_resourceProvider, m_copier, m_uploader, m_queue.get(),
+                       updateMoreTexturesSize());
+}
+
 void CCTextureUpdateController::onTimerFired()
 {
     if (!updateMoreTexturesIfEnoughTimeRemaining())
-        m_client->updateTexturesCompleted();
+        m_client->readyToFinalizeTextureUpdates();
 }
 
 double CCTextureUpdateController::monotonicTimeNow() const
@@ -154,7 +165,15 @@ size_t CCTextureUpdateController::updateMoreTexturesSize() const
 
 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 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();
@@ -166,8 +185,30 @@ bool CCTextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
 
 void CCTextureUpdateController::updateMoreTexturesNow()
 {
-    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();
 }
 
 }
diff --git a/cc/CCTextureUpdateController.h b/cc/CCTextureUpdateController.h
index 76f81a0..61e0f6c 100644
--- a/cc/CCTextureUpdateController.h
+++ b/cc/CCTextureUpdateController.h
@@ -17,7 +17,7 @@ class TextureUploader;
 
 class CCTextureUpdateControllerClient {
 public:
-    virtual void updateTexturesCompleted() = 0;
+    virtual void readyToFinalizeTextureUpdates() = 0;
 
 protected:
     virtual ~CCTextureUpdateControllerClient() { }
@@ -35,7 +35,8 @@ public:
 
     virtual ~CCTextureUpdateController();
 
-    void updateMoreTextures(double monotonicTimeLimit);
+    void performMoreUpdates(double monotonicTimeLimit);
+    void finalize();
 
     // CCTimerClient implementation.
     virtual void onTimerFired() OVERRIDE;
diff --git a/cc/CCTextureUpdateControllerTest.cpp b/cc/CCTextureUpdateControllerTest.cpp
index 48c34ec..fd57bb2 100644
--- a/cc/CCTextureUpdateControllerTest.cpp
+++ b/cc/CCTextureUpdateControllerTest.cpp
@@ -521,13 +521,13 @@ TEST_F(CCTextureUpdateControllerTest, TripleUpdateFinalUpdateAllPartial)
 class FakeCCTextureUpdateControllerClient : public cc::CCTextureUpdateControllerClient {
 public:
     FakeCCTextureUpdateControllerClient() { reset(); }
-    void reset() { m_completedCalled = false; }
-    bool completedCalled() const { return m_completedCalled; }
+    void reset() { m_readyToFinalizeCalled = false; }
+    bool readyToFinalizeCalled() const { return m_readyToFinalizeCalled; }
 
-    virtual void updateTexturesCompleted() OVERRIDE { m_completedCalled = true; }
+    virtual void readyToFinalizeTextureUpdates() OVERRIDE { m_readyToFinalizeCalled = true; }
 
 protected:
-    bool m_completedCalled;
+    bool m_readyToFinalizeCalled;
 };
 
 class FakeCCTextureUpdateController : public cc::CCTextureUpdateController {
@@ -579,7 +579,7 @@ TEST_F(CCTextureUpdateControllerTest, UpdateMoreTextures)
     controller->setUpdateMoreTexturesTime(0.1);
     controller->setUpdateMoreTexturesSize(1);
     // Not enough time for any updates.
-    controller->updateMoreTextures(0.09);
+    controller->performMoreUpdates(0.09);
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_EQ(0, m_numBeginUploads);
     EXPECT_EQ(0, m_numEndUploads);
@@ -588,7 +588,7 @@ TEST_F(CCTextureUpdateControllerTest, UpdateMoreTextures)
     controller->setUpdateMoreTexturesTime(0.1);
     controller->setUpdateMoreTexturesSize(1);
     // Only enough time for 1 update.
-    controller->updateMoreTextures(0.12);
+    controller->performMoreUpdates(0.12);
     runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_EQ(1, m_numBeginUploads);
@@ -599,11 +599,11 @@ TEST_F(CCTextureUpdateControllerTest, UpdateMoreTextures)
     controller->setUpdateMoreTexturesTime(0.1);
     controller->setUpdateMoreTexturesSize(1);
     // Enough time for 2 updates.
-    controller->updateMoreTextures(0.22);
+    controller->performMoreUpdates(0.22);
     runPendingTask(&thread, controller.get());
     runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
-    EXPECT_TRUE(client.completedCalled());
+    EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(3, m_numBeginUploads);
     EXPECT_EQ(3, m_numEndUploads);
     EXPECT_EQ(3, m_numTotalUploads);
@@ -625,11 +625,11 @@ TEST_F(CCTextureUpdateControllerTest, NoMoreUpdates)
     controller->setUpdateMoreTexturesTime(0.1);
     controller->setUpdateMoreTexturesSize(1);
     // Enough time for 3 updates but only 2 necessary.
-    controller->updateMoreTextures(0.31);
+    controller->performMoreUpdates(0.31);
     runPendingTask(&thread, controller.get());
     runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
-    EXPECT_TRUE(client.completedCalled());
+    EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numBeginUploads);
     EXPECT_EQ(2, m_numEndUploads);
     EXPECT_EQ(2, m_numTotalUploads);
@@ -638,11 +638,11 @@ TEST_F(CCTextureUpdateControllerTest, NoMoreUpdates)
     controller->setUpdateMoreTexturesTime(0.1);
     controller->setUpdateMoreTexturesSize(1);
     // Enough time for updates but no more updates left.
-    controller->updateMoreTextures(0.31);
-    // 0-delay task used to call updateTexturesCompleted().
+    controller->performMoreUpdates(0.31);
+    // 0-delay task used to call readyToFinalizeTextureUpdates().
     runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
-    EXPECT_TRUE(client.completedCalled());
+    EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numBeginUploads);
     EXPECT_EQ(2, m_numEndUploads);
     EXPECT_EQ(2, m_numTotalUploads);
@@ -665,18 +665,18 @@ TEST_F(CCTextureUpdateControllerTest, UpdatesCompleteInFiniteTime)
     controller->setUpdateMoreTexturesSize(1);
 
     for (int i = 0; i < 100; i++) {
-        if (client.completedCalled())
+        if (client.readyToFinalizeCalled())
             break;
 
         // Not enough time for any updates.
-        controller->updateMoreTextures(0.4);
+        controller->performMoreUpdates(0.4);
 
         if (thread.hasPendingTask())
             runPendingTask(&thread, controller.get());
     }
 
     EXPECT_FALSE(thread.hasPendingTask());
-    EXPECT_TRUE(client.completedCalled());
+    EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numBeginUploads);
     EXPECT_EQ(2, m_numEndUploads);
     EXPECT_EQ(2, m_numTotalUploads);
diff --git a/cc/CCThreadProxy.cpp b/cc/CCThreadProxy.cpp
index ec86bef..cf425e9 100644
--- a/cc/CCThreadProxy.cpp
+++ b/cc/CCThreadProxy.cpp
@@ -593,9 +593,8 @@ void CCThreadProxy::beginFrameCompleteOnImplThread(CCCompletionEvent* completion
         setNeedsCommitOnImplThread();
     }
 
-    bool hasResourceUpdates = queue->hasMoreUpdates();
-    if (hasResourceUpdates)
-        m_currentTextureUpdateControllerOnImplThread = CCTextureUpdateController::create(this, CCProxy::implThread(), queue, m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader());
+    bool hasResourceUpdates = !!queue->fullUploadSize();
+    m_currentTextureUpdateControllerOnImplThread = CCTextureUpdateController::create(this, CCProxy::implThread(), queue, m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader());
     m_commitCompletionEventOnImplThread = completion;
 
     m_schedulerOnImplThread->beginFrameComplete(hasResourceUpdates);
@@ -615,7 +614,8 @@ void CCThreadProxy::scheduledActionUpdateMoreResources(double monotonicTimeLimit
 {
     TRACE_EVENT0("cc", "CCThreadProxy::scheduledActionUpdateMoreResources");
     ASSERT(m_currentTextureUpdateControllerOnImplThread);
-    m_currentTextureUpdateControllerOnImplThread->updateMoreTextures(monotonicTimeLimit);
+    m_currentTextureUpdateControllerOnImplThread->performMoreUpdates(
+        monotonicTimeLimit);
 }
 
 void CCThreadProxy::scheduledActionCommit()
@@ -623,7 +623,10 @@ void CCThreadProxy::scheduledActionCommit()
     TRACE_EVENT0("cc", "CCThreadProxy::scheduledActionCommit");
     ASSERT(isImplThread());
     ASSERT(m_commitCompletionEventOnImplThread);
+    ASSERT(m_currentTextureUpdateControllerOnImplThread);
 
+    // Complete all remaining texture updates.
+    m_currentTextureUpdateControllerOnImplThread->finalize();
     m_currentTextureUpdateControllerOnImplThread.clear();
 
     m_layerTreeHostImpl->beginCommit();
@@ -761,7 +764,7 @@ CCScheduledActionDrawAndSwapResult CCThreadProxy::scheduledActionDrawAndSwapForc
     return scheduledActionDrawAndSwapInternal(true);
 }
 
-void CCThreadProxy::updateTexturesCompleted()
+void CCThreadProxy::readyToFinalizeTextureUpdates()
 {
     ASSERT(isImplThread());
     m_schedulerOnImplThread->updateResourcesComplete();
diff --git a/cc/CCThreadProxy.h b/cc/CCThreadProxy.h
index 0e26168..a4c802a 100644
--- a/cc/CCThreadProxy.h
+++ b/cc/CCThreadProxy.h
@@ -72,7 +72,7 @@ public:
     virtual void scheduledActionAcquireLayerTexturesForMainThread() OVERRIDE;
 
     // CCTextureUpdateControllerClient implementation
-    virtual void updateTexturesCompleted() OVERRIDE;
+    virtual void readyToFinalizeTextureUpdates() OVERRIDE;
 
 private:
     explicit CCThreadProxy(CCLayerTreeHost*);