cc: Don't call ReadyToFinalizeTextureUpdates multiple times

cc/resources/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 "cc/resources/resource_update_controller.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "cc/resources/prioritized_resource.h"
@@ skipping 29 matching lines @@
     base::SingleThreadTaskRunner* task_runner,
     scoped_ptr<ResourceUpdateQueue> queue,
     ResourceProvider* resource_provider)
     : client_(client),
       queue_(queue.Pass()),
       resource_provider_(resource_provider),
       texture_updates_per_tick_(MaxFullUpdatesPerTick(resource_provider)),
       first_update_attempt_(true),
       task_runner_(task_runner),
       task_posted_(false),
+      ready_to_finalize_(false),
       weak_factory_(this) {}
 
 ResourceUpdateController::~ResourceUpdateController() {}
 
 void ResourceUpdateController::PerformMoreUpdates(
     base::TimeTicks time_limit) {
   time_limit_ = time_limit;
 
-  // Update already in progress.
-  if (task_posted_)
+  // Update already in progress or we are already done.
+  if (task_posted_ || ready_to_finalize_)
     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 (!first_update_attempt_)
     UpdateMoreTexturesNow();
 
   // Post a 0-delay task when no updates were left. When it runs,
   // ReadyToFinalizeTextureUpdates() will be called.
@@ skipping 28 matching lines @@
     UpdateTexture(queue_->TakeFirstFullUpload());
 
   while (queue_->PartialUploadSize())
     UpdateTexture(queue_->TakeFirstPartialUpload());
 
   resource_provider_->FlushUploads();
 }
 
 void ResourceUpdateController::OnTimerFired() {
   task_posted_ = false;
-  if (!UpdateMoreTexturesIfEnoughTimeRemaining())
+  if (!UpdateMoreTexturesIfEnoughTimeRemaining()) {
+    ready_to_finalize_ = true;
     client_->ReadyToFinalizeTextureUpdates();
+  }
 }
 
 base::TimeTicks ResourceUpdateController::UpdateMoreTexturesCompletionTime() {
   return resource_provider_->EstimatedUploadCompletionTime(
       texture_updates_per_tick_);
 }
 
 size_t ResourceUpdateController::UpdateMoreTexturesSize() const {
   return texture_updates_per_tick_;
 }
@@ skipping 32 matching lines @@
   if (!uploads)
     return;
 
   while (queue_->FullUploadSize() && uploads--)
     UpdateTexture(queue_->TakeFirstFullUpload());
 
   resource_provider_->FlushUploads();
 }
 
 }  // namespace cc