cc: Prevent ResourceUpdateContoller from uploading textures after lost context

cc/resources/resource_update_controller_unittest.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/test/test_simple_task_runner.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
@@ skipping 337 matching lines @@
   static scoped_ptr<FakeResourceUpdateController> Create(
       ResourceUpdateControllerClient* client,
       base::TestSimpleTaskRunner* task_runner,
       scoped_ptr<ResourceUpdateQueue> queue,
       ResourceProvider* resource_provider) {
     return make_scoped_ptr(new FakeResourceUpdateController(
         client, task_runner, queue.Pass(), resource_provider));
   }
 
   void SetNow(base::TimeTicks time) { now_ = time; }
-  virtual base::TimeTicks Now() const OVERRIDE { return now_; }
-  void SetUpdateMoreTexturesTime(base::TimeDelta time) {
-    update_more_textures_time_ = time;
+  base::TimeTicks Now() const { return now_; }
+  void SetUpdateTextureTime(base::TimeDelta time) {
+    update_textures_time_ = time;
   }
-  virtual base::TimeDelta UpdateMoreTexturesTime() const OVERRIDE {
-    return update_more_textures_time_;
+  virtual base::TimeTicks UpdateMoreTexturesCompletionTime() OVERRIDE {
+    size_t total_updates =
+        resource_provider_->NumBlockingUploads() + update_more_textures_size_;
+    return now_ + total_updates * update_textures_time_;
   }
   void SetUpdateMoreTexturesSize(size_t size) {
     update_more_textures_size_ = size;
   }
   virtual size_t UpdateMoreTexturesSize() const OVERRIDE {
     return update_more_textures_size_;
   }
 
  protected:
   FakeResourceUpdateController(ResourceUpdateControllerClient* client,
                                base::TestSimpleTaskRunner* task_runner,
                                scoped_ptr<ResourceUpdateQueue> queue,
                                ResourceProvider* resource_provider)
       : ResourceUpdateController(
           client, task_runner, queue.Pass(), resource_provider),
+        resource_provider_(resource_provider),
         update_more_textures_size_(0) {}
 
+  ResourceProvider* resource_provider_;
   base::TimeTicks now_;
-  base::TimeDelta update_more_textures_time_;
+  base::TimeDelta update_textures_time_;
   size_t update_more_textures_size_;
 };
 
 static void RunPendingTask(base::TestSimpleTaskRunner* task_runner,
                            FakeResourceUpdateController* controller) {
   EXPECT_TRUE(task_runner->HasPendingTask());
   controller->SetNow(controller->Now() + task_runner->NextPendingTaskDelay());
   task_runner->RunPendingTasks();
 }
 
 TEST_F(ResourceUpdateControllerTest, UpdateMoreTextures) {
   FakeResourceUpdateControllerClient client;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner =
       new base::TestSimpleTaskRunner;
 
   SetMaxUploadCountPerUpdate(1);
   AppendFullUploadsToUpdateQueue(3);
   AppendPartialUploadsToUpdateQueue(0);
 
   DebugScopedSetImplThreadAndMainThreadBlocked
   impl_thread_and_main_thread_blocked(&proxy_);
   scoped_ptr<FakeResourceUpdateController> controller(
       FakeResourceUpdateController::Create(&client,
                                            task_runner.get(),
                                            queue_.Pass(),
                                            resource_provider_.get()));
 
   controller->SetNow(controller->Now() + base::TimeDelta::FromMilliseconds(1));
-  controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100));
+  controller->SetUpdateTextureTime(base::TimeDelta::FromMilliseconds(100));
   controller->SetUpdateMoreTexturesSize(1);
   // Not enough time for any updates.
   controller->PerformMoreUpdates(controller->Now() +
                                  base::TimeDelta::FromMilliseconds(90));
   EXPECT_FALSE(task_runner->HasPendingTask());
 
-  controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100));
+  controller->SetUpdateTextureTime(base::TimeDelta::FromMilliseconds(100));
   controller->SetUpdateMoreTexturesSize(1);
   // Only enough time for 1 update.
   controller->PerformMoreUpdates(controller->Now() +
                                  base::TimeDelta::FromMilliseconds(120));
   EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_EQ(1, num_total_uploads_);
 
   // Complete one upload.
   MakeQueryResultAvailable();
 
