cc: Implement and use FilterOperations::MapRectReverse for mapping backdrop bounding box.

cc/output/filter_operation.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 <algorithm>
 
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
@@ skipping 297 matching lines @@
           value->AppendInteger(it.rect().y());
           value->AppendInteger(it.rect().width());
           value->AppendInteger(it.rect().height());
         }
         value->EndArray();
       }
       break;
   }
 }
 
-static SkVector MapStdDeviation(float std_deviation, const SkMatrix& matrix) {
+namespace {
+
+enum class MapDirection { FORWARD, REVERSE };

[Stephen White, 2016/06/08 22:05:23]

Why not just use SkImageFilter::MapDirection?

[jbroman, 2016/06/13 14:57:33]

Sure, done. (No real reason, other than "it doesn't always call into Skia". It's
totally not a big deal because this is all in an anonymous namespace anyhow.)

+
+SkVector MapStdDeviation(float std_deviation, const SkMatrix& matrix) {
   // Corresponds to SpreadForStdDeviation in filter_operations.cc.
   SkVector sigma = SkVector::Make(std_deviation, std_deviation);
   matrix.mapVectors(&sigma, 1);
   return sigma * SkIntToScalar(3);
 }
 
-gfx::Rect FilterOperation::MapRect(const gfx::Rect& rect,
-                                   const SkMatrix& matrix) const {
-  switch (type_) {
+gfx::Rect MapRectInternal(const FilterOperation& op,
+                          const gfx::Rect& rect,
+                          const SkMatrix& matrix,
+                          MapDirection direction) {
+  switch (op.type()) {
     case FilterOperation::BLUR: {
-      SkVector spread = MapStdDeviation(amount(), matrix);
+      SkVector spread = MapStdDeviation(op.amount(), matrix);
+      float spreadX = std::abs(spread.x());
+      float spreadY = std::abs(spread.y());
       gfx::Rect result = rect;
-      result.Inset(-spread.x(), -spread.y(), -spread.x(), -spread.y());
+      result.Inset(-spreadX, -spreadY, -spreadX, -spreadY);
       return result;
     }
     case FilterOperation::DROP_SHADOW: {
-      SkVector spread = MapStdDeviation(amount(), matrix);
+      SkVector spread = MapStdDeviation(op.amount(), matrix);
+      float spreadX = std::abs(spread.x());
+      float spreadY = std::abs(spread.y());
       gfx::Rect result = rect;
-      result.Inset(-spread.x(), -spread.y(), -spread.x(), -spread.y());
-      result += drop_shadow_offset().OffsetFromOrigin();
+      result.Inset(-spreadX, -spreadY, -spreadX, -spreadY);
+
+      gfx::Vector2d drop_shadow_offset =
+          op.drop_shadow_offset().OffsetFromOrigin();
+      if (direction == MapDirection::FORWARD)
+        result += drop_shadow_offset;
+      else
+        result -= drop_shadow_offset;
+
       result.Union(rect);
       return result;
     }
     case FilterOperation::REFERENCE: {
-      if (!image_filter())
+      if (!op.image_filter())
         return rect;
       SkIRect in_rect = gfx::RectToSkIRect(rect);
-      SkIRect out_rect = image_filter()->filterBounds(
-          in_rect, matrix, SkImageFilter::kForward_MapDirection);
+      SkIRect out_rect = op.image_filter()->filterBounds(
+          in_rect, matrix, direction == MapDirection::FORWARD
+                               ? SkImageFilter::kForward_MapDirection
+                               : SkImageFilter::kReverse_MapDirection);
       return gfx::SkIRectToRect(out_rect);
     }
     default:
       return rect;
   }
 }
 
+}  // namespace
+
+gfx::Rect FilterOperation::MapRect(const gfx::Rect& rect,
+                                   const SkMatrix& matrix) const {
+  return MapRectInternal(*this, rect, matrix, MapDirection::FORWARD);
+}
+
+gfx::Rect FilterOperation::MapRectReverse(const gfx::Rect& rect,
+                                          const SkMatrix& matrix) const {
+  return MapRectInternal(*this, rect, matrix, MapDirection::REVERSE);
+}
+
 }  // namespace cc