fragment_builder.cc | Explore in Territory

// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/core/layout/fragment_builder.h"

#include "base/containers/contains.h"
#include "third_party/blink/public/mojom/use_counter/metrics/web_feature.mojom-shared.h"
#include "third_party/blink/renderer/core/display_lock/display_lock_utilities.h"
#include "third_party/blink/renderer/core/layout/fragmentation_utils.h"
#include "third_party/blink/renderer/core/layout/physical_box_fragment.h"
#include "third_party/blink/renderer/core/layout/physical_fragment.h"
#include "third_party/blink/renderer/core/style/computed_style_base_constants.h"

namespace blink {

namespace {

bool IsInlineContainerForNode(const BlockNode& node,
                              const LayoutObject* inline_container) { … }

LogicalAnchorQuery::SetOptions AnchorQuerySetOptions(
    const PhysicalFragment& fragment,
    const LayoutInputNode& container,
    bool maybe_out_of_order_if_oof) { … }

}  // namespace

bool FragmentBuilder::IsRoot() const { … }

bool FragmentBuilder::IsPaginatedRoot() const { … }

PhysicalFragment::BoxType FragmentBuilder::GetBoxType() const { … }

void FragmentBuilder::ReplaceChild(wtf_size_t index,
                                   const PhysicalFragment& new_child,
                                   const LogicalOffset offset) { … }

HeapVector<Member<LayoutBoxModelObject>>&
FragmentBuilder::EnsureStickyDescendants() { … }

void FragmentBuilder::PropagateStickyDescendants(
    const PhysicalFragment& child) { … }

HeapVector<Member<LayoutBox>>& FragmentBuilder::EnsureSnapAreas() { … }

void FragmentBuilder::PropagateSnapAreas(const PhysicalFragment& child) { … }

LogicalAnchorQuery& FragmentBuilder::EnsureAnchorQuery() { … }

void FragmentBuilder::PropagateChildAnchors(const PhysicalFragment& child,
                                            const LogicalOffset& child_offset) { … }

void FragmentBuilder::PropagateFromLayoutResultAndFragment(
    const LayoutResult& child_result,
    LogicalOffset child_offset,
    LogicalOffset relative_offset,
    const OofInlineContainer<LogicalOffset>* inline_container) { … }

void FragmentBuilder::PropagateFromLayoutResult(
    const LayoutResult& child_result) { … }

ScrollStartTargetCandidates& FragmentBuilder::EnsureScrollStartTargets() { … }

void FragmentBuilder::PropagateScrollStartTarget(
    const PhysicalFragment& child) { … }

// Propagate data in |child| to this fragment. The |child| will then be added as
// a child fragment or a child fragment item.
void FragmentBuilder::PropagateFromFragment(
    const PhysicalFragment& child,
    LogicalOffset child_offset,
    LogicalOffset relative_offset,
    const OofInlineContainer<LogicalOffset>* inline_container) { … }

void FragmentBuilder::AddChildInternal(const PhysicalFragment* child,
                                       const LogicalOffset& child_offset) { … }

void FragmentBuilder::AddOutOfFlowChildCandidate(
    BlockNode child,
    const LogicalOffset& child_offset,
    LogicalStaticPosition::InlineEdge inline_edge,
    LogicalStaticPosition::BlockEdge block_edge,
    bool is_hidden_for_paint,
    bool allow_top_layer_nodes) { … }

void FragmentBuilder::AddOutOfFlowInlineChildCandidate(
    BlockNode child,
    const LogicalOffset& child_offset,
    TextDirection inline_container_direction,
    bool is_hidden_for_paint) { … }

void FragmentBuilder::AddOutOfFlowFragmentainerDescendant(
    const LogicalOofNodeForFragmentation& descendant) { … }

void FragmentBuilder::AddOutOfFlowFragmentainerDescendant(
    const LogicalOofPositionedNode& descendant) { … }

void FragmentBuilder::AddOutOfFlowDescendant(
    const LogicalOofPositionedNode& descendant) { … }

void FragmentBuilder::SwapOutOfFlowPositionedCandidates(
    HeapVector<LogicalOofPositionedNode>* candidates) { … }

void FragmentBuilder::ClearOutOfFlowPositionedCandidates() { … }

void FragmentBuilder::AddMulticolWithPendingOOFs(
    const BlockNode& multicol,
    MulticolWithPendingOofs<LogicalOffset>* multicol_info) { … }

void FragmentBuilder::SwapMulticolsWithPendingOOFs(
    MulticolCollection* multicols_with_pending_oofs) { … }

void FragmentBuilder::SwapOutOfFlowFragmentainerDescendants(
    HeapVector<LogicalOofNodeForFragmentation>* descendants) { … }

void FragmentBuilder::TransferOutOfFlowCandidates(
    FragmentBuilder* destination_builder,
    LogicalOffset additional_offset,
    const MulticolWithPendingOofs<LogicalOffset>* multicol) { … }

void FragmentBuilder::MoveOutOfFlowDescendantCandidatesToDescendants() { … }

LayoutUnit FragmentBuilder::BlockOffsetAdjustmentForFragmentainer(
    LayoutUnit fragmentainer_consumed_block_size) const { … }

void FragmentBuilder::PropagateOOFPositionedInfo(
    const PhysicalFragment& fragment,
    LogicalOffset offset,
    LogicalOffset relative_offset,
    LogicalOffset offset_adjustment,
    const OofInlineContainer<LogicalOffset>* inline_container,
    LayoutUnit containing_block_adjustment,
    const OofContainingBlock<LogicalOffset>* containing_block,
    const OofContainingBlock<LogicalOffset>* fixedpos_containing_block,
    const OofInlineContainer<LogicalOffset>* fixedpos_inline_container,
    LogicalOffset additional_fixedpos_offset) { … }

void FragmentBuilder::PropagateOOFFragmentainerDescendants(
    const PhysicalFragment& fragment,
    LogicalOffset offset,
    LogicalOffset relative_offset,
    LayoutUnit containing_block_adjustment,
    const OofContainingBlock<LogicalOffset>* containing_block,
    const OofContainingBlock<LogicalOffset>* fixedpos_containing_block,
    HeapVector<LogicalOofNodeForFragmentation>* out_list) { … }

void FragmentBuilder::AdjustFixedposContainerInfo(
    const PhysicalFragment* box_fragment,
    LogicalOffset relative_offset,
    OofInlineContainer<LogicalOffset>* fixedpos_inline_container,
    const PhysicalFragment** fixedpos_containing_block_fragment,
    const OofInlineContainer<LogicalOffset>* current_inline_container) const { … }

void FragmentBuilder::PropagateSpaceShortage(
    std::optional<LayoutUnit> space_shortage) { … }

const LayoutResult* FragmentBuilder::Abort(LayoutResult::EStatus status) { … }

#if DCHECK_IS_ON()

String FragmentBuilder::ToString() const { … }

#endif

}  // namespace blink
chromium/third_party/blink/renderer/core/layout/fragment_builder.cc
