Fix nested border radius with composited child.

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/LayerClipRecorder.h"
 
 #include "core/layout/LayoutView.h"
 #include "core/paint/ClipRect.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/geometry/IntRect.h"
@@ skipping 12 matching lines @@
                                      const LayoutPoint& fragment_offset,
                                      PaintLayerFlags paint_flags,
                                      BorderRadiusClippingRule rule)
     : graphics_context_(graphics_context),
       layout_object_(layout_object),
       clip_type_(clip_type) {
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return;
   IntRect snapped_clip_rect = PixelSnappedIntRect(clip_rect.Rect());
   Vector<FloatRoundedRect> rounded_rects;
-  if (clip_root && clip_rect.HasRadius()) {
+  if (clip_root) {
     CollectRoundedRectClips(*layout_object.Layer(), clip_root, graphics_context,
                             fragment_offset, paint_flags, rule, rounded_rects);
   }
 
   graphics_context_.GetPaintController().CreateAndAppend<ClipDisplayItem>(
       layout_object, clip_type_, snapped_clip_rect, rounded_rects);
 }
 
 static bool InContainingBlockChain(PaintLayer* start_layer,
                                    PaintLayer* end_layer) {
@@ skipping 17 matching lines @@
     const PaintLayer* clip_root,
     GraphicsContext& context,
     const LayoutPoint& fragment_offset,
     PaintLayerFlags paint_flags,
     BorderRadiusClippingRule rule,
     Vector<FloatRoundedRect>& rounded_rect_clips) {
   // If the clip rect has been tainted by a border radius, then we have to walk
   // up our layer chain applying the clips from any layers with overflow. The
   // condition for being able to apply these clips is that the overflow object
   // be in our containing block chain so we check that also.
+#ifndef NDEBUG
+  LOG(INFO) << "CollectRoundedRectClips layer: " << &paint_layer;
+  LOG(INFO) << "CollectRoundedRectClips clip_root: " << clip_root;
+#endif
   for (PaintLayer* layer = rule == kIncludeSelfForBorderRadius
                                ? &paint_layer
                                : paint_layer.Parent();
        layer; layer = layer->Parent()) {
     // Composited scrolling layers handle border-radius clip in the compositor
     // via a mask layer. We do not want to apply a border-radius clip to the
     // layer contents itself, because that would require re-rastering every
     // frame to update the clip. We only want to make sure that the mask layer
     // is properly clipped so that it can in turn clip the scrolled contents in
     // the compositor.
+    bool paintingAncestorMask =
+        paint_flags & kPaintLayerPaintingAncestorClippingMaskPhase;
     if (layer->NeedsCompositedScrolling() &&
         !(paint_flags & kPaintLayerPaintingChildClippingMaskPhase ||
-          paint_flags & kPaintLayerPaintingAncestorClippingMaskPhase))
+          paintingAncestorMask))
       break;
 
     if (layer->GetLayoutObject().HasOverflowClip() &&
         layer->GetLayoutObject().Style()->HasBorderRadius() &&
         InContainingBlockChain(&paint_layer, layer)) {
       LayoutPoint delta(fragment_offset);
       layer->ConvertToLayerCoords(clip_root, delta);
 
       // The PaintLayer's size is pixel-snapped if it is a LayoutBox. We can't
       // use a pre-snapped border rect for clipping, since
       // getRoundedInnerBorderFor assumes it has not been snapped yet.
       LayoutSize size(layer->GetLayoutBox()
                           ? ToLayoutBox(layer->GetLayoutObject()).Size()
                           : LayoutSize(layer->size()));
-      rounded_rect_clips.push_back(
+      FloatRoundedRect clip_rect =
           layer->GetLayoutObject().Style()->GetRoundedInnerBorderFor(
-              LayoutRect(delta, size)));
+              LayoutRect(delta, size));
+      rounded_rect_clips.push_back(clip_rect);
+#ifndef NDEBUG
+      LOG(INFO) << "Adding rect for layer " << layer << " "
+                << clip_rect.ToString();
+#endif
     }
 
     if (layer == clip_root)
       break;
   }
 }
 
 LayerClipRecorder::~LayerClipRecorder() {
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return;
   graphics_context_.GetPaintController().EndItem<EndClipDisplayItem>(
       layout_object_, DisplayItem::ClipTypeToEndClipType(clip_type_));
 }
 
 }  // namespace blink