cc: Add image decode control in the compositor.

cc/tiles/image_decode_controller_unittest.cc

Index: cc/tiles/image_decode_controller_unittest.cc
diff --git a/cc/tiles/image_decode_controller_unittest.cc b/cc/tiles/image_decode_controller_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e49dcc60270010e43db20b1dfc7534dc86f4bed0
--- /dev/null
+++ b/cc/tiles/image_decode_controller_unittest.cc
@@ -0,0 +1,194 @@
+// Copyright 2015 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_decode_controller.h"
+
+#include "cc/playback/draw_image.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cc {
+namespace {
+
+skia::RefPtr<SkImage> CreateImage(int width, int height) {
+  SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
+  SkBitmap bitmap;
+  bitmap.allocPixels(info);
+  return skia::AdoptRef(SkImage::NewFromBitmap(bitmap));
+}
+
+TEST(ImageDecodeControllerTest, ImageKeyLowQuality) {
+  skia::RefPtr<SkImage> image = CreateImage(100, 100);
+  bool has_perspective = false;
+  bool is_decomposable = true;
+  SkFilterQuality qualities[] = {kNone_SkFilterQuality, kLow_SkFilterQuality};
+  for (auto quality : qualities) {
+    DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
+                         has_perspective, is_decomposable);
+
+    auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+    EXPECT_EQ(image->uniqueID(), key.image_id());
+    EXPECT_EQ(quality, key.filter_quality());
+    EXPECT_EQ(50, key.target_size().width());
+    EXPECT_EQ(150, key.target_size().height());
+    EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
+  }
+}
+
+TEST(ImageDecodeControllerTest, ImageKeyMediumQuality) {
+  skia::RefPtr<SkImage> image = CreateImage(100, 100);
+  bool has_perspective = false;
+  bool is_decomposable = true;
+  SkFilterQuality quality = kMedium_SkFilterQuality;
+
+  DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
+                       has_perspective, is_decomposable);
+
+  auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+  EXPECT_EQ(image->uniqueID(), key.image_id());
+  EXPECT_EQ(quality, key.filter_quality());
+  EXPECT_EQ(50, key.target_size().width());
+  EXPECT_EQ(150, key.target_size().height());
+  EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
+}
+
+TEST(ImageDecodeControllerTest, ImageKeyMediumQualityEvenWithPerspective) {
+  skia::RefPtr<SkImage> image = CreateImage(100, 100);
+  bool has_perspective = true;
+  bool is_decomposable = true;
+  SkFilterQuality quality = kMedium_SkFilterQuality;
+
+  DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
+                       has_perspective, is_decomposable);
+
+  auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+  EXPECT_EQ(image->uniqueID(), key.image_id());
+  EXPECT_EQ(quality, key.filter_quality());
+  EXPECT_EQ(50, key.target_size().width());
+  EXPECT_EQ(150, key.target_size().height());
+  EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
+}
+
+TEST(ImageDecodeControllerTest, ImageKeyMediumQualityDropToLowIfEnlarging) {
+  skia::RefPtr<SkImage> image = CreateImage(100, 100);
+  bool has_perspective = false;
+  bool is_decomposable = true;
+  SkFilterQuality quality = kMedium_SkFilterQuality;
+
+  DrawImage draw_image(image.get(), SkSize::Make(1.5f, 1.5f), quality,
+                       has_perspective, is_decomposable);
+
+  auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+  EXPECT_EQ(image->uniqueID(), key.image_id());
+  EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
+  EXPECT_EQ(150, key.target_size().width());
+  EXPECT_EQ(150, key.target_size().height());
+  EXPECT_EQ(150u * 150u * 4u, key.target_bytes());
+}
+
+TEST(ImageDecodeControllerTest, ImageKeyMediumQualityDropToLowIfIdentity) {
+  skia::RefPtr<SkImage> image = CreateImage(100, 100);
+  bool has_perspective = false;
+  bool is_decomposable = true;
+  SkFilterQuality quality = kMedium_SkFilterQuality;
+
+  DrawImage draw_image(image.get(), SkSize::Make(1.f, 1.f), quality,
+                       has_perspective, is_decomposable);
+
+  auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+  EXPECT_EQ(image->uniqueID(), key.image_id());
+  EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
+  EXPECT_EQ(100, key.target_size().width());
+  EXPECT_EQ(100, key.target_size().height());
+  EXPECT_EQ(100u * 100u * 4u, key.target_bytes());
+}
+
+TEST(ImageDecodeControllerTest,
+     ImageKeyMediumQualityDropToLowIfNotDecomposable) {
+  skia::RefPtr<SkImage> image = CreateImage(100, 100);
+  bool has_perspective = false;
+  bool is_decomposable = false;
+  SkFilterQuality quality = kMedium_SkFilterQuality;
+
+  DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
+                       has_perspective, is_decomposable);
+
+  auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+  EXPECT_EQ(image->uniqueID(), key.image_id());
+  EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
+  EXPECT_EQ(50, key.target_size().width());
+  EXPECT_EQ(150, key.target_size().height());
+  EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
+}
+
+TEST(ImageDecodeControllerTest, ImageKeyHighQuality) {
+  skia::RefPtr<SkImage> image = CreateImage(100, 100);
+  bool has_perspective = false;
+  bool is_decomposable = true;
+  SkFilterQuality quality = kHigh_SkFilterQuality;
+
+  DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
+                       has_perspective, is_decomposable);
+
+  auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+  EXPECT_EQ(image->uniqueID(), key.image_id());
+  EXPECT_EQ(quality, key.filter_quality());
+  EXPECT_EQ(50, key.target_size().width());
+  EXPECT_EQ(150, key.target_size().height());
+  EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
+}
+
+TEST(ImageDecodeControllerTest,
+     ImageKeyHighQualityDropToMediumWithPerspective) {
+  skia::RefPtr<SkImage> image = CreateImage(100, 100);
+  bool has_perspective = true;
+  bool is_decomposable = true;
+  SkFilterQuality quality = kHigh_SkFilterQuality;
+
+  DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
+                       has_perspective, is_decomposable);
+
+  auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+  EXPECT_EQ(image->uniqueID(), key.image_id());
+  EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
+  EXPECT_EQ(50, key.target_size().width());
+  EXPECT_EQ(150, key.target_size().height());
+  EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
+}
+
+TEST(ImageDecodeControllerTest, ImageKeyHighQualityDropToLowIfNotDecomposable) {
+  skia::RefPtr<SkImage> image = CreateImage(100, 100);
+  bool has_perspective = false;
+  bool is_decomposable = false;
+  SkFilterQuality quality = kHigh_SkFilterQuality;
+
+  DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
+                       has_perspective, is_decomposable);
+
+  auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+  EXPECT_EQ(image->uniqueID(), key.image_id());
+  EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
+  EXPECT_EQ(50, key.target_size().width());
+  EXPECT_EQ(150, key.target_size().height());
+  EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
+}
+
+TEST(ImageDecodeControllerTest, ImageKeyHighQualityDropToLowIfIdentity) {
+  skia::RefPtr<SkImage> image = CreateImage(100, 100);
+  bool has_perspective = false;
+  bool is_decomposable = true;
+  SkFilterQuality quality = kHigh_SkFilterQuality;
+
+  DrawImage draw_image(image.get(), SkSize::Make(1.f, 1.f), quality,
+                       has_perspective, is_decomposable);
+
+  auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+  EXPECT_EQ(image->uniqueID(), key.image_id());
+  EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
+  EXPECT_EQ(100, key.target_size().width());
+  EXPECT_EQ(100, key.target_size().height());
+  EXPECT_EQ(100u * 100u * 4u, key.target_bytes());
+}
+
+}  // namespace
+}  // namespace cc