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 1951 matching lines @@
     if (style()->visibility() != VISIBLE) {
         PaintLayer* layer = enclosingLayer();
         layer->updateDescendantDependentFlags();
         if (layer->subtreeIsInvisible())
             return LayoutRect();
     }
 
     return visualOverflowRect();
 }
 
+void LayoutBox::inflateVisualRectForReflectionAndFilterUnderContainer(LayoutRect& rect, const LayoutObject& container, const LayoutBoxModelObject* ancestorToStopAt) const
+{
+    // Apply visual overflow caused by reflections and filters defined on objects between this object
+    // and container (not included) or ancestorToStopAt (included).
+    LayoutSize offsetFromContainer = this->offsetFromContainer(&container);
+    rect.move(offsetFromContainer);
+    for (LayoutObject* parent = this->parent(); parent && parent != container; parent = parent->parent()) {
+        if (parent->isBox()) {
+            // Convert rect into coordinate space of parent to apply parent's reflection and filter.
+            LayoutSize parentOffset = parent->offsetFromAncestorContainer(&container);
+            rect.move(-parentOffset);
+            toLayoutBox(parent)->inflateVisualRectForReflectionAndFilter(rect);
+            rect.move(parentOffset);
+        }
+        if (parent == ancestorToStopAt)
+            break;
+    }
+    rect.move(-offsetFromContainer);
+}
+
 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)
+        inflateVisualRectForReflectionAndFilterUnderContainer(rect, *container, ancestor);
+
     // 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