Use PaintImage in cc QueueImageDecode

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 <utility>
 
 #include "base/bind.h"
 #include "base/optional.h"
@@ skipping 219 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BlockingTask);
 };
 
 // For tests that exercise image controller's thread, this is the timeout value
 // to allow the worker thread to do its work.
 int kDefaultTimeoutSeconds = 10;
 
 class ImageControllerTest : public testing::Test {
  public:
   ImageControllerTest() : task_runner_(base::SequencedTaskRunnerHandle::Get()) {
-    image_ = CreateDiscardableImage(gfx::Size(1, 1));
+    image_ = PaintImage(PaintImage::GetNextId(),
+                        CreateDiscardableImage(gfx::Size(1, 1)));
   }
   ~ImageControllerTest() override = default;
 
   void SetUp() override {
     worker_task_runner_ = make_scoped_refptr(new WorkerTaskRunner);
     controller_.reset(
         new ImageController(task_runner_.get(), worker_task_runner_));
     cache_ = TestableCache();
     controller_->SetImageDecodeCache(&cache_);
   }
 
   void TearDown() override {
     controller_.reset();
     worker_task_runner_ = nullptr;
   }
 
   base::SequencedTaskRunner* task_runner() { return task_runner_.get(); }
   ImageController* controller() { return controller_.get(); }
   TestableCache* cache() { return &cache_; }
-  sk_sp<const SkImage> image() const { return image_; }
+  PaintImage image() const { return image_; }
 
   // Timeout callback, which errors and exits the runloop.
   static void Timeout(base::RunLoop* run_loop) {
     ADD_FAILURE() << "Timeout.";
     run_loop->Quit();
   }
 
   // Convenience method to run the run loop with a timeout.
   void RunOrTimeout(base::RunLoop* run_loop) {
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::BindOnce(&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_;
+  PaintImage image_;
 };
 
 TEST_F(ImageControllerTest, NullControllerUnrefsImages) {
   std::vector<DrawImage> images(10);
   ImageDecodeCache::TracingInfo tracing_info;
 
   ASSERT_EQ(10u, images.size());
   auto tasks =
       controller()->SetPredecodeImages(std::move(images), tracing_info);
   EXPECT_EQ(0u, tasks.size());
   EXPECT_EQ(10, cache()->number_of_refs());
 
   controller()->SetImageDecodeCache(nullptr);
   EXPECT_EQ(0, cache()->number_of_refs());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecode) {
   base::RunLoop run_loop;
   DecodeClient decode_client;
-  EXPECT_EQ(image()->bounds().width(), 1);
+  EXPECT_EQ(image().sk_image()->bounds().width(), 1);
   ImageController::ImageDecodeRequestId expected_id =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client),
                      run_loop.QuitClosure()));
   RunOrTimeout(&run_loop);
   EXPECT_EQ(expected_id, decode_client.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
             decode_client.result());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeNonLazy) {
   base::RunLoop run_loop;
   DecodeClient decode_client;
 
   SkBitmap bitmap;
   bitmap.allocN32Pixels(1, 1);
-  sk_sp<const SkImage> image = SkImage::MakeFromBitmap(bitmap);
+  PaintImage image(PaintImage::GetNextId(), SkImage::MakeFromBitmap(bitmap));
 
   ImageController::ImageDecodeRequestId expected_id =
       controller()->QueueImageDecode(
           image,
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client),
                      run_loop.QuitClosure()));
   RunOrTimeout(&run_loop);
   EXPECT_EQ(expected_id, decode_client.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED,
             decode_client.result());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeTooLarge) {
   base::RunLoop run_loop;
   DecodeClient decode_client;
+  PaintImage image(PaintImage::GetNextId(),
+                   CreateDiscardableImage(gfx::Size(2000, 2000)));
 
-  sk_sp<const SkImage> image = CreateDiscardableImage(gfx::Size(2000, 2000));
   ImageController::ImageDecodeRequestId expected_id =
       controller()->QueueImageDecode(
           image,
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client),
                      run_loop.QuitClosure()));
   RunOrTimeout(&run_loop);
   EXPECT_EQ(expected_id, decode_client.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::FAILURE,
             decode_client.result());
 }
@@ skipping 240 matching lines @@
             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