Don't clip contain:paint when requested to ignore clip

third_party/WebKit/Source/core/paint/PaintLayerClipper.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 326 matching lines @@
   foregroundRect = backgroundRect;
 
   LayoutPoint offset;
   if (offsetFromRoot)
     offset = *offsetFromRoot;
   else
     m_layer.convertToLayerCoords(context.rootLayer, offset);
   layerBounds = LayoutRect(offset, LayoutSize(m_layer.size()));
 
   // Update the clip rects that will be passed to child layers.
-  if ((layoutObject.hasOverflowClip() ||
-       layoutObject.styleRef().containsPaint()) &&
-      shouldRespectOverflowClip(context)) {
+  if (shouldClipOverflow(context)) {
     foregroundRect.intersect(
         toLayoutBox(layoutObject)
             .overflowClipRect(offset, context.overlayScrollbarClipBehavior));
     if (layoutObject.styleRef().hasBorderRadius())
       foregroundRect.setHasRadius(true);
 
     // FIXME: Does not do the right thing with columns yet, since we don't yet
     // factor in the individual column boxes as overflow.
 
     // The LayoutView is special since its overflow clipping rect may be larger
@@ skipping 40 matching lines @@
   // Ensure that our parent's clip has been calculated so that we can examine
   // the values.
   if (parentLayer) {
     parentLayer->clipper().getOrCalculateClipRects(context, clipRects);
   } else {
     clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
   }
 
   adjustClipRectsForChildren(layoutObject, clipRects);
 
-  if ((layoutObject.hasOverflowClip() && shouldRespectOverflowClip(context)) ||
+  if (shouldClipOverflow(context) || layoutObject.hasClip() ||
       (layoutObject.isSVGRoot() &&
-       toLayoutSVGRoot(&layoutObject)->shouldApplyViewportClip()) ||
-      layoutObject.hasClip() || layoutObject.styleRef().containsPaint()) {
+       toLayoutSVGRoot(&layoutObject)->shouldApplyViewportClip())) {
     // This offset cannot use convertToLayerCoords, because sometimes our
     // rootLayer may be across some transformed layer boundary, for example, in
     // the PaintLayerCompositor overlapMap, where clipRects are needed in view
     // space.
     applyClipRects(context, layoutObject,
                    roundedLayoutPoint(layoutObject.localToAncestorPoint(
                        FloatPoint(), context.rootLayer->layoutObject())),
                    clipRects);
   }
 }
@@ skipping 16 matching lines @@
   LayoutRect source(LayoutRect::infiniteIntRect());
   bool success = false;
   const ObjectPaintProperties* properties =
       m_layer.layoutObject()->objectPaintProperties();
   PropertyTreeState propertyTreeState =
       properties->localBorderBoxProperties()->propertyTreeState;
 
   if (properties->cssClip())
     propertyTreeState.setClip(properties->cssClip());
 
-  const LayoutObject& layoutObject = *m_layer.layoutObject();
-  if (shouldRespectOverflowClip(context) && isForeground &&
-      (layoutObject.hasOverflowClip() ||
-       layoutObject.styleRef().containsPaint())) {
-    if (properties->overflowClip())
-      propertyTreeState.setClip(properties->overflowClip());
-  }
+  if (isForeground && shouldClipOverflow(context) && properties->overflowClip())
+    propertyTreeState.setClip(properties->overflowClip());
 
   const ObjectPaintProperties* ancestorProperties =
       context.rootLayer->layoutObject()->objectPaintProperties();
   PropertyTreeState destinationPropertyTreeState =
       ancestorProperties->localBorderBoxProperties()->propertyTreeState;
   if (!context.rootLayer->clipper().shouldRespectOverflowClip(context)) {
     if (ancestorProperties->overflowClip())
       destinationPropertyTreeState.setClip(ancestorProperties->overflowClip());
   }
   FloatRect clippedRectInRootLayerSpace =
       m_geometryMapper->mapToVisualRectInDestinationSpace(
           FloatRect(source), propertyTreeState, destinationPropertyTreeState,
           success);
   DCHECK(success);
   return ClipRect(LayoutRect(clippedRectInRootLayerSpace));
 }
 
 ClipRect PaintLayerClipper::applyOverflowClipToBackgroundRectWithGeometryMapper(
     const ClipRectsContext& context,
     const ClipRect& clip) const {
   const LayoutObject& layoutObject = *m_layer.layoutObject();
   FloatRect clipRect(clip.rect());
-  if ((layoutObject.hasOverflowClip() ||
-       layoutObject.styleRef().containsPaint()) &&
-      shouldRespectOverflowClip(context)) {
+  if (shouldClipOverflow(context)) {
     LayoutRect layerBoundsWithVisualOverflow =
         layoutObject.isLayoutView()
             ? toLayoutView(layoutObject).viewRect()
             : toLayoutBox(layoutObject).visualOverflowRect();
     toLayoutBox(layoutObject)
         .flipForWritingMode(
             // PaintLayer are in physical coordinates, so the overflow has to be
             // flipped.
             layerBoundsWithVisualOverflow);
     mapLocalToRootWithGeometryMapper(context, layerBoundsWithVisualOverflow);
@@ skipping 39 matching lines @@
 }
 
 void PaintLayerClipper::getOrCalculateClipRects(const ClipRectsContext& context,
                                                 ClipRects& clipRects) const {
   if (context.usesCache())
     clipRects = getClipRects(context);
   else
     calculateClipRects(context, clipRects);
 }
 
+bool PaintLayerClipper::shouldClipOverflow(
+    const ClipRectsContext& context) const {
+  return (m_layer.layoutObject()->hasOverflowClip() ||
+          m_layer.layoutObject()->styleRef().containsPaint()) &&
+         shouldRespectOverflowClip(context);
+}
+
 bool PaintLayerClipper::shouldRespectOverflowClip(
     const ClipRectsContext& context) const {
   if (&m_layer != context.rootLayer)
     return true;
 
   if (context.respectOverflowClip == IgnoreOverflowClip)
     return false;
 
   if (m_layer.isRootLayer() &&
       context.respectOverflowClipForViewport == IgnoreOverflowClip)
     return false;
 
   return true;
 }
 
 ClipRects& PaintLayerClipper::paintingClipRects(
     const PaintLayer* rootLayer,
     ShouldRespectOverflowClipType respectOverflowClip,
     const LayoutSize& subpixelAccumulation) const {
   DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnoreOverlayScrollbarSize, subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink