cc: Make image controller return a status with the callback.

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"
-#include "cc/tiles/image_controller.h"
+#include "cc/test/skia_common.h"
 #include "cc/tiles/image_decode_cache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 class TestWorkerThread : public base::SimpleThread {
  public:
   TestWorkerThread()
       : base::SimpleThread("test_worker_thread"), condition_(&lock_) {}
@@ skipping 66 matching lines @@
 };
 
 // Image decode cache with introspection!
 class TestableCache : public ImageDecodeCache {
  public:
   ~TestableCache() override { EXPECT_EQ(number_of_refs_, 0); }
 
   bool GetTaskForImageAndRef(const DrawImage& image,
                              const TracingInfo& tracing_info,
                              scoped_refptr<TileTask>* task) override {
+    // Return false for large images to mimic "won't fit in memory"
+    // behavior.
+    if (image.image() &&
+        image.image()->width() * image.image()->height() >= 1000 * 1000) {
+      return false;
+    }
+
     *task = task_to_use_;
     ++number_of_refs_;
     return true;
   }
   bool GetOutOfRasterDecodeTaskForImageAndRef(
       const DrawImage& image,
       scoped_refptr<TileTask>* task) override {
-    *task = task_to_use_;
-    ++number_of_refs_;
-    return true;
+    return GetTaskForImageAndRef(image, TracingInfo(), task);
   }
 
   void UnrefImage(const DrawImage& image) override {
     ASSERT_GT(number_of_refs_, 0);
     --number_of_refs_;
   }
   DecodedDrawImage GetDecodedImageForDraw(const DrawImage& image) override {
     return DecodedDrawImage(nullptr, kNone_SkFilterQuality);
   }
   void DrawWithImageFinished(const DrawImage& image,
                              const DecodedDrawImage& decoded_image) override {}
   void ReduceCacheUsage() override {}
   void SetShouldAggressivelyFreeResources(
       bool aggressively_free_resources) override {}
 
   int number_of_refs() const { return number_of_refs_; }
   void SetTaskToUse(scoped_refptr<TileTask> task) { task_to_use_ = task; }
 
  private:
   int number_of_refs_ = 0;
   scoped_refptr<TileTask> task_to_use_;
 };
 
 // A simple class that can receive decode callbacks.
 class DecodeClient {
  public:
   DecodeClient() {}
   void Callback(const base::Closure& quit_closure,
-                ImageController::ImageDecodeRequestId id) {
+                ImageController::ImageDecodeRequestId id,
+                ImageController::ImageDecodeResult result) {
     id_ = id;
+    result_ = result;
     quit_closure.Run();
   }
 
   ImageController::ImageDecodeRequestId id() { return id_; }
+  ImageController::ImageDecodeResult result() { return result_; }
 
  private:
   ImageController::ImageDecodeRequestId id_ = 0;
+  ImageController::ImageDecodeResult result_ =
+      ImageController::ImageDecodeResult::FAILURE;
 };
 
 // A dummy task that does nothing.
 class SimpleTask : public TileTask {
  public:
   SimpleTask() : TileTask(true /* supports_concurrent_execution */) {
     EXPECT_TRUE(thread_checker_.CalledOnValidThread());
   }
 
   void RunOnWorkerThread() override {
@@ skipping 57 matching lines @@
 };
 
 // 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()) {
-    bitmap_.allocN32Pixels(1, 1);
-    image_ = SkImage::MakeFromBitmap(bitmap_);
+    image_ = 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_);
   }
@@ skipping 21 matching lines @@
         base::Bind(&ImageControllerTest::Timeout, base::Unretained(run_loop)),
         base::TimeDelta::FromSeconds(kDefaultTimeoutSeconds));
     run_loop->Run();
   }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   scoped_refptr<WorkerTaskRunner> worker_task_runner_;
   TestableCache cache_;
   std::unique_ptr<ImageController> controller_;
-  SkBitmap bitmap_;
   sk_sp<const SkImage> 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);
   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);
+
+  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));
+  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());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeMultipleImages) {
   base::RunLoop run_loop;
   DecodeClient decode_client1;
   ImageController::ImageDecodeRequestId expected_id1 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client1),
                      base::Bind([] {})));
   DecodeClient decode_client2;
   ImageController::ImageDecodeRequestId expected_id2 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
                      base::Bind([] {})));
   DecodeClient decode_client3;
   ImageController::ImageDecodeRequestId expected_id3 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client3),
                      run_loop.QuitClosure()));
   RunOrTimeout(&run_loop);
   EXPECT_EQ(expected_id1, decode_client1.id());
+  EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
+            decode_client1.result());
   EXPECT_EQ(expected_id2, decode_client2.id());
+  EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
+            decode_client2.result());
   EXPECT_EQ(expected_id3, decode_client3.id());
+  EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
+            decode_client3.result());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeWithTask) {
   scoped_refptr<SimpleTask> task(new SimpleTask);
   cache()->SetTaskToUse(task);
 
   base::RunLoop run_loop;
   DecodeClient decode_client;
   ImageController::ImageDecodeRequestId expected_id =
       controller()->QueueImageDecode(
@@ skipping 24 matching lines @@
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
                      base::Bind([] {})));
   DecodeClient decode_client3;
   ImageController::ImageDecodeRequestId expected_id3 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client3),
                      run_loop.QuitClosure()));
   RunOrTimeout(&run_loop);
   EXPECT_EQ(expected_id1, decode_client1.id());
+  EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
+            decode_client1.result());
   EXPECT_EQ(expected_id2, decode_client2.id());
+  EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
+            decode_client2.result());
   EXPECT_EQ(expected_id3, decode_client3.id());
+  EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
+            decode_client3.result());
   EXPECT_TRUE(task->has_run());
   EXPECT_TRUE(task->HasCompleted());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeChangeControllerWithTaskQueued) {
   scoped_refptr<BlockingTask> task_one(new BlockingTask);
   cache()->SetTaskToUse(task_one);
 
   DecodeClient decode_client1;
   ImageController::ImageDecodeRequestId expected_id1 =
@@ skipping 43 matching lines @@
   cache()->SetTaskToUse(nullptr);
   base::RunLoop run_loop2;
   DecodeClient decode_client2;
   ImageController::ImageDecodeRequestId expected_id2 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
                      run_loop2.QuitClosure()));
   RunOrTimeout(&run_loop2);
   EXPECT_EQ(expected_id2, decode_client2.id());
+  EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
+            decode_client2.result());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeLockedImageControllerChange) {
   scoped_refptr<SimpleTask> task(new SimpleTask);
   cache()->SetTaskToUse(task);
 
   base::RunLoop run_loop1;
   DecodeClient decode_client1;
   ImageController::ImageDecodeRequestId expected_id1 =
       controller()->QueueImageDecode(
@@ skipping 30 matching lines @@
   // 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);
   RunOrTimeout(&run_loop1);
   RunOrTimeout(&run_loop2);
 }
 
 }  // namespace
 }  // namespace cc