Paint local attachment backgrounds into composited scrolling contents layer

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 689 matching lines @@
     offset.move(absPos.x(), absPos.y());
     return toIntSize(offset);
 }
 
 FloatQuad LayoutBox::absoluteContentQuad() const
 {
     LayoutRect rect = contentBoxRect();
     return localToAbsoluteQuad(FloatRect(rect));
 }
 
-LayoutRect LayoutBox::backgroundClipRect() const
+LayoutRect LayoutBox::backgroundRect(BackgroundRectType rectType) const
 {
-    // TODO(flackr): Check for the maximum background clip rect.
-    switch (style()->backgroundClip()) {
+    EFillBox backgroundBox = TextFillBox;
+    // Find the largest background rect of the given opaqueness.
+    if (const FillLayer* current = &(style()->backgroundLayers())) {
+        do {
+            const FillLayer* cur = current;
+            current = current->next();
+            if (rectType == BackgroundKnownOpaqueRect) {
+                if (cur->blendMode() != WebBlendModeNormal || cur->composite() != CompositeSourceOver)
+                    continue;
+
+                bool layerKnownOpaque = false;
+                // Check if the image or color has alpha.
+                if (const StyleImage* image = cur->image()) {
+                    if (image->knownToBeOpaque(*this))
+                        layerKnownOpaque = true;
+                }
+
+                // The background color is painted into the last layer.
+                if (!cur->next()) {
+                    Color backgroundColor = resolveColor(CSSPropertyBackgroundColor);
+                    if (!backgroundColor.hasAlpha())
+                        layerKnownOpaque = true;
+                }
+
+                // If neither the image nor the color are opaque then skip this layer.
+                if (!layerKnownOpaque)
+                    continue;
+            }
+            EFillBox currentClip = cur->clip();
+            // Restrict clip if attachment is local.
+            if (currentClip == BorderFillBox && cur->attachment() == LocalBackgroundAttachment)
+                currentClip = PaddingFillBox;
+
+            // If we're asking for the clip rect, a content-box clipped fill layer can be scrolled
+            // into the padding box of the overflow container.
+            if (rectType == BackgroundClipRect
+                && currentClip == ContentFillBox && cur->attachment() == LocalBackgroundAttachment) {
+                currentClip = PaddingFillBox;
+            }
+
+            backgroundBox = enclosingFillBox(backgroundBox, currentClip);
+        } while (current);
+    }
+    switch (backgroundBox) {
     case BorderFillBox:
-        // A 'border-box' clip on scrollable elements local attachment is treated as 'padding-box'.
-        // https://www.w3.org/TR/css3-background/#the-background-attachment
-        if (!style()->isOverflowVisible() && style()->backgroundLayers().attachment() == LocalBackgroundAttachment)
-            return paddingBoxRect();
         return borderBoxRect();
         break;
     case PaddingFillBox:
         return paddingBoxRect();
         break;
     case ContentFillBox:
         return contentBoxRect();
         break;
     default:
         break;
@@ skipping 660 matching lines @@
         return false;
     paintedExtent = LayoutRect(geometry.destRect());
     return true;
 }
 
 bool LayoutBox::backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const
 {
     if (isDocumentElement() || backgroundStolenForBeingBody())
         return false;
 
-    Color backgroundColor = resolveColor(CSSPropertyBackgroundColor);
-    if (backgroundColor.hasAlpha())
-        return false;
-
     // If the element has appearance, it might be painted by theme.
     // We cannot be sure if theme paints the background opaque.
     // In this case it is safe to not assume opaqueness.
     // FIXME: May be ask theme if it paints opaque.
     if (style()->hasAppearance())
         return false;
     // FIXME: Check the opaqueness of background images.
 
     // FIXME: Use rounded rect if border radius is present.
     if (style()->hasBorderRadius())
         return false;
     if (hasClipPath())
         return false;
-    // FIXME: The background color clip is defined by the last layer.
-    if (style()->backgroundLayers().next())
+    if (style()->hasBlendMode())
         return false;
-    return backgroundClipRect().contains(localRect);
+    return backgroundRect(BackgroundKnownOpaqueRect).contains(localRect);
 }
 
 static bool isCandidateForOpaquenessTest(const LayoutBox& childBox)
 {
     const ComputedStyle& childStyle = childBox.styleRef();
     if (childStyle.position() != StaticPosition && childBox.containingBlock() != childBox.parent())
         return false;
     if (childStyle.visibility() != EVisibility::Visible || childStyle.shapeOutside())
         return false;
     if (childBox.size().isZero())
@@ skipping 347 matching lines @@
     LayoutBoxModelObject::mapLocalToAncestor(ancestor, transformState, mode);
 }
 
 void LayoutBox::mapAncestorToLocal(const LayoutBoxModelObject* ancestor, TransformState& transformState, MapCoordinatesFlags mode) const
 {
     if (this == ancestor)
         return;
 
     bool isFixedPos = style()->position() == FixedPosition;
 
-    if (style()->canContainFixedPositionObjects() && !isFixedPos) {
-        // If this box has a transform or contains paint, it acts as a fixed position container for fixed descendants,
-        // and may itself also be fixed position. So propagate 'fixed' up only if this box is fixed position.
+    // If this box has a transform or contains paint, it acts as a fixed position container for fixed descendants,
+    // and may itself also be fixed position. So propagate 'fixed' up only if this box is fixed position.
+    if (style()->canContainFixedPositionObjects() && !isFixedPos)
         mode &= ~IsFixed;
-    } else if (isFixedPos) {
+    else if (isFixedPos)
         mode |= IsFixed;
-    }
 
     LayoutBoxModelObject::mapAncestorToLocal(ancestor, transformState, mode);
 }
 
 LayoutSize LayoutBox::offsetFromContainer(const LayoutObject* o) const
 {
     ASSERT(o == container());
 
     LayoutSize offset;
     if (isInFlowPositioned())
@@ skipping 2993 matching lines @@
         m_rareData->m_snapAreas->remove(&snapArea);
     }
 }
 
 SnapAreaSet* LayoutBox::snapAreas() const
 {
     return m_rareData ? m_rareData->m_snapAreas.get() : nullptr;
 }
 
 } // namespace blink