cc: Prevent ResourceUpdateContoller from uploading textures after lost context

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 14 matching lines @@
 }  // namespace
 
 namespace cc {
 
 size_t ResourceUpdateController::MaxPartialTextureUpdates() {
   return kPartialTextureUpdatesMax;
 }
 
 size_t ResourceUpdateController::MaxFullUpdatesPerTick(
     ResourceProvider* resource_provider) {
-  double textures_per_second = resource_provider->EstimatedUploadsPerSecond();
-  size_t textures_per_tick =
-      floor(resource_provider->TextureUpdateTickRate().InSecondsF() *
-            textures_per_second);
-  return textures_per_tick ? textures_per_tick : 1;
+  return resource_provider->EstimatedUploadsPerTick();
 }
 
 ResourceUpdateController::ResourceUpdateController(
     ResourceUpdateControllerClient* client,
     base::SingleThreadTaskRunner* task_runner,
     scoped_ptr<ResourceUpdateQueue> queue,
     ResourceProvider* resource_provider)
     : client_(client),
       queue_(queue.Pass()),
       resource_provider_(resource_provider),
@@ skipping 56 matching lines @@
 
   resource_provider_->FlushUploads();
 }
 
 void ResourceUpdateController::OnTimerFired() {
   task_posted_ = false;
   if (!UpdateMoreTexturesIfEnoughTimeRemaining())
     client_->ReadyToFinalizeTextureUpdates();
 }
 
-base::TimeTicks ResourceUpdateController::Now() const {
-  return gfx::FrameTime::Now();
-}
-
-base::TimeDelta ResourceUpdateController::UpdateMoreTexturesTime() const {
-  return resource_provider_->TextureUpdateTickRate();
+base::TimeTicks ResourceUpdateController::UpdateMoreTexturesCompletionTime() {
+  return resource_provider_->EstimatedUploadCompletionTime(
+      texture_updates_per_tick_);
 }
 
 size_t ResourceUpdateController::UpdateMoreTexturesSize() const {
   return texture_updates_per_tick_;
 }
 
 size_t ResourceUpdateController::MaxBlockingUpdates() const {
   return UpdateMoreTexturesSize() * kMaxBlockingUpdateIntervals;
 }
 
-base::TimeDelta ResourceUpdateController::PendingUpdateTime() const {
-  base::TimeDelta update_one_resource_time =
-      UpdateMoreTexturesTime() / UpdateMoreTexturesSize();
-  return update_one_resource_time * resource_provider_->NumBlockingUploads();
-}
-
 bool ResourceUpdateController::UpdateMoreTexturesIfEnoughTimeRemaining() {
   while (resource_provider_->NumBlockingUploads() < MaxBlockingUpdates()) {
     if (!queue_->FullUploadSize())
       return false;
 
     if (!time_limit_.is_null()) {
-      // Estimated completion time of all pending updates.
-      base::TimeTicks completion_time = Now() + PendingUpdateTime();
-
-      // Time remaining based on current completion estimate.
-      base::TimeDelta time_remaining = time_limit_ - completion_time;
-
-      if (time_remaining < UpdateMoreTexturesTime())
+      base::TimeTicks completion_time = UpdateMoreTexturesCompletionTime();
+      if (completion_time > time_limit_)
         return true;
     }
 
     UpdateMoreTexturesNow();
   }
 
   task_posted_ = true;
   task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ResourceUpdateController::OnTimerFired,
                  weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kUploaderBusyTickRate * 1000));
   return true;
 }
 
 void ResourceUpdateController::UpdateMoreTexturesNow() {
   size_t uploads = std::min(
       queue_->FullUploadSize(), UpdateMoreTexturesSize());
 
   if (!uploads)
     return;
 
   while (queue_->FullUploadSize() && uploads--)
     UpdateTexture(queue_->TakeFirstFullUpload());
 
   resource_provider_->FlushUploads();
 }
 
 }  // namespace cc