cc: Use medium filter quality for downscales.

cc/tiles/software_image_decode_controller_unittest.cc

 // 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/software_image_decode_controller.h"
 
 #include "cc/playback/draw_image.h"
 #include "cc/resources/resource_format.h"
 #include "cc/test/test_tile_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 281 matching lines @@
 
   auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
   EXPECT_EQ(image->uniqueID(), key.image_id());
   EXPECT_EQ(quality, key.filter_quality());
   EXPECT_EQ(7, key.target_size().width());
   EXPECT_EQ(3, key.target_size().height());
   EXPECT_FALSE(key.can_use_original_decode());
   EXPECT_EQ(7u * 3u * 4u, key.locked_bytes());
 }
 
-TEST(SoftwareImageDecodeControllerTest, ImageKeyHighQuality) {
+TEST(SoftwareImageDecodeControllerTest,
+     ImageKeyPartialDowscalesDropsHighQualityToMedium) {
   sk_sp<SkImage> image = CreateImage(100, 100);
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable));
 
   auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
   EXPECT_EQ(image->uniqueID(), key.image_id());
+  EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
+  EXPECT_EQ(100, key.target_size().width());
+  EXPECT_EQ(100, key.target_size().height());
+  EXPECT_FALSE(key.can_use_original_decode());
+  EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
+}
+
+TEST(SoftwareImageDecodeControllerTest,
+     ImageKeyFullDowscalesDropsHighQualityToMedium) {
+  sk_sp<SkImage> image = CreateImage(100, 100);
+  bool is_decomposable = true;
+  SkFilterQuality quality = kHigh_SkFilterQuality;
+
+  DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
+                       quality,
+                       CreateMatrix(SkSize::Make(0.5f, 0.2f), 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(50, key.target_size().height());
+  EXPECT_FALSE(key.can_use_original_decode());
+  EXPECT_EQ(50u * 50u * 4u, key.locked_bytes());
+}
+
+TEST(SoftwareImageDecodeControllerTest, ImageKeyDowscalesHighQuality) {
+  sk_sp<SkImage> image = CreateImage(100, 100);
+  bool is_decomposable = true;
+  SkFilterQuality quality = kHigh_SkFilterQuality;
+
+  DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
+                       quality,
+                       CreateMatrix(SkSize::Make(2.5f, 1.5f), 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(250, key.target_size().width());
   EXPECT_EQ(150, key.target_size().height());
   EXPECT_FALSE(key.can_use_original_decode());
-  EXPECT_EQ(50u * 150u * 4u, key.locked_bytes());
+  EXPECT_EQ(250u * 150u * 4u, key.locked_bytes());
 }
 
 TEST(SoftwareImageDecodeControllerTest,
      ImageKeyHighQualityDropToMediumIfTooLarge) {
   // Just over 64MB when scaled.
   sk_sp<SkImage> image = CreateImage(4555, 2048);
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   // At least one dimension should scale down, so that medium quality doesn't
@@ skipping 143 matching lines @@
   sk_sp<SkImage> image = CreateImage(100, 100);
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   DrawImage draw_image(
       image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
 
   auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
   EXPECT_EQ(image->uniqueID(), key.image_id());
-  EXPECT_EQ(kHigh_SkFilterQuality, key.filter_quality());
+  EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
   EXPECT_EQ(40, key.target_size().width());
   EXPECT_EQ(35, key.target_size().height());
   EXPECT_EQ(gfx::Rect(20, 30, 80, 70), key.src_rect());
   EXPECT_EQ(40u * 35u * 4u, key.locked_bytes());
 }
 
 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImage) {
   TestSoftwareImageDecodeController controller;
   sk_sp<SkImage> image = CreateImage(100, 100);
   bool is_decomposable = true;
@@ skipping 33 matching lines @@
       image, SkIRect::MakeWH(image->width(), image->height()),
       kHigh_SkFilterQuality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
   scoped_refptr<TileTask> high_quality_task;
   bool need_unref = controller.GetTaskForImageAndRef(
       high_quality_draw_image, ImageDecodeController::TracingInfo(),
       &high_quality_task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(high_quality_task);
 
-  DrawImage medium_quality_draw_image(
-      image, SkIRect::MakeWH(image->width(), image->height()),
-      kMedium_SkFilterQuality,
-      CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<TileTask> medium_quality_task;
-  need_unref = controller.GetTaskForImageAndRef(
-      medium_quality_draw_image, ImageDecodeController::TracingInfo(),
-      &medium_quality_task);
-  EXPECT_TRUE(need_unref);
-  EXPECT_TRUE(medium_quality_task);
-  EXPECT_TRUE(high_quality_task.get() != medium_quality_task.get());
-
   DrawImage low_quality_draw_image(
       image, SkIRect::MakeWH(image->width(), image->height()),
       kLow_SkFilterQuality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
   scoped_refptr<TileTask> low_quality_task;
   need_unref = controller.GetTaskForImageAndRef(
       low_quality_draw_image, ImageDecodeController::TracingInfo(),
       &low_quality_task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(low_quality_task);
   EXPECT_TRUE(high_quality_task.get() != low_quality_task.get());
-  EXPECT_TRUE(medium_quality_task.get() != low_quality_task.get());
 
   TestTileTaskRunner::ProcessTask(high_quality_task.get());
-  TestTileTaskRunner::ProcessTask(medium_quality_task.get());
   TestTileTaskRunner::ProcessTask(low_quality_task.get());
 
   controller.UnrefImage(high_quality_draw_image);
-  controller.UnrefImage(medium_quality_draw_image);
   controller.UnrefImage(low_quality_draw_image);
 }
 
 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) {
   TestSoftwareImageDecodeController controller;
   sk_sp<SkImage> image = CreateImage(100, 100);
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   DrawImage half_size_draw_image(
@@ skipping 850 matching lines @@
   EXPECT_EQ(decoded_draw_image_50.image(), decoded_draw_image_49.image());
 
   controller.DrawWithImageFinished(draw_image_50, decoded_draw_image_50);
   controller.UnrefImage(draw_image_50);
   controller.DrawWithImageFinished(draw_image_49, decoded_draw_image_49);
   controller.UnrefImage(draw_image_49);
 }
 
 }  // namespace
 }  // namespace cc