Ensure filter and reflection outsets are applied on paint invalidation rect

third_party/WebKit/Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 1953 matching lines @@
         layer->updateDescendantDependentFlags();
         if (layer->subtreeIsInvisible())
             return LayoutRect();
     }
 
     return visualOverflowRect();
 }
 
 bool LayoutBox::mapToVisualRectInAncestorSpace(const LayoutBoxModelObject* ancestor, LayoutRect& rect, VisualRectFlags visualRectFlags) const
 {
-    // We need to inflate the paint invalidation rect before we use paintInvalidationState,
-    // else we would forget to inflate it for the current layoutObject. FIXME: If these were
-    // included into the visual overflow for paint invalidation, we wouldn't have this issue.
-    inflatePaintInvalidationRectForReflectionAndFilter(rect);
+    inflateVisualRectForReflectionAndFilter(rect);
 
     if (ancestor == this) {
         // The final rect returned is always in the physical coordinate space of the ancestor.
         flipForWritingMode(rect);
         return true;
     }
 
     bool ancestorSkipped;
-    LayoutObject* container = this->container(ancestor, &ancestorSkipped);
+    bool filterOrReflectionSkipped;
+    LayoutObject* container = this->container(ancestor, &ancestorSkipped, &filterOrReflectionSkipped);
     if (!container)
         return true;
 
+    if (filterOrReflectionSkipped) {

[chrishtr, 2016/05/03 17:31:38]

Please factor the contents of this if into a helper method.

[Xianzhu, 2016/05/03 18:00:24]

Done.

+        // Apply filter and reflection outsets between this object and container or ancestor.

[jbroman, 2016/05/03 17:30:48]

Suggest not phrasing this as "outsets". Not all filters are blur-like.

For instance, an offset filter shifts the image (while that _can_ be viewed as
an outset, it's pretty awkward to as it isn't an expansion). And with
reflections it's even more different (in particular, it's sensitive to the
coordinate space being used).

Characterizing this the way Blink is trending toward -- and the way Skia does --
is better: there's a function mapping rectangles through filters (forwards or
backwards, depending on the case).

[Xianzhu, 2016/05/03 18:00:24]

Thanks for the info. Done.

+        LayoutSize offsetFromContainer = this->offsetFromContainer(container);
+        rect.move(offsetFromContainer);
+        for (LayoutObject* parent = this->parent(); parent && parent != container; parent = parent->parent()) {
+            if (parent->isBox()) {
+                // If the ancestor is below o, then we need to map the rect into ancestor's coordinates.
+                LayoutSize parentOffset = parent->offsetFromAncestorContainer(container);

[chrishtr, 2016/05/03 17:31:38]

This is expensive, but I suppose this whole situation is quite rare, so ok?

[Xianzhu, 2016/05/03 18:00:24]

I believe it's rare because no layout test covered this, and no bug report for
it.

+                rect.move(-parentOffset);
+                toLayoutBox(parent)->inflateVisualRectForReflectionAndFilter(rect);
+                rect.move(parentOffset);
+            }
+            if (parent == ancestor) {
+                // We meet ancestor before container.
+                ASSERT(ancestorSkipped);
+                break;
+            }
+        }
+        rect.move(-offsetFromContainer);
+    }
+
     // The rect we compute at each step is shifted by our x/y offset in the parent container's coordinate space.
     // Only when we cross a writing mode boundary will we have to possibly flipForWritingMode (to convert into a more
     // appropriate offset corner for the enclosing container).
     if (isWritingModeRoot()) {
         flipForWritingMode(rect);
         // Then flip rect currently in physical direction to container's block direction.
         if (container->styleRef().isFlippedBlocksWritingMode())
             rect.setX(m_frameRect.width() - rect.maxX());
     }
 
@@ skipping 36 matching lines @@
             toLayoutView(container)->adjustOffsetForFixedPosition(rect);
         return true;
     }
 
     if (container->isLayoutView())
         return toLayoutView(container)->mapToVisualRectInAncestorSpace(ancestor, rect, position == FixedPosition ? IsFixed : 0, visualRectFlags);
     else
         return container->mapToVisualRectInAncestorSpace(ancestor, rect, visualRectFlags);
 }
 
-void LayoutBox::inflatePaintInvalidationRectForReflectionAndFilter(LayoutRect& paintInvalidationRect) const
+void LayoutBox::inflateVisualRectForReflectionAndFilter(LayoutRect& paintInvalidationRect) const
 {
     if (!RuntimeEnabledFeatures::cssBoxReflectFilterEnabled() && hasReflection())
         paintInvalidationRect.unite(reflectedRect(paintInvalidationRect));
 
     if (layer() && layer()->hasFilterInducingProperty())
         paintInvalidationRect = layer()->mapLayoutRectForFilter(paintInvalidationRect);
 }
 
 void LayoutBox::invalidatePaintForOverhangingFloats(bool)
 {
@@ skipping 2694 matching lines @@
 
 void LayoutBox::clearPercentHeightDescendants()
 {
     for (LayoutObject* curr = slowFirstChild(); curr; curr = curr->nextInPreOrder(this)) {
         if (curr->isBox())
             toLayoutBox(curr)->removeFromPercentHeightContainer();
     }
 }
 
 } // namespace blink