cc: Add unit tests for non-identity matrix for FilterOperation::MapRect.

cc/output/filter_operations_unittest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include "cc/output/filter_operations.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "third_party/skia/include/effects/SkDropShadowImageFilter.h"
 #include "third_party/skia/include/effects/SkOffsetImageFilter.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace cc {
 namespace {
 
+SkMatrix MakeScaleMatrix(float x_scale, float y_scale) {

[Stephen White, 2016/07/14 22:03:14]

BTW, this is SkMatrix::MakeScale().

[jbroman, 2016/07/14 22:24:06]

Done. Don't know how I missed that, it being the very first function in
SkMatrix.h. :)

+  SkMatrix matrix;
+  matrix.setScale(x_scale, y_scale);
+  return matrix;
+}
+
 TEST(FilterOperationsTest, GetOutsetsBlur) {
   FilterOperations ops;
   ops.Append(FilterOperation::CreateBlurFilter(20));
   int top, right, bottom, left;
   top = right = bottom = left = 0;
   ops.GetOutsets(&top, &right, &bottom, &left);
   EXPECT_EQ(60, top);
   EXPECT_EQ(60, right);
   EXPECT_EQ(60, bottom);
   EXPECT_EQ(60, left);
 }
 
 TEST(FilterOperationsTest, MapRectBlur) {
   FilterOperations ops;
   ops.Append(FilterOperation::CreateBlurFilter(20));
   EXPECT_EQ(gfx::Rect(-60, -60, 130, 130),
             ops.MapRect(gfx::Rect(0, 0, 10, 10), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(-120, -120, 260, 260),
+            ops.MapRect(gfx::Rect(0, 0, 20, 20), MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(gfx::Rect(-60, -70, 130, 130),
+            ops.MapRect(gfx::Rect(0, -10, 10, 10), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, MapRectReverseBlur) {
   FilterOperations ops;
   ops.Append(FilterOperation::CreateBlurFilter(20));
   EXPECT_EQ(gfx::Rect(-60, -60, 130, 130),
             ops.MapRectReverse(gfx::Rect(0, 0, 10, 10), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(-120, -120, 260, 260),
+            ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(
+      gfx::Rect(-60, -70, 130, 130),
+      ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, GetOutsetsDropShadowReferenceFilter) {
   // TODO(hendrikw): We need to make outsets for reference filters be in line
   // with non-reference filters. See crbug.com/523534
   FilterOperations ops;
   ops.Append(
       FilterOperation::CreateReferenceFilter(SkDropShadowImageFilter::Make(
           SkIntToScalar(3), SkIntToScalar(8), SkIntToScalar(4),
           SkIntToScalar(9), SK_ColorBLACK,
@@ skipping 12 matching lines @@
 TEST(FilterOperationsTest, MapRectDropShadowReferenceFilter) {
   FilterOperations ops;
   ops.Append(
       FilterOperation::CreateReferenceFilter(SkDropShadowImageFilter::Make(
           SkIntToScalar(3), SkIntToScalar(8), SkIntToScalar(4),
           SkIntToScalar(9), SK_ColorBLACK,
           SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
           nullptr)));
   EXPECT_EQ(gfx::Rect(-9, -19, 34, 64),
             ops.MapRect(gfx::Rect(0, 0, 10, 10), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(-18, -38, 68, 128),
+            ops.MapRect(gfx::Rect(0, 0, 20, 20), MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(gfx::Rect(-9, -45, 34, 64),
+            ops.MapRect(gfx::Rect(0, -10, 10, 10), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, MapRectReverseDropShadowReferenceFilter) {
   FilterOperations ops;
   ops.Append(
       FilterOperation::CreateReferenceFilter(SkDropShadowImageFilter::Make(
           SkIntToScalar(3), SkIntToScalar(8), SkIntToScalar(4),
           SkIntToScalar(9), SK_ColorBLACK,
           SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
           nullptr)));
   EXPECT_EQ(gfx::Rect(-15, -35, 34, 64),
             ops.MapRectReverse(gfx::Rect(0, 0, 10, 10), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(-30, -70, 68, 128),
+            ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(
+      gfx::Rect(-15, -29, 34, 64),
+      ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, MapRectOffsetReferenceFilter) {
   sk_sp<SkImageFilter> filter = SkOffsetImageFilter::Make(30, 40, nullptr);
   FilterOperations ops;
   ops.Append(FilterOperation::CreateReferenceFilter(std::move(filter)));
   EXPECT_EQ(gfx::Rect(30, 40, 10, 10),
             ops.MapRect(gfx::Rect(0, 0, 10, 10), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(60, 80, 20, 20),
+            ops.MapRect(gfx::Rect(0, 0, 20, 20), MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(gfx::Rect(30, -50, 10, 10),
+            ops.MapRect(gfx::Rect(0, -10, 10, 10), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, MapRectReverseOffsetReferenceFilter) {
   sk_sp<SkImageFilter> filter = SkOffsetImageFilter::Make(30, 40, nullptr);
   FilterOperations ops;
   ops.Append(FilterOperation::CreateReferenceFilter(std::move(filter)));
   EXPECT_EQ(gfx::Rect(-30, -40, 10, 10),
             ops.MapRectReverse(gfx::Rect(0, 0, 10, 10), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(-60, -80, 20, 20),
+            ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(
+      gfx::Rect(-30, 30, 10, 10),
+      ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, MapRectCombineNonCommutative) {
   // Offsets by 100px in each axis, then scales the resulting image by 2.
   FilterOperations ops;
   ops.Append(FilterOperation::CreateReferenceFilter(
       SkOffsetImageFilter::Make(100, 100, nullptr)));
   SkMatrix scaleMatrix;
   scaleMatrix.setScale(2, 2);
   ops.Append(
       FilterOperation::CreateReferenceFilter(SkImageFilter::MakeMatrixFilter(
           scaleMatrix, kNone_SkFilterQuality, nullptr)));
 
   EXPECT_EQ(gfx::Rect(200, 200, 20, 20),
             ops.MapRect(gfx::Rect(10, 10), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(400, 400, 40, 40),
+            ops.MapRect(gfx::Rect(20, 20), MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(gfx::Rect(200, -220, 20, 20),
+            ops.MapRect(gfx::Rect(0, -10, 10, 10), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, MapRectReverseCombineNonCommutative) {
   // Offsets by 100px in each axis, then scales the resulting image by 2.
   FilterOperations ops;
   ops.Append(FilterOperation::CreateReferenceFilter(
       SkOffsetImageFilter::Make(100, 100, nullptr)));
   SkMatrix scaleMatrix;
   scaleMatrix.setScale(2, 2);
   ops.Append(
       FilterOperation::CreateReferenceFilter(SkImageFilter::MakeMatrixFilter(
           scaleMatrix, kNone_SkFilterQuality, nullptr)));
 
   EXPECT_EQ(gfx::Rect(10, 10),
             ops.MapRectReverse(gfx::Rect(200, 200, 20, 20), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(20, 20), ops.MapRectReverse(gfx::Rect(400, 400, 40, 40),
+                                                  MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(
+      gfx::Rect(0, -10, 10, 10),
+      ops.MapRectReverse(gfx::Rect(200, -220, 20, 20), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, GetOutsetsNullReferenceFilter) {
   FilterOperations ops;
   ops.Append(FilterOperation::CreateReferenceFilter(nullptr));
 
   int top, right, bottom, left;
   top = right = bottom = left = 0;
   ops.GetOutsets(&top, &right, &bottom, &left);
   EXPECT_EQ(0, top);
   EXPECT_EQ(0, right);
   EXPECT_EQ(0, bottom);
   EXPECT_EQ(0, left);
 }
 
 TEST(FilterOperationsTest, MapRectNullReferenceFilter) {
   FilterOperations ops;
   ops.Append(FilterOperation::CreateReferenceFilter(nullptr));
   EXPECT_EQ(gfx::Rect(0, 0, 10, 10),
             ops.MapRect(gfx::Rect(0, 0, 10, 10), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
+            ops.MapRect(gfx::Rect(0, 0, 20, 20), MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(gfx::Rect(0, -10, 10, 10),
+            ops.MapRect(gfx::Rect(0, -10, 10, 10), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, MapRectReverseNullReferenceFilter) {
   FilterOperations ops;
   ops.Append(FilterOperation::CreateReferenceFilter(nullptr));
   EXPECT_EQ(gfx::Rect(0, 0, 10, 10),
             ops.MapRectReverse(gfx::Rect(0, 0, 10, 10), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
+            ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(
+      gfx::Rect(0, -10, 10, 10),
+      ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, GetOutsetsDropShadow) {
   FilterOperations ops;
   ops.Append(FilterOperation::CreateDropShadowFilter(gfx::Point(3, 8), 20, 0));
   int top, right, bottom, left;
   top = right = bottom = left = 0;
   ops.GetOutsets(&top, &right, &bottom, &left);
   EXPECT_EQ(52, top);
   EXPECT_EQ(63, right);
   EXPECT_EQ(68, bottom);
   EXPECT_EQ(57, left);
 }
 
 TEST(FilterOperationsTest, MapRectDropShadow) {
   FilterOperations ops;
   ops.Append(FilterOperation::CreateDropShadowFilter(gfx::Point(3, 8), 20, 0));
   EXPECT_EQ(gfx::Rect(-57, -52, 130, 130),
             ops.MapRect(gfx::Rect(0, 0, 10, 10), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(-114, -104, 260, 260),
+            ops.MapRect(gfx::Rect(0, 0, 20, 20), MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(gfx::Rect(-57, -78, 130, 130),
+            ops.MapRect(gfx::Rect(0, -10, 10, 10), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, MapRectReverseDropShadow) {
   FilterOperations ops;
   ops.Append(FilterOperation::CreateDropShadowFilter(gfx::Point(3, 8), 20, 0));
   EXPECT_EQ(gfx::Rect(-63, -68, 130, 130),
             ops.MapRectReverse(gfx::Rect(0, 0, 10, 10), SkMatrix::I()));
+  EXPECT_EQ(gfx::Rect(-126, -136, 260, 260),
+            ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), MakeScaleMatrix(2, 2)));
+  EXPECT_EQ(
+      gfx::Rect(-63, -62, 130, 130),
+      ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), MakeScaleMatrix(1, -1)));
 }
 
 TEST(FilterOperationsTest, GetOutsetsDropShadowDoesNotContract) {
   // Even with a drop-shadow, the original content is still drawn. Thus the
   // content bounds are never contracted due to a drop-shadow.
   FilterOperations ops;
   ops.Append(FilterOperation::CreateDropShadowFilter(gfx::Point(3, 8), 0, 0));
   int top, right, bottom, left;
   top = right = bottom = left = 0;
   ops.GetOutsets(&top, &right, &bottom, &left);
@@ skipping 679 matching lines @@
   blended = to.Blend(from, -0.75);
   EXPECT_EQ(to, blended);
   blended = to.Blend(from, 0.75);
   EXPECT_EQ(to, blended);
   blended = to.Blend(from, 1.5);
   EXPECT_EQ(to, blended);
 }
 
 }  // namespace
 }  // namespace cc