Fix paint and rect mapping issues for stacked float under stacked inline

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

 // Copyright 2016 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/PaintInvalidator.h"
 
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 180 matching lines @@
 
   return point;
 }
 
 void PaintInvalidator::updatePaintingLayer(const LayoutObject& object,
                                            PaintInvalidatorContext& context) {
   if (object.hasLayer() &&
       toLayoutBoxModelObject(object).hasSelfPaintingLayer()) {
     context.paintingLayer = toLayoutBoxModelObject(object).layer();
   } else if (object.isColumnSpanAll() ||
-             (object.isFloating() && !object.parent()->isLayoutBlock())) {
+             (object.isFloating() &&
+              !object.parent()->canContainFloatingObject(object))) {
     // See LayoutObject::paintingLayer() for the special-cases of floating under
     // inline and multicolumn.
     context.paintingLayer = object.paintingLayer();
   }
 
   if (object.isLayoutBlockFlow() && toLayoutBlockFlow(object).containsFloats())
     context.paintingLayer->setNeedsPaintPhaseFloat();
 
   if (object == context.paintingLayer->layoutObject())
     return;
@@ skipping 51 matching lines @@
 
 }  // namespace
 
 void PaintInvalidator::updateContext(const LayoutObject& object,
                                      PaintInvalidatorContext& context) {
   Optional<ScopedUndoFrameViewContentClipAndScroll>
       undoFrameViewContentClipAndScroll;
 
   if (object.isPaintInvalidationContainer()) {
     context.paintInvalidationContainer = toLayoutBoxModelObject(&object);
-    if (object.styleRef().isStackingContext())
+    if (object.styleRef().isStackingContext()) {
       context.paintInvalidationContainerForStackedContents =
           toLayoutBoxModelObject(&object);
+    }
   } else if (object.isLayoutView()) {
     // paintInvalidationContainerForStackedContents is only for stacked
     // descendants in its own frame, because it doesn't establish stacking
     // context for stacked contents in sub-frames.
     // Contents stacked in the root stacking context in this frame should use
     // this frame's paintInvalidationContainer.
     context.paintInvalidationContainerForStackedContents =
         context.paintInvalidationContainer;
-    if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled())
+    if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       undoFrameViewContentClipAndScroll.emplace(
           *toLayoutView(object).frameView(), context);
-  } else if (object.isFloating() && !object.parent()->isLayoutBlock()) {
-    // See LayoutObject::paintingLayer() for specialty of floating objects.
-    context.paintInvalidationContainer =
-        &object.containerForPaintInvalidation();
+    }
   } else if (object.styleRef().isStacked() &&
              // This is to exclude some objects (e.g. LayoutText) inheriting
              // stacked style from parent but aren't actually stacked.
              object.hasLayer() &&
              context.paintInvalidationContainer !=
                  context.paintInvalidationContainerForStackedContents) {
     // The current object is stacked, so we should use
     // m_paintInvalidationContainerForStackedContents as its paint invalidation
     // container on which the current object is painted.
     context.paintInvalidationContainer =
         context.paintInvalidationContainerForStackedContents;
     if (context.forcedSubtreeInvalidationFlags &
         PaintInvalidatorContext::
-            ForcedSubtreeFullInvalidationForStackedContents)
+            ForcedSubtreeFullInvalidationForStackedContents) {
       context.forcedSubtreeInvalidationFlags |=
           PaintInvalidatorContext::ForcedSubtreeFullInvalidation;
+    }
+  } else if (object.isFloating() &&
+             !object.parent()->canContainFloatingObject(object)) {
+    context.paintInvalidationContainer =
+        &object.containerForPaintInvalidation();
   }
 
   if (object == context.paintInvalidationContainer) {
     // When we hit a new paint invalidation container, we don't need to
     // continue forcing a check for paint invalidation, since we're
     // descending into a different invalidation container. (For instance if
     // our parents were moved, the entire container will just move.)
     if (object != context.paintInvalidationContainerForStackedContents) {
       // However, we need to keep the
       // ForcedSubtreeFullInvalidationForStackedContents flag if the current
@@ skipping 126 matching lines @@
         PaintInvalidatorContext::ForcedSubtreeInvalidationRectUpdate;
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations() {
   for (auto target : m_pendingDelayedPaintInvalidations)
     target->getMutableForPainting().setShouldDoFullPaintInvalidation(
         PaintInvalidationDelayedFull);
 }
 
 }  // namespace blink