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 709 matching lines @@
         break;
     case ContentFillBox:
         return contentBoxRect();
         break;
     default:
         break;
     }
     return LayoutRect();
 }
 
+LayoutRect LayoutBox::opaqueBackgroundClipRect() const
+{
+    EFillBox backgroundClip = TextFillBox;
+    // Find the largest opaque background clip rect.
+    // TODO(flackr): Unify with the above method.
+    if (const FillLayer* current = &(style()->backgroundLayers())) {
+        do {
+            const FillLayer* cur = current;
+            current = current->next();
+            if (cur->blendMode() != WebBlendModeNormal || cur->composite() != CompositeSourceOver)
+                continue;
+            // Check if the image or color has alpha.
+            if (const StyleImage* image = cur->image()) {
+                if (!image->knownToBeOpaque(*this))
+                    continue;
+            } else {
+                Color backgroundColor = resolveColor(CSSPropertyBackgroundColor);
+                if (backgroundColor.hasAlpha())
+                    continue;
+            }
+            EFillBox currentClip = cur->clip();
+            // Adjust clip if attachment is local.
+            if (currentClip == BorderFillBox && cur->attachment() == LocalBackgroundAttachment)
+                currentClip = PaddingFillBox;
+            // TODO(flackr): Expose and use clipMax method from FillLayer.cpp.
+            if (currentClip < backgroundClip)
+                backgroundClip = currentClip;
+        } while (current);
+    }
+    switch (backgroundClip) {
+    case BorderFillBox:
+        return borderBoxRect();
+        break;
+    case PaddingFillBox:
+        return paddingBoxRect();
+        break;
+    case ContentFillBox:
+        return contentBoxRect();
+        break;
+    default:
+        break;
+    }
+    return LayoutRect();
+}
+
 void LayoutBox::addOutlineRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset, IncludeBlockVisualOverflowOrNot) const
 {
     rects.append(LayoutRect(additionalOffset, size()));
 }
 
 bool LayoutBox::canResize() const
 {
     // We need a special case for <iframe> because they never have
     // hasOverflowClip(). However, they do "implicitly" clip their contents, so
     // we want to allow resizing them also.
@@ skipping 648 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 opaqueBackgroundClipRect().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() != VISIBLE || childStyle.shapeOutside())
         return false;
     if (childBox.size().isZero())
@@ skipping 354 matching lines @@
 }
 
 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,

[Stephen Chennney, 2016/07/27 22:33:36]

The previous method has the comment outside the block, and this one has it
inside. Let's make them consistent while we're modifying them.

[flackr, 2016/07/28 14:39:20]

Done.

         // and may itself also be fixed position. So propagate 'fixed' up only if this box is fixed position.
         mode &= ~IsFixed;
     } else if (isFixedPos) {
         mode |= IsFixed;
     }
 
     LayoutBoxModelObject::mapAncestorToLocal(ancestor, transformState, mode);
 }
 
 LayoutSize LayoutBox::offsetFromContainer(const LayoutObject* o) const
@@ skipping 3181 matching lines @@
         m_rareData->m_snapAreas->remove(&snapArea);
     }
 }
 
 SnapAreaSet* LayoutBox::snapAreas() const
 {
     return m_rareData ? m_rareData->m_snapAreas.get() : nullptr;
 }
 
 } // namespace blink