cc: Regenerate image decode requests tasks when cache switches.

cc/tiles/image_controller_unittest.cc

 // Copyright 2016 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/tiles/image_controller.h"
 #include "base/bind.h"
 #include "base/optional.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/sequenced_task_runner_handle.h"
@@ skipping 248 matching lines @@
 
   // Convenience method to run the run loop with a timeout.
   void RunOrTimeout(base::RunLoop* run_loop) {
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ImageControllerTest::Timeout, base::Unretained(run_loop)),
         base::TimeDelta::FromSeconds(kDefaultTimeoutSeconds));
     run_loop->Run();
   }
 
+  void ResetController() { controller_.reset(); }
+
  private:
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   scoped_refptr<WorkerTaskRunner> worker_task_runner_;
   TestableCache cache_;
   std::unique_ptr<ImageController> controller_;
   sk_sp<const SkImage> image_;
 };
 
 TEST_F(ImageControllerTest, NullControllerUnrefsImages) {
   std::vector<DrawImage> images(10);
@@ skipping 163 matching lines @@
   DecodeClient decode_client2;
   ImageController::ImageDecodeRequestId expected_id2 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
                      run_loop.QuitClosure()));
 
   task_one->AllowToRun();
   task_two->AllowToRun();
   controller()->SetImageDecodeCache(nullptr);
+  ResetController();
 
   RunOrTimeout(&run_loop);
 
   EXPECT_TRUE(task_one->state().IsCanceled() || task_one->HasCompleted());
   EXPECT_TRUE(task_two->state().IsCanceled() || task_two->HasCompleted());
   EXPECT_EQ(expected_id1, decode_client1.id());
   EXPECT_EQ(expected_id2, decode_client2.id());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeImageAlreadyLocked) {
@@ skipping 38 matching lines @@
                      run_loop1.QuitClosure()));
   RunOrTimeout(&run_loop1);
   EXPECT_EQ(expected_id1, decode_client1.id());
   EXPECT_TRUE(task->has_run());
   EXPECT_EQ(1, cache()->number_of_refs());
 
   controller()->SetImageDecodeCache(nullptr);
   EXPECT_EQ(0, cache()->number_of_refs());
 }
 
-TEST_F(ImageControllerTest, DispatchesDecodeCallbacksAfterCacheChanged) {
+TEST_F(ImageControllerTest, DispatchesDecodeCallbacksAfterCacheReset) {
   scoped_refptr<SimpleTask> task(new SimpleTask);
   cache()->SetTaskToUse(task);
 
   base::RunLoop run_loop1;
   DecodeClient decode_client1;
   base::RunLoop run_loop2;
   DecodeClient decode_client2;
 
   controller()->QueueImageDecode(
       image(),
       base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client1),
                  run_loop1.QuitClosure()));
   controller()->QueueImageDecode(
       image(),
       base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
                  run_loop2.QuitClosure()));
 
   // Now reset the image cache before decode completed callbacks are posted to
   // the compositor thread. Ensure that the completion callbacks for the decode
   // is still run.
   controller()->SetImageDecodeCache(nullptr);
+  ResetController();
+
   RunOrTimeout(&run_loop1);
   RunOrTimeout(&run_loop2);
+
+  EXPECT_EQ(ImageController::ImageDecodeResult::FAILURE,
+            decode_client1.result());
+  EXPECT_EQ(ImageController::ImageDecodeResult::FAILURE,
+            decode_client2.result());
+}
+
+TEST_F(ImageControllerTest, DispatchesDecodeCallbacksAfterCacheChanged) {
+  scoped_refptr<SimpleTask> task(new SimpleTask);
+  cache()->SetTaskToUse(task);
+
+  base::RunLoop run_loop1;
+  DecodeClient decode_client1;
+  base::RunLoop run_loop2;
+  DecodeClient decode_client2;
+
+  controller()->QueueImageDecode(
+      image(),
+      base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client1),
+                 run_loop1.QuitClosure()));
+  controller()->QueueImageDecode(
+      image(),
+      base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
+                 run_loop2.QuitClosure()));
+
+  // Now reset the image cache before decode completed callbacks are posted to
+  // the compositor thread. This should orphan the requests.
+  controller()->SetImageDecodeCache(nullptr);
+
+  EXPECT_EQ(0, cache()->number_of_refs());
+
+  TestableCache other_cache;
+  other_cache.SetTaskToUse(task);
+
+  controller()->SetImageDecodeCache(&other_cache);
+
+  RunOrTimeout(&run_loop1);
+  RunOrTimeout(&run_loop2);
+
+  EXPECT_EQ(2, other_cache.number_of_refs());
+  EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
+            decode_client1.result());
+  EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
+            decode_client2.result());
+
+  // Reset the controller since the order of destruction is wrong in this test
+  // (|other_cache| should outlive the controller. This is normally done via
+  // SetImageDecodeCache(nullptr) or it can be done in the dtor of the cache.)
+  ResetController();
 }
 
 }  // namespace
 }  // namespace cc