Don't invalidate paint on background image change if it's obscured

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 1463 matching lines @@
 }
 
 void LayoutBox::paintMask(const PaintInfo& paintInfo, const LayoutPoint& paintOffset) const
 {
     BoxPainter(*this).paintMask(paintInfo, paintOffset);
 }
 
 void LayoutBox::imageChanged(WrappedImagePtr image, const IntRect*)
 {
     // TODO(chrishtr): support PaintInvalidationDelayedFull for animated border images.
-    if ((style()->borderImage().image() && style()->borderImage().image()->data() == image)
-        || (style()->maskBoxImage().image() && style()->maskBoxImage().image()->data() == image)) {
+    if ((styleRef().borderImage().image() && styleRef().borderImage().image()->data() == image)
+        || (styleRef().maskBoxImage().image() && styleRef().maskBoxImage().image()->data() == image)) {
         setShouldDoFullPaintInvalidation();
-        return;
+    } else {
+        for (const FillLayer* layer = &styleRef().maskLayers(); layer; layer = layer->next()) {
+            if (layer->image() && image == layer->image()->data()) {
+                setShouldDoFullPaintInvalidation();
+                break;
+            }
+        }
+    }
+
+    if (!isDocumentElement() && !backgroundStolenForBeingBody()) {
+        for (const FillLayer* layer = &styleRef().backgroundLayers(); layer; layer = layer->next()) {
+            if (layer->image() && image == layer->image()->data()) {
+                invalidateBackgroundObscurationStatus();
+                bool maybeAnimated = layer->image()->cachedImage() && layer->image()->cachedImage()->getImage() && layer->image()->cachedImage()->getImage()->maybeAnimated();
+                if (maybeAnimated)
+                    setMayNeedPaintInvalidationAnimatgedBackgroundImage();
+                else
+                    setShouldDoFullPaintInvalidation();
+                break;
+            }
+        }
     }
 
     ShapeValue* shapeOutsideValue = style()->shapeOutside();
     if (!frameView()->isInPerformLayout() && isFloating() && shapeOutsideValue && shapeOutsideValue->image() && shapeOutsideValue->image()->data() == image) {
         ShapeOutsideInfo& info = ShapeOutsideInfo::ensureInfo(*this);
         if (!info.isComputingShape()) {
             info.markShapeAsDirty();
             markShapeOutsideDependentsForLayout();
         }
     }
-
-    if (!invalidatePaintOfLayerRectsForImage(image, style()->backgroundLayers(), true))

[chrishtr, 2016/08/09 22:07:54]

Why is it ok to delete this?

[Xianzhu, 2016/08/09 23:07:14]

Line 1499 became line 1487-1494. Line 1500 became line 1496-1507. Expanded
because the two calls had few common lines and the bool parameter control the
behavior of the function looked not good.

The conditions are made independent because one image may be shared between mask
and background. Even if we setShouldDoFullPaintInvalidation for mask image, we
still need to invalidateBackgroundObscurationStatus if the image is used in
background.

-        invalidatePaintOfLayerRectsForImage(image, style()->maskLayers(), false);
 }
 
 ResourcePriority LayoutBox::computeResourcePriority() const
 {
     LayoutRect viewBounds = viewRect();
     LayoutRect objectBounds = LayoutRect(absoluteContentBox());
 
     // The object bounds might be empty right now, so intersects will fail since it doesn't deal
     // with empty rects. Use LayoutRect::contains in that case.
     bool isVisible;
     if (!objectBounds.isEmpty())
         isVisible =  viewBounds.intersects(objectBounds);
     else
         isVisible = viewBounds.contains(objectBounds);
 
     LayoutRect screenRect;
     if (!objectBounds.isEmpty()) {
         screenRect = viewBounds;
         screenRect.intersect(objectBounds);
     }
 
     int screenArea = 0;
     if (!screenRect.isEmpty() && isVisible)
         screenArea = static_cast<uint32_t>(screenRect.width() * screenRect.height());
     return ResourcePriority(isVisible ? ResourcePriority::Visible : ResourcePriority::NotVisible, screenArea);
 }
 
-bool LayoutBox::invalidatePaintOfLayerRectsForImage(WrappedImagePtr image, const FillLayer& layers, bool drawingBackground)
-{
-    if (drawingBackground && (isDocumentElement() || backgroundStolenForBeingBody()))
-        return false;
-    for (const FillLayer* curLayer = &layers; curLayer; curLayer = curLayer->next()) {
-        if (curLayer->image() && image == curLayer->image()->data()) {
-            bool maybeAnimated = curLayer->image()->cachedImage() && curLayer->image()->cachedImage()->getImage() && curLayer->image()->cachedImage()->getImage()->maybeAnimated();
-            if (maybeAnimated && drawingBackground)
-                setShouldDoFullPaintInvalidation(PaintInvalidationDelayedFull);
-            else
-                setShouldDoFullPaintInvalidation();
-
-            if (drawingBackground)
-                invalidateBackgroundObscurationStatus();
-            return true;
-        }
-    }
-    return false;
-}
-
-bool LayoutBox::intersectsVisibleViewport()
+bool LayoutBox::intersectsVisibleViewport() const
 {
     LayoutRect rect = visualOverflowRect();
     LayoutView* layoutView = view();
     while (layoutView->frame()->ownerLayoutObject())
         layoutView = layoutView->frame()->ownerLayoutObject()->view();
     mapToVisualRectInAncestorSpace(layoutView, rect);
     return rect.intersects(LayoutRect(layoutView->frameView()->getScrollableArea()->visibleContentRectDouble()));
 }
 
 PaintInvalidationReason LayoutBox::invalidatePaintIfNeeded(const PaintInvalidationState& paintInvalidationState)
 {
     if (hasBoxDecorationBackground()
         // We also paint overflow controls in background phase.
         || (hasOverflowClip() && getScrollableArea()->hasOverflowControls())) {
         PaintLayer& layer = paintInvalidationState.paintingLayer();
         if (layer.layoutObject() != this)
             layer.setNeedsPaintPhaseDescendantBlockBackgrounds();
     }
 
-    PaintInvalidationReason fullInvalidationReason = fullPaintInvalidationReason();
-    // If the current paint invalidation reason is PaintInvalidationDelayedFull, then this paint invalidation can delayed if the
-    // LayoutBox in question is not on-screen. The logic to decide whether this is appropriate exists at the site of the original
-    // paint invalidation that chose PaintInvalidationDelayedFull.
-    if (fullInvalidationReason == PaintInvalidationDelayedFull) {
-        if (!intersectsVisibleViewport())
-            return PaintInvalidationDelayedFull;
-
-        // Reset state back to regular full paint invalidation if the object is onscreen.
-        setShouldDoFullPaintInvalidation(PaintInvalidationFull);
-    }
-
     PaintInvalidationReason reason = LayoutBoxModelObject::invalidatePaintIfNeeded(paintInvalidationState);
 
     if (PaintLayerScrollableArea* area = getScrollableArea())
         area->invalidatePaintOfScrollControlsIfNeeded(paintInvalidationState);
 
     // This is for the next invalidatePaintIfNeeded so must be at the end.
     savePreviousBoxSizesIfNeeded();
     return reason;
 }
 
@@ skipping 2381 matching lines @@
         if (scrollableArea->hasVerticalScrollbar() && !scrollableArea->layerForVerticalScrollbar())
             return true;
     }
     return false;
 }
 
 PaintInvalidationReason LayoutBox::getPaintInvalidationReason(const PaintInvalidationState& paintInvalidationState,
     const LayoutRect& oldBounds, const LayoutPoint& oldLocation, const LayoutRect& newBounds, const LayoutPoint& newLocation) const
 {
     PaintInvalidationReason invalidationReason = LayoutBoxModelObject::getPaintInvalidationReason(paintInvalidationState, oldBounds, oldLocation, newBounds, newLocation);
-    if (isFullPaintInvalidationReason(invalidationReason))
+
+    if (isFullPaintInvalidationReason(invalidationReason) && invalidationReason != PaintInvalidationDelayedFull)
         return invalidationReason;
 
+    if (mayNeedPaintInvalidationAnimatedBackgroundImage() && !backgroundIsKnownToBeObscured())
+        invalidationReason = PaintInvalidationDelayedFull;
+
+    // If the current paint invalidation reason is PaintInvalidationDelayedFull, then this paint invalidation can delayed if the
+    // LayoutBox in question is not on-screen. The logic to decide whether this is appropriate exists at the site of the original
+    // paint invalidation that chose PaintInvalidationDelayedFull.
+    if (invalidationReason == PaintInvalidationDelayedFull) {
+        // Do regular full paint invalidation if the object is onscreen.
+        return intersectsVisibleViewport() ? PaintInvalidationFull : PaintInvalidationDelayedFull;
+    }
+
     if (isLayoutView()) {
         const LayoutView* layoutView = toLayoutView(this);
         // In normal compositing mode, root background doesn't need to be invalidated for
         // box changes, because the background always covers the whole document rect
         // and clipping is done by compositor()->m_containerLayer. Also the scrollbars
         // are always composited. There are no other box decoration on the LayoutView thus
         // we can safely exit here.
         if (layoutView->usesCompositing() && (!document().settings() || !document().settings()->rootLayerScrolls()))
             return invalidationReason;
     }
@@ skipping 993 matching lines @@
         m_rareData->m_snapAreas->remove(&snapArea);
     }
 }
 
 SnapAreaSet* LayoutBox::snapAreas() const
 {
     return m_rareData ? m_rareData->m_snapAreas.get() : nullptr;
 }
 
 } // namespace blink