. The continuation chain starts with the first
// LayoutInline {B}, continues to the middle anonymous LayoutBlockFlow and
// finishes with the last LayoutInline {B}.
//
// Note that the middle anonymous LayoutBlockFlow duplicates the content.
// TODO(jchaffraix): Find out why we made the decision to always insert the
// anonymous LayoutBlockFlows.
//
// This section was inspired by an older article by Dave Hyatt:
// https://www.webkit.org/blog/115/webcore-rendering-ii-blocks-and-inlines/
class CORE_EXPORT LayoutInline : public LayoutBoxModelObject {
public:
explicit LayoutInline(Element*);
void Trace(Visitor*) const override;
static LayoutInline* CreateAnonymous(Document&);
LayoutObject* FirstChild() const {
NOT_DESTROYED();
DCHECK_EQ(Children(), VirtualChildren());
return Children()->FirstChild();
}
LayoutObject* LastChild() const {
NOT_DESTROYED();
DCHECK_EQ(Children(), VirtualChildren());
return Children()->LastChild();
}
// If you have a LayoutInline, use firstChild or lastChild instead.
void SlowFirstChild() const = delete;
void SlowLastChild() const = delete;
void AddChild(LayoutObject* new_child,
LayoutObject* before_child = nullptr) override;
Element* GetNode() const {
NOT_DESTROYED();
return To
(LayoutBoxModelObject::GetNode());
}
PhysicalBoxStrut MarginOutsets() const final;
// Returns the bounding box of all quads returned by `LocalQuadsForSelf`.
gfx::RectF LocalBoundingBoxRectF() const;
gfx::RectF LocalBoundingBoxRectForAccessibility(
IncludeDescendants include_descendants) const final;
PhysicalRect PhysicalLinesBoundingBox() const;
PhysicalRect LinesVisualOverflowBoundingBox() const;
PhysicalRect VisualOverflowRect() const final;
bool HasInlineFragments() const final;
wtf_size_t FirstInlineFragmentItemIndex() const final;
void ClearFirstInlineFragmentItemIndex() final;
void SetFirstInlineFragmentItemIndex(wtf_size_t) final;
void AddOutlineRects(OutlineRectCollector&,
OutlineInfo*,
const PhysicalOffset& additional_offset,
OutlineType) const override;
bool AlwaysCreateLineBoxes() const {
NOT_DESTROYED();
return AlwaysCreateLineBoxesForLayoutInline() &&
!IsInLayoutNGInlineFormattingContext();
}
void SetAlwaysCreateLineBoxes(bool always_create_line_boxes = true) {
NOT_DESTROYED();
DCHECK(!IsInLayoutNGInlineFormattingContext());
SetAlwaysCreateLineBoxesForLayoutInline(always_create_line_boxes);
}
// True if this inline box should force creation of PhysicalBoxFragment.
bool ShouldCreateBoxFragment() const {
NOT_DESTROYED();
return AlwaysCreateLineBoxesForLayoutInline() &&
IsInLayoutNGInlineFormattingContext();
}
void SetShouldCreateBoxFragment(bool value = true) {
NOT_DESTROYED();
DCHECK(IsInLayoutNGInlineFormattingContext());
SetAlwaysCreateLineBoxesForLayoutInline(value);
}
void UpdateShouldCreateBoxFragment();
PhysicalRect LocalCaretRect(int, CaretShape) const final;
// When this LayoutInline doesn't generate line boxes of its own, regenerate
// the rects of the line boxes and hit test the rects.
// |parent_cursor| is used to limit the regenerated rects to be from
// descendant fragments of |parent_cursor|.
bool HitTestCulledInline(HitTestResult&,
const HitTestLocation&,
const PhysicalOffset& accumulated_offset,
const InlineCursor& parent_cursor);
PhysicalOffset FirstLineBoxTopLeft() const {
NOT_DESTROYED();
return FirstLineBoxTopLeftInternal().value_or(PhysicalOffset());
}
PhysicalRect AbsoluteBoundingBoxRectHandlingEmptyInline(
MapCoordinatesFlags = {}) const final;
const char* GetName() const override {
NOT_DESTROYED();
return "LayoutInline";
}
PhysicalRect DebugRect() const override;
protected:
void WillBeDestroyed(const ComputedStyle*) override;
void InLayoutNGInlineFormattingContextWillChange(bool) final;
void StyleDidChange(StyleDifference,
const ComputedStyle* old_style,
const ComputedStyle& new_style,
const StyleChangeContext&) override;
void InvalidateDisplayItemClients(PaintInvalidationReason) const override;
void QuadsInAncestorInternal(Vector&,
const LayoutBoxModelObject* ancestor,
MapCoordinatesFlags,
BoxQuadType) const override;
private:
void QuadsForSelfInternal(Vector& quads,
const LayoutBoxModelObject* ancestor,
MapCoordinatesFlags mode,
bool map_to_ancestor,
BoxQuadType box_type = BoxQuadType::kBorder) const;
// Collects rectangles that the outline of this object would be drawing along
// the outside of, even if the object isn't styled with a outline for now.
// If include_descendants is true, then descendant rects are aggregated,
// causing visible overflow to be included (note that visible overflow is hit
// testable).
void AddOutlineRectsInternal(OutlineRectCollector&,
OutlineInfo*,
const PhysicalOffset& additional_offset,
OutlineType,
IncludeDescendants include_descendants) const;
LayoutObjectChildList* VirtualChildren() final {
NOT_DESTROYED();
return Children();
}
const LayoutObjectChildList* VirtualChildren() const final {
NOT_DESTROYED();
return Children();
}
const LayoutObjectChildList* Children() const {
NOT_DESTROYED();
return &children_;
}
LayoutObjectChildList* Children() {
NOT_DESTROYED();
return &children_;
}
bool IsLayoutInline() const final {
NOT_DESTROYED();
return true;
}
// Compute the initial value of |ShouldCreateBoxFragment()| for this
// LayoutInline. It maybe flipped to true later for other conditions.
bool ComputeInitialShouldCreateBoxFragment() const;
bool ComputeInitialShouldCreateBoxFragment(const ComputedStyle& style) const;
PhysicalRect CulledInlineVisualOverflowBoundingBox() const;
// PhysicalRectCollector should be like a function:
// void (const PhysicalRect&).
template
void CollectLineBoxRects(const PhysicalRectCollector&) const;
void AddChildAsBlockInInline(LayoutObject* new_child,
LayoutObject* before_child);
// Create an anonymous block for block children of this inline.
LayoutBlockFlow* CreateAnonymousContainerForBlockChildren() const;
LayoutBox* CreateAnonymousBoxToSplit(
const LayoutBox* box_to_split) const final;
void MarkMayContainAnchor() final;
void Paint(const PaintInfo&) const override;
bool NodeAtPoint(HitTestResult&,
const HitTestLocation&,
const PhysicalOffset& accumulated_offset,
HitTestPhase) final;
PaintLayerType LayerTypeRequired() const override;
PhysicalOffset OffsetPoint(const Element*) const final;
PhysicalRect BoundingBoxRelativeToFirstFragment() const final;
bool MapToVisualRectInAncestorSpaceInternal(
const LayoutBoxModelObject* ancestor,
TransformState&,
VisualRectFlags) const final;
PositionWithAffinity PositionForPoint(const PhysicalOffset&) const override;
void DirtyLinesFromChangedChild(LayoutObject*) final;
void UpdateHitTestResult(HitTestResult&, const PhysicalOffset&) const final;
void ImageChanged(WrappedImagePtr, CanDeferInvalidation) final;
void AddDraggableRegions(Vector&) final;
bool ShouldBeHandledAsInline(const ComputedStyle&) const override {
NOT_DESTROYED();
// This is needed (at a minimum) for LayoutSVGInline, which (including
// subclasses) is constructed for svg:a, svg:textPath, and svg:tspan,
// regardless of CSS 'display'.
return true;
}
bool AnonymousHasStylePropagationOverride() final {
NOT_DESTROYED();
return true;
}
std::optional FirstLineBoxTopLeftInternal() const;
PhysicalOffset AnchorPhysicalLocation() const;
LayoutObjectChildList children_;
// The index of the first fragment item associated with this object in
// |FragmentItems::Items()|. Zero means there are no such item.
// Valid only when IsInLayoutNGInlineFormattingContext().
wtf_size_t first_fragment_item_index_ = 0u;
};
inline wtf_size_t LayoutInline::FirstInlineFragmentItemIndex() const {
NOT_DESTROYED();
if (!IsInLayoutNGInlineFormattingContext())
return 0u;
return first_fragment_item_index_;
}
template <>
struct DowncastTraits {
static bool AllowFrom(const LayoutObject& object) {
return object.IsLayoutInline();
}
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_CORE_LAYOUT_LAYOUT_INLINE_H_