cc: Maximize pending updates.

cc/resource_update_controller.cc

 // 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 "cc/resource_update_controller.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/prioritized_texture.h"
@@ skipping 77 matching lines @@
 {
     m_timeLimit = timeLimit;
 
     // Update already in progress.
     if (m_taskPosted)
         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_taskPosted = true;
-            m_thread->postTask(base::Bind(&ResourceUpdateController::onTimerFired,
-                                          m_weakFactory.GetWeakPtr()));
-        }
+    if (!m_firstUpdateAttempt)
+        updateMoreTexturesNow();
 
-        m_firstUpdateAttempt = false;
-    } else
-        updateMoreTexturesNow();
+    // Post a 0-delay task when no updates were left. When it runs,
+    // readyToFinalizeTextureUpdates() will be called.
+    if (!updateMoreTexturesIfEnoughTimeRemaining()) {
+        m_taskPosted = true;
+        m_thread->postTask(
+            base::Bind(&ResourceUpdateController::onTimerFired,
+                       m_weakFactory.GetWeakPtr()));
+    }
+
+    m_firstUpdateAttempt = false;
 }
 
 void ResourceUpdateController::discardUploadsToEvictedResources()
 {
     m_queue->clearUploadsToEvictedResources();
 }
 
 void ResourceUpdateController::updateTexture(ResourceUpdate update)
 {
     if (update.picture) {
@@ skipping 113 matching lines @@
 size_t ResourceUpdateController::updateMoreTexturesSize() const
 {
     return m_textureUpdatesPerTick;
 }
 
 size_t ResourceUpdateController::maxBlockingUpdates() const
 {
     return updateMoreTexturesSize() * maxBlockingUpdateIntervals;
 }
 
+base::TimeDelta ResourceUpdateController::pendingUpdateTime() const
+{
+    base::TimeDelta updateOneResourceTime =
+        updateMoreTexturesTime() / updateMoreTexturesSize();
+    return updateOneResourceTime * m_resourceProvider->numBlockingUploads();
+}
+
 bool ResourceUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
 {
-    // Blocking uploads will increase when we're too aggressive in our upload
-    // time estimate. We use a different timeout here to prevent unnecessary
-    // amounts of idle time when blocking uploads have reached the max.
-    if (m_resourceProvider->numBlockingUploads() >= maxBlockingUpdates()) {
-        m_taskPosted = true;
-        m_thread->postDelayedTask(base::Bind(&ResourceUpdateController::onTimerFired,
-                                             m_weakFactory.GetWeakPtr()),
-                                 uploaderBusyTickRate * 1000);
-        return true;
+    while (m_resourceProvider->numBlockingUploads() < maxBlockingUpdates()) {
+        if (!m_queue->fullUploadSize())
+            return false;
+
+        if (!m_timeLimit.is_null()) {
+            // Estimated completion time of all pending updates.
+            base::TimeTicks completionTime = this->now() + pendingUpdateTime();
+
+            // Time remaining based on current completion estimate.
+            base::TimeDelta timeRemaining = m_timeLimit - completionTime;
+
+            if (timeRemaining < updateMoreTexturesTime())
+                return true;
+        }
+
+        updateMoreTexturesNow();
     }
 
-    if (!m_queue->fullUploadSize())
-        return false;
-
-    bool hasTimeRemaining = m_timeLimit.is_null() ||
-        this->now() < m_timeLimit - updateMoreTexturesTime();
-    if (hasTimeRemaining)
-        updateMoreTexturesNow();
-
+    m_taskPosted = true;
+    m_thread->postDelayedTask(
+        base::Bind(&ResourceUpdateController::onTimerFired,
+                   m_weakFactory.GetWeakPtr()),
+        uploaderBusyTickRate * 1000);
     return true;
 }
 
 void ResourceUpdateController::updateMoreTexturesNow()
 {
     size_t uploads = std::min(
         m_queue->fullUploadSize(), updateMoreTexturesSize());
-    m_taskPosted = true;
-    m_thread->postDelayedTask(base::Bind(&ResourceUpdateController::onTimerFired,
-                                         m_weakFactory.GetWeakPtr()),
-                              updateMoreTexturesTime().InSecondsF() / updateMoreTexturesSize() * uploads * 1000);
 
     if (!uploads)
         return;
 
     while (m_queue->fullUploadSize() && uploads--)
         updateTexture(m_queue->takeFirstFullUpload());
 
     m_resourceProvider->flushUploads();
 }
 
 }  // namespace cc