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

third_party/WebKit/Source/core/layout/LayoutObject.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 935 matching lines @@
   // positioned inline, thus we can't return a LayoutBlock from this function.
   //
   // This method is extremely similar to containingBlock(), but with a few
   // notable exceptions.
   // (1) For normal flow elements, it just returns the parent.
   // (2) For absolute positioned elements, it will return a relative
   //     positioned inline. containingBlock() simply skips relpositioned inlines
   //     and lets an enclosing block handle the layout of the positioned object.
   //     This does mean that computePositionedLogicalWidth and
   //     computePositionedLogicalHeight have to use container().
-  //
-  // Note that floating objects don't belong to either of the above exceptions.
+  // (3) For floating object, it returns the nearest ancestor whose
+  //     canContainFloatingObject(*this) is true.
   //
   // This function should be used for any invalidation as it would correctly
   // walk the containing block chain. See e.g. markContainerChainForLayout.
   // It is also used for correctly sizing absolutely positioned elements
   // (point 3 above).
   LayoutObject* container(AncestorSkipInfo* = nullptr) const;
   // Finds the container as if this object is fixed-position.
   LayoutBlock* containerForFixedPosition(AncestorSkipInfo* = nullptr) const;
   // Finds the containing block as if this object is absolute-position.
   LayoutBlock* containingBlockForAbsolutePosition(
@@ skipping 190 matching lines @@
 
   bool canContainAbsolutePositionObjects() const {
     return m_style->canContainAbsolutePositionObjects() ||
            canContainFixedPositionObjects();
   }
   bool canContainFixedPositionObjects() const {
     return isLayoutView() || isSVGForeignObject() ||
            (isLayoutBlock() && m_style->canContainFixedPositionObjects());
   }
 
+  // A block can contain floating objects. A stacked inline can contain stacked
+  // floating objects. A floating object's container is the nearest ancestor
+  // that can contain the object.
+  bool canContainFloatingObject(const LayoutObject& floating) const {
+    DCHECK(floating.isFloating());
+    return isLayoutBlock() ||
+           (styleRef().isStacked() && floating.styleRef().isStacked());
+  }
+
   // Convert the given local point to absolute coordinates
   // FIXME: Temporary. If UseTransforms is true, take transforms into account.
   // Eventually localToAbsolute() will always be transform-aware.
   FloatPoint localToAbsolute(const FloatPoint& localPoint = FloatPoint(),
                              MapCoordinatesFlags = 0) const;
 
   // If the LayoutBoxModelObject ancestor is non-null, the input point is in the
   // space of the ancestor.
   // Otherwise:
   //   If TraverseDocumentBoundaries is specified, the input point is in the
@@ skipping 1522 matching lines @@
 CORE_EXPORT void showLineTree(const blink::LayoutObject*);
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1);
 // We don't make object2 an optional parameter so that showLayoutTree
 // can be called from gdb easily.
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1,
                                 const blink::LayoutObject* object2);
 
 #endif
 
 #endif  // LayoutObject_h