-  controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100));
+  controller->SetUpdateTextureTime(base::TimeDelta::FromMilliseconds(100));
   controller->SetUpdateMoreTexturesSize(1);
   // Enough time for 2 updates.
   controller->PerformMoreUpdates(controller->Now() +
                                  base::TimeDelta::FromMilliseconds(220));
   RunPendingTask(task_runner.get(), controller.get());
   EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_TRUE(client.ReadyToFinalizeCalled());
   EXPECT_EQ(3, num_total_uploads_);
 }
 
 TEST_F(ResourceUpdateControllerTest, NoMoreUpdates) {
   FakeResourceUpdateControllerClient client;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner =
       new base::TestSimpleTaskRunner;
 
   SetMaxUploadCountPerUpdate(1);
   AppendFullUploadsToUpdateQueue(2);
   AppendPartialUploadsToUpdateQueue(0);
 
   DebugScopedSetImplThreadAndMainThreadBlocked
   impl_thread_and_main_thread_blocked(&proxy_);
   scoped_ptr<FakeResourceUpdateController> controller(
       FakeResourceUpdateController::Create(&client,
                                            task_runner.get(),
                                            queue_.Pass(),
                                            resource_provider_.get()));
 
   controller->SetNow(controller->Now() + base::TimeDelta::FromMilliseconds(1));
-  controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100));
+  controller->SetUpdateTextureTime(base::TimeDelta::FromMilliseconds(100));
   controller->SetUpdateMoreTexturesSize(1);
   // Enough time for 3 updates but only 2 necessary.
   controller->PerformMoreUpdates(controller->Now() +
                                  base::TimeDelta::FromMilliseconds(310));
   RunPendingTask(task_runner.get(), controller.get());
   EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_TRUE(client.ReadyToFinalizeCalled());
   EXPECT_EQ(2, num_total_uploads_);
 
-  controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100));
+  controller->SetUpdateTextureTime(base::TimeDelta::FromMilliseconds(100));
   controller->SetUpdateMoreTexturesSize(1);
   // Enough time for updates but no more updates left.
   controller->PerformMoreUpdates(controller->Now() +
                                  base::TimeDelta::FromMilliseconds(310));
   // 0-delay task used to call ReadyToFinalizeTextureUpdates().
   RunPendingTask(task_runner.get(), controller.get());
   EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_TRUE(client.ReadyToFinalizeCalled());
   EXPECT_EQ(2, num_total_uploads_);
 }
 
 TEST_F(ResourceUpdateControllerTest, UpdatesCompleteInFiniteTime) {
   FakeResourceUpdateControllerClient client;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner =
       new base::TestSimpleTaskRunner;
 
   SetMaxUploadCountPerUpdate(1);
   AppendFullUploadsToUpdateQueue(2);
   AppendPartialUploadsToUpdateQueue(0);
 
   DebugScopedSetImplThreadAndMainThreadBlocked
   impl_thread_and_main_thread_blocked(&proxy_);
   scoped_ptr<FakeResourceUpdateController> controller(
       FakeResourceUpdateController::Create(&client,
                                            task_runner.get(),
                                            queue_.Pass(),
                                            resource_provider_.get()));
 
   controller->SetNow(controller->Now() + base::TimeDelta::FromMilliseconds(1));
-  controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(500));
+  controller->SetUpdateTextureTime(base::TimeDelta::FromMilliseconds(500));
   controller->SetUpdateMoreTexturesSize(1);
 
   for (int i = 0; i < 100; i++) {
     if (client.ReadyToFinalizeCalled())
       break;
 
     // Not enough time for any updates.
     controller->PerformMoreUpdates(controller->Now() +
                                    base::TimeDelta::FromMilliseconds(400));
 
     if (task_runner->HasPendingTask())
       RunPendingTask(task_runner.get(), controller.get());
   }
 
   EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_TRUE(client.ReadyToFinalizeCalled());
   EXPECT_EQ(2, num_total_uploads_);
 }
 
 }  // namespace
 }  // namespace cc