cc: Add scaling for checkered images.

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 216 matching lines @@
   base::ConditionVariable run_cv_;
   bool can_run_ = false;
 
   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;
 
+DrawImage CreateDiscardableDrawImage(gfx::Size size) {
+  return DrawImage(
+      PaintImage(PaintImage::kUnknownStableId, CreateDiscardableImage(size)),
+      SkIRect::MakeWH(size.width(), size.height()), kNone_SkFilterQuality,
+      SkMatrix::I(), gfx::ColorSpace());
+}
+
 class ImageControllerTest : public testing::Test {
  public:
   ImageControllerTest() : task_runner_(base::SequencedTaskRunnerHandle::Get()) {
-    image_ = CreateDiscardableImage(gfx::Size(1, 1));
+    image_ = CreateDiscardableDrawImage(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_; }
+  const DrawImage& 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_;
+  DrawImage 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().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);
+  DrawImage image = DrawImage(
+      PaintImage(PaintImage::kUnknownStableId, SkImage::MakeFromBitmap(bitmap)),
+      SkIRect::MakeWH(1, 1), kNone_SkFilterQuality, SkMatrix::I(),
+      gfx::ColorSpace());
 
   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;
 
-  sk_sp<const SkImage> image = CreateDiscardableImage(gfx::Size(2000, 2000));
+  DrawImage image = CreateDiscardableDrawImage(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