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) {
+        // Apply filter and reflection outsets between this object and container or ancestor.
+        for (LayoutObject* parent = this->parent(); parent && parent != container; parent = parent->parent()) {
+            if (parent->isBox())
+                toLayoutBox(parent)->inflateVisualRectForReflectionAndFilter(rect);

[chrishtr, 2016/05/02 22:16:30]

Doesn't |rect| need to be in the space of parent| for this to be valid?

[Xianzhu, 2016/05/02 22:21:48]

Not necessary. The function just inflate the rect by maximum outsets of the
filter effect. The result rect covers all the affected area of this object with
the ancestor filter applied.

[chrishtr, 2016/05/02 22:51:50]

But if the rect is not originally in the space of the box, how can these outsets
possibly be applied correctly?

+            if (parent == ancestor) {
+                // We meet ancestor before container.
+                ASSERT(ancestorSkipped);
+                break;
+            }
+        }
+    }
+
     // 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