Handle negative scale in SkDropShadowImageFilter::onFilterNodeBounds.

tests/ImageFilterTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
@@ skipping 838 matching lines @@
     sk_sp<SkImageFilter> filter1(SkDilateImageFilter::Make(2, 2, nullptr));
     sk_sp<SkImageFilter> filter2(make_drop_shadow(std::move(filter1)));
 
     SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
     SkIRect expectedBounds = SkIRect::MakeXYWH(-132, -132, 234, 234);
     bounds = filter2->filterBounds(bounds, SkMatrix::I());
 
     REPORTER_ASSERT(reporter, bounds == expectedBounds);
 }
 
+DEF_TEST(ImageFilterScaledBlurRadius, reporter) {
+    // Each blur should spread 3*sigma, so 3 for the blur and 30 for the shadow
+    // (before the CTM). Bounds should be computed correctly in the presence of
+    // a (possibly negative) scale.
+    sk_sp<SkImageFilter> blur(make_blur(nullptr));
+    sk_sp<SkImageFilter> dropShadow(make_drop_shadow(nullptr));
+    {
+        // Uniform scale by 2.
+        SkMatrix scaleMatrix;
+        scaleMatrix.setScale(2, 2);
+        SkIRect bounds = SkIRect::MakeLTRB(0, 0, 200, 200);
+
+        SkIRect expectedBlurBounds = SkIRect::MakeLTRB(-6, -6, 206, 206);
+        SkIRect blurBounds = blur->filterBounds(
+            bounds, scaleMatrix, SkImageFilter::kForward_MapDirection);
+        REPORTER_ASSERT(reporter, blurBounds == expectedBlurBounds);
+        SkIRect reverseBlurBounds = blur->filterBounds(
+            bounds, scaleMatrix, SkImageFilter::kReverse_MapDirection);
+        REPORTER_ASSERT(reporter, reverseBlurBounds == expectedBlurBounds);
+
+        SkIRect expectedShadowBounds = SkIRect::MakeLTRB(0, 0, 460, 460);
+        SkIRect shadowBounds = dropShadow->filterBounds(
+            bounds, scaleMatrix, SkImageFilter::kForward_MapDirection);
+        REPORTER_ASSERT(reporter, shadowBounds == expectedShadowBounds);
+        SkIRect expectedReverseShadowBounds =
+            SkIRect::MakeLTRB(-260, -260, 200, 200);
+        SkIRect reverseShadowBounds = dropShadow->filterBounds(
+            bounds, scaleMatrix, SkImageFilter::kReverse_MapDirection);
+        REPORTER_ASSERT(reporter,
+            reverseShadowBounds == expectedReverseShadowBounds);
+    }
+    {
+        // Vertical flip.
+        SkMatrix scaleMatrix;
+        scaleMatrix.setScale(1, -1);
+        SkIRect bounds = SkIRect::MakeLTRB(0, -100, 100, 0);
+
+        SkIRect expectedBlurBounds = SkIRect::MakeLTRB(-3, -103, 103, 3);
+        SkIRect blurBounds = blur->filterBounds(
+            bounds, scaleMatrix, SkImageFilter::kForward_MapDirection);
+        REPORTER_ASSERT(reporter, blurBounds == expectedBlurBounds);
+        SkIRect reverseBlurBounds = blur->filterBounds(
+            bounds, scaleMatrix, SkImageFilter::kReverse_MapDirection);
+        REPORTER_ASSERT(reporter, reverseBlurBounds == expectedBlurBounds);
+
+        SkIRect expectedShadowBounds = SkIRect::MakeLTRB(0, -230, 230, 0);
+        SkIRect shadowBounds = dropShadow->filterBounds(
+            bounds, scaleMatrix, SkImageFilter::kForward_MapDirection);
+        REPORTER_ASSERT(reporter, shadowBounds == expectedShadowBounds);
+        SkIRect expectedReverseShadowBounds =
+            SkIRect::MakeLTRB(-130, -100, 100, 130);
+        SkIRect reverseShadowBounds = dropShadow->filterBounds(
+            bounds, scaleMatrix, SkImageFilter::kReverse_MapDirection);
+        REPORTER_ASSERT(reporter,
+            reverseShadowBounds == expectedReverseShadowBounds);
+    }
+}
+
 DEF_TEST(ImageFilterComposedBlurFastBounds, reporter) {
     sk_sp<SkImageFilter> filter1(make_blur(nullptr));
     sk_sp<SkImageFilter> filter2(make_blur(nullptr));
     sk_sp<SkImageFilter> composedFilter(SkComposeImageFilter::Make(std::move(filter1),
                                                                    std::move(filter2)));
 
     SkRect boundsSrc = SkRect::MakeWH(SkIntToScalar(100), SkIntToScalar(100));
     SkRect expectedBounds = SkRect::MakeXYWH(
         SkIntToScalar(-6), SkIntToScalar(-6), SkIntToScalar(112), SkIntToScalar(112));
     SkRect boundsDst = composedFilter->computeFastBounds(boundsSrc);
@@ skipping 927 matching lines @@
         { SkColorFilterImageFilter::Make(cf, blif), false },
         { SkMergeImageFilter::Make(cfif, blif),     false },
         { SkComposeImageFilter::Make(blif, cfif),   false },
     };
     
     for (const auto& rec : recs) {
         const bool canHandle = rec.fFilter->canHandleComplexCTM();
         REPORTER_ASSERT(reporter, canHandle == rec.fExpectCanHandle);
     }
 }