Fix nested border radius with composited child.

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 37 matching lines @@
 #include "core/layout/api/LayoutAPIShim.h"
 #include "core/layout/api/LayoutEmbeddedContentItem.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/loader/resource/ImageResourceContent.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/page/scrolling/StickyPositionScrollingConstraints.h"
 #include "core/page/scrolling/TopDocumentRootScrollerController.h"
 #include "core/paint/FramePaintTiming.h"
+#include "core/paint/LayerClipRecorder.h"
 #include "core/paint/ObjectPaintInvalidator.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/PaintLayerPainter.h"
 #include "core/paint/PaintLayerStackingNodeIterator.h"
 #include "core/paint/ScrollableAreaPainter.h"
 #include "core/paint/TransformRecorder.h"
 #include "core/plugins/PluginView.h"
 #include "core/probe/CoreProbes.h"
 #include "platform/LengthFunctions.h"
 #include "platform/RuntimeEnabledFeatures.h"
@@ skipping 475 matching lines @@
 }
 
 void CompositedLayerMapping::UpdateCompositingReasons() {
   // All other layers owned by this mapping will have the same compositing
   // reason for their lifetime, so they are initialized only when created.
   graphics_layer_->SetCompositingReasons(owning_layer_.GetCompositingReasons());
   graphics_layer_->SetSquashingDisallowedReasons(
       owning_layer_.GetSquashingDisallowedReasons());
 }
 
 bool CompositedLayerMapping::AncestorRoundedCornersWontClip(

[chrishtr, 2017/06/09 22:45:28]

Please unittest this directly.

[Stephen Chennney, 2017/06/12 14:43:29]

Will do.

-    const LayoutBoxModelObject& child,
-    const LayoutBoxModelObject& clipping_ancestor) {
-  LayoutRect local_visual_rect = composited_bounds_;
-  child.MapToVisualRectInAncestorSpace(&clipping_ancestor, local_visual_rect);
-  FloatRoundedRect rounded_clip_rect =
-      clipping_ancestor.Style()->GetRoundedInnerBorderFor(
-          clipping_ancestor.LocalVisualRect());
-  FloatRect inner_clip_rect = rounded_clip_rect.RadiusCenterRect();
-  // The first condition catches cases where the child is certainly inside
-  // the rounded corner portion of the border, and cannot be clipped by
-  // the rounded portion. The second catches cases where the child is
-  // entirely outside the rectangular border (ignoring rounded corners) so
-  // is also unaffected by the rounded corners. In both cases the existing
-  // rectangular clip is adequate and the mask is unnecessary.
-  return inner_clip_rect.Contains(FloatRect(local_visual_rect)) ||
-         !local_visual_rect.Intersects(
-             EnclosingLayoutRect(rounded_clip_rect.Rect()));
+    const LayoutBoxModelObject* clipping_container) {

[chrishtr, 2017/06/09 22:45:28]

I don't think this argument is necessary. Just iterate over clipping container
until you reach an element higher in the DOM than compositing_container.

[Stephen Chennney, 2017/06/12 14:43:29]

The argument is just because I happen to have already computed this thing so it
seems simpler to pass it in than compute it again.

I'll cut short the iteration at the compositing_container.

[Stephen Chennney, 2017/06/12 15:04:55]

Misunderstood. I see what you mean now and have made the change.

+  // Find the root-most clipper. We must process all clips in the chain to
+  // the root to correctly handle nested clips.

[chrishtr, 2017/06/09 22:45:28]

You don't need to look above above compositing_ancestor.
Those clips don't matter because they are applied by other
composited layers.

[Stephen Chennney, 2017/06/12 14:43:29]

Yes. I get that now.

+  const PaintLayer* clip_root = clipping_container->EnclosingLayer();
+  while (const PaintLayer* new_clip_root =
+             clip_root->ClippingContainer()->EnclosingLayer()) {
+    clip_root = new_clip_root;
+  }
+
+  LayoutPoint offset_to_clipper;
+  owning_layer_.ConvertToLayerCoords(clip_root, offset_to_clipper);
+  Vector<FloatRoundedRect> rounded_rect_clips;
+  LayerClipRecorder::CollectRoundedRectClips(
+      owning_layer_, clip_root, -offset_to_clipper, true,
+      LayerClipRecorder::kDoNotIncludeSelfForBorderRadius, rounded_rect_clips);
+
+  for (auto clip_rect : rounded_rect_clips) {
+    FloatRect inner_clip_rect = clip_rect.RadiusCenterRect();
+    // The first condition catches cases where the child is certainly inside
+    // the rounded corner portion of the border, and cannot be clipped by
+    // the rounded portion. The second catches cases where the child is
+    // entirely outside the rectangular border (ignoring rounded corners) so
+    // is also unaffected by the rounded corners. In both cases the existing
+    // rectangular clip is adequate and the mask is unnecessary.
+    if (!(inner_clip_rect.Contains(FloatRect(composited_bounds_)) ||
+          !composited_bounds_.Intersects(
+              EnclosingLayoutRect(clip_rect.Rect())))) {
+      return false;
+    }
+  }
+  return true;
 }
 
 void CompositedLayerMapping::
     OwningLayerClippedOrMaskedByLayerNotAboveCompositedAncestor(
         const PaintLayer* scroll_parent,
         bool& owning_layer_is_clipped,
         bool& owning_layer_is_masked) {
   owning_layer_is_clipped = false;
   owning_layer_is_masked = false;
 
@@ skipping 31 matching lines @@
 
   ClipRect clip_rect;
   owning_layer_.Clipper(PaintLayer::kDoNotUseGeometryMapper)
       .CalculateBackgroundClipRect(clip_rects_context, clip_rect);
   IntRect parent_clip_rect = PixelSnappedIntRect(clip_rect.Rect());
   owning_layer_is_clipped = parent_clip_rect != LayoutRect::InfiniteIntRect();
 
   // TODO(schenney): CSS clips are not applied to composited children, and
   // should be via mask or by compositing the parent too.
   // https://bugs.chromium.org/p/chromium/issues/detail?id=615870
-  DCHECK(clipping_container->Style());
-  owning_layer_is_masked =
-      owning_layer_is_clipped &&
-      clipping_container->Style()->HasBorderRadius() &&
-      !AncestorRoundedCornersWontClip(GetLayoutObject(), *clipping_container);
+  if (owning_layer_is_clipped) {
+    owning_layer_is_masked =
+        !AncestorRoundedCornersWontClip(clipping_container);
+  }
 }
 
 const PaintLayer* CompositedLayerMapping::ScrollParent() {
   const PaintLayer* scroll_parent = owning_layer_.ScrollParent();
   if (scroll_parent && !scroll_parent->NeedsCompositedScrolling())
     return nullptr;
   return scroll_parent;
 }
 
 bool CompositedLayerMapping::UpdateGraphicsLayerConfiguration() {
@@ skipping 3028 matching lines @@
   } else if (graphics_layer == decoration_outline_layer_.get()) {
     name = "Decoration Layer";
   } else {
     NOTREACHED();
   }
 
   return name;
 }
 
 }  // namespace blink