Fix geometry mapping issues for float under 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 881 matching lines @@
   bool behavesLikeBlockContainer() const {
     return isLayoutBlockFlow() || isLayoutButton();
   }
 
   // This function returns the containing block of the object.
   // Due to CSS being inconsistent, a containing block can be a relatively
   // 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) It can be used on orphaned subtrees, i.e., it can be called safely
-  //     even when the object is not part of the primary document subtree yet.
-  // (2) For normal flow elements, it just returns the parent.
-  // (3) For absolute positioned elements, it will return a relative
+  // (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.
+  //
   // 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).
   //
   // If |ancestor| and |ancestorSkipped| are not null, on return
   // *ancestorSkipped is true if the layoutObject returned is an ancestor of
   // |ancestor|.
   LayoutObject* container(const LayoutBoxModelObject* ancestor = nullptr,
                           bool* ancestorSkipped = nullptr,
                           bool* filterSkipped = nullptr) const;
   // Finds the container as if this object is fixed-position.
   LayoutBlock* containerForFixedPosition(
       const LayoutBoxModelObject* ancestor = nullptr,
       bool* ancestorSkipped = nullptr,
       bool* filterSkipped = nullptr) const;
   // Finds the containing block as if this object is absolute-position.
-  LayoutBlock* containingBlockForAbsolutePosition() const;
+  LayoutBlock* containingBlockForAbsolutePosition(
+      const LayoutBoxModelObject* ancestor = nullptr,
+      bool* ancestorSkipped = nullptr,
+      bool* filterSkipped = nullptr) const;
 
   virtual LayoutObject* hoverAncestor() const { return parent(); }
 
   Element* offsetParent(const Element* = nullptr) const;
 
   void markContainerChainForLayout(bool scheduleRelayout = true,
                                    SubtreeLayoutScope* = nullptr);
   void setNeedsLayout(LayoutInvalidationReasonForTracing,
                       MarkingBehavior = MarkContainerChain,
                       SubtreeLayoutScope* = nullptr);
@@ skipping 168 matching lines @@
   //   non-anonymous LayoutBlock.
   //   Note that in the previous examples, the returned LayoutBlock has no
   //   logical relationship to the original element.
   //
   // LayoutBlocks are the one that handle laying out positioned elements,
   // thus this function is important during layout, to insert the positioned
   // elements into the correct LayoutBlock.
   //
   // See container() for the function that returns the containing block.
   // See LayoutBlock.h for some extra explanations on containing blocks.
-  LayoutBlock* containingBlock() const;
+  LayoutBlock* containingBlock(const LayoutBoxModelObject* ancestor = nullptr,

[mstensho (USE GERRIT), 2017/01/05 10:31:30]

How about a struct that holds these three variables instead?

struct AncestorSkipInfo { // There could be a better name
    const LayoutBoxModelObject* const ancestor { nullptr };
    bool ancestorSkipped { false };
    bool filterSkipped { false };
};

LayoutBlock* containingBlock(AncestorSkipInfo* = nullptr)

And then we should have the same in containingBlockForAbsolutePosition(), and
even container().

[Xianzhu, 2017/01/06 00:42:35]

Sounds good. Would like to address this in a follow-up.

+                               bool* ancestorSkipped = nullptr,
+                               bool* filterSkipped = nullptr) const;
 
   bool canContainAbsolutePositionObjects() const {
     return m_style->canContainAbsolutePositionObjects() ||
            canContainFixedPositionObjects();
   }
   bool canContainFixedPositionObjects() const {
     return isLayoutView() || isSVGForeignObject() ||
            (isLayoutBlock() && m_style->canContainFixedPositionObjects());
   }
 
@@ skipping 1543 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