Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
openSUSE
chromium.7041
chromium-override.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File chromium-override.patch of Package chromium.7041
Index: third_party/WebKit/Source/core/layout/ng/inline/ng_inline_layout_algorithm.cc diff --git a/third_party/WebKit/Source/core/layout/ng/inline/ng_inline_layout_algorithm.cc b/third_party/WebKit/Source/core/layout/ng/inline/ng_inline_layout_algorithm.cc index 1a426a995436c58bfa9aa557018415994cbed4bb..89db06af1f7341070566b05b9763c1f7a126498e 100644 --- a/third_party/WebKit/Source/core/layout/ng/inline/ng_inline_layout_algorithm.cc +++ b/third_party/WebKit/Source/core/layout/ng/inline/ng_inline_layout_algorithm.cc @@ -55,11 +55,11 @@ NGInlineLayoutAlgorithm::NGInlineLayoutAlgorithm( // Only resolve our BFC offset if we know that we are non-empty as we may // need to pass through our margin strut. if (!inline_node->Items().IsEmpty()) { - NGLogicalOffset bfc_offset = ConstraintSpace().BfcOffset(); - bfc_offset.block_offset += ConstraintSpace().MarginStrut().Sum(); - MaybeUpdateFragmentBfcOffset(ConstraintSpace(), bfc_offset, + LayoutUnit bfc_block_offset = ConstraintSpace().BfcOffset().block_offset; + bfc_block_offset += ConstraintSpace().MarginStrut().Sum(); + MaybeUpdateFragmentBfcOffset(ConstraintSpace(), bfc_block_offset, &container_builder_); - PositionPendingFloats(bfc_offset.block_offset, &container_builder_, + PositionPendingFloats(bfc_block_offset, &container_builder_, MutableConstraintSpace()); } Index: third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.cc diff --git a/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.cc b/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.cc index 261d588dd69b4e9f05a23a9aac076f517da9d217..03f669188987dd95f3c0b65479814b192a655156 100644 --- a/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.cc +++ b/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.cc @@ -67,14 +67,31 @@ bool IsOutOfSpace(const NGConstraintSpace& space, LayoutUnit content_size) { } // namespace +// This struct is used for communicating to a child the position of the +// previous inflow child. +struct NGPreviousInflowPosition { + LayoutUnit bfc_block_offset; + LayoutUnit logical_block_offset; + NGMarginStrut margin_strut; +}; + +// This strut holds information for the current inflow child. The data is not +// useful outside of handling this single inflow child. +struct NGInflowChildData { + NGLogicalOffset bfc_offset_estimate; + NGMarginStrut margin_strut; + NGBoxStrut margins; +}; + void MaybeUpdateFragmentBfcOffset(const NGConstraintSpace& space, - const NGLogicalOffset& offset, + LayoutUnit bfc_block_offset, NGFragmentBuilder* builder) { DCHECK(builder); if (!builder->BfcOffset()) { - NGLogicalOffset mutable_offset(offset); - AdjustToClearance(space.ClearanceOffset(), &mutable_offset); - builder->SetBfcOffset(mutable_offset); + NGLogicalOffset bfc_offset = {space.BfcOffset().inline_offset, + bfc_block_offset}; + AdjustToClearance(space.ClearanceOffset(), &bfc_offset); + builder->SetBfcOffset(bfc_offset); } } @@ -150,11 +167,13 @@ Optional<MinMaxContentSize> NGBlockLayoutAlgorithm::ComputeMinMaxContentSize() } NGLogicalOffset NGBlockLayoutAlgorithm::CalculateLogicalOffset( + const NGBoxStrut& child_margins, const WTF::Optional<NGLogicalOffset>& known_fragment_offset) { if (known_fragment_offset) return known_fragment_offset.value() - ContainerBfcOffset(); LayoutUnit inline_offset = - border_and_padding_.inline_start + curr_child_margins_.inline_start; + border_and_padding_.inline_start + child_margins.inline_start; + // TODO(ikilpatrick): Using the content_size_ here looks suspicious - check. return {inline_offset, content_size_}; } @@ -199,17 +218,20 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgorithm::Layout() { // within a previous fragment. content_size_ = BreakToken() ? LayoutUnit() : border_and_padding_.block_start; - curr_margin_strut_ = ConstraintSpace().MarginStrut(); - curr_bfc_offset_ = ConstraintSpace().BfcOffset(); + NGMarginStrut input_margin_strut = ConstraintSpace().MarginStrut(); + LayoutUnit input_bfc_block_offset = + ConstraintSpace().BfcOffset().block_offset; // Margins collapsing: // Do not collapse margins between parent and its child if there is // border/padding between them. if (border_and_padding_.block_start) { - curr_bfc_offset_.block_offset += curr_margin_strut_.Sum(); - MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_, + input_bfc_block_offset += input_margin_strut.Sum(); + MaybeUpdateFragmentBfcOffset(ConstraintSpace(), input_bfc_block_offset, &container_builder_); - curr_margin_strut_ = NGMarginStrut(); + // We reset the block offset here as it may have been effected by clearance. + input_bfc_block_offset = ContainerBfcOffset().block_offset; + input_margin_strut = NGMarginStrut(); } // If a new formatting context hits the margin collapsing if-branch above @@ -218,29 +240,34 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgorithm::Layout() { // If we are resuming layout from a break token the same rule applies. Margin // struts cannot pass through break tokens. if (ConstraintSpace().IsNewFormattingContext() || BreakToken()) { - MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_, + MaybeUpdateFragmentBfcOffset(ConstraintSpace(), input_bfc_block_offset, &container_builder_); - DCHECK_EQ(curr_margin_strut_, NGMarginStrut()); + DCHECK_EQ(input_margin_strut, NGMarginStrut()); DCHECK_EQ(container_builder_.BfcOffset().value(), NGLogicalOffset()); - curr_bfc_offset_ = {}; } - curr_bfc_offset_.block_offset += content_size_; + input_bfc_block_offset += content_size_; + + NGPreviousInflowPosition previous_inflow_position = { + input_bfc_block_offset, content_size_, input_margin_strut}; while (child) { if (child->IsOutOfFlowPositioned()) { DCHECK(!child_break_token); - HandleOutOfFlowPositioned(ToNGBlockNode(child)); + HandleOutOfFlowPositioned(previous_inflow_position, ToNGBlockNode(child)); } else if (child->IsFloating()) { - HandleFloating(ToNGBlockNode(child), + HandleFloating(previous_inflow_position, ToNGBlockNode(child), ToNGBlockBreakToken(child_break_token)); } else { - NGLogicalOffset child_bfc_offset = PrepareChildLayout(child); + NGInflowChildData child_data = + PrepareChildLayout(previous_inflow_position, child); RefPtr<NGConstraintSpace> child_space = - CreateConstraintSpaceForChild(child_bfc_offset, *child); + CreateConstraintSpaceForChild(*child, child_data); RefPtr<NGLayoutResult> layout_result = child->Layout(child_space.Get(), child_break_token); - FinishChildLayout(*child_space, child, layout_result.Get()); + previous_inflow_position = + FinishChildLayout(*child_space, previous_inflow_position, child_data, + child, layout_result.Get()); } entry = child_iterator.NextChild(); @@ -251,6 +278,9 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgorithm::Layout() { break; } + NGMarginStrut end_margin_strut = previous_inflow_position.margin_strut; + LayoutUnit end_bfc_block_offset = previous_inflow_position.bfc_block_offset; + // Margins collapsing: // Bottom margins of an in-flow block box doesn't collapse with its last // in-flow block-level child's bottom margin if the box has bottom @@ -258,8 +288,8 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgorithm::Layout() { content_size_ += border_and_padding_.block_end; if (border_and_padding_.block_end || ConstraintSpace().IsNewFormattingContext()) { - content_size_ += curr_margin_strut_.Sum(); - curr_margin_strut_ = NGMarginStrut(); + content_size_ += end_margin_strut.Sum(); + end_margin_strut = NGMarginStrut(); } // Recompute the block-axis size now that we know our content size. @@ -273,10 +303,10 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgorithm::Layout() { // Non-empty blocks always know their position in space. // TODO(ikilpatrick): This check for a break token seems error prone. if (size.block_size || BreakToken()) { - curr_bfc_offset_.block_offset += curr_margin_strut_.Sum(); - MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_, + end_bfc_block_offset += end_margin_strut.Sum(); + MaybeUpdateFragmentBfcOffset(ConstraintSpace(), end_bfc_block_offset, &container_builder_); - PositionPendingFloats(curr_bfc_offset_.block_offset, &container_builder_, + PositionPendingFloats(end_bfc_block_offset, &container_builder_, MutableConstraintSpace()); } @@ -285,9 +315,9 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgorithm::Layout() { // of its parent if the parent has height != auto() if (!Style().LogicalHeight().IsAuto()) { // TODO(glebl): handle minLogicalHeight, maxLogicalHeight. - curr_margin_strut_ = NGMarginStrut(); + end_margin_strut = NGMarginStrut(); } - container_builder_.SetEndMarginStrut(curr_margin_strut_); + container_builder_.SetEndMarginStrut(end_margin_strut); container_builder_.SetOverflowSize( NGLogicalSize(max_inline_size_, content_size_)); @@ -302,33 +332,32 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgorithm::Layout() { return container_builder_.ToBoxFragment(); } -void NGBlockLayoutAlgorithm::HandleOutOfFlowPositioned(NGBlockNode* child) { - NGLogicalOffset offset = {border_and_padding_.inline_start, content_size_}; +void NGBlockLayoutAlgorithm::HandleOutOfFlowPositioned( + const NGPreviousInflowPosition& previous_inflow_position, + NGBlockNode* child) { + NGLogicalOffset offset = {border_and_padding_.inline_start, + previous_inflow_position.logical_block_offset}; // We only include the margin strut in the OOF static-position if we know we // aren't going to be a zero-block-size fragment. if (container_builder_.BfcOffset()) - offset.block_offset += curr_margin_strut_.Sum(); + offset.block_offset += previous_inflow_position.margin_strut.Sum(); container_builder_.AddOutOfFlowChildCandidate(child, offset); } -void NGBlockLayoutAlgorithm::HandleFloating(NGBlockNode* child, - NGBlockBreakToken* token) { - // TODO(ikilpatrick): Pass in BFC offset from previous in-flow child. - curr_bfc_offset_ = container_builder_.BfcOffset() - ? container_builder_.BfcOffset().value() - : ConstraintSpace().BfcOffset(); - curr_bfc_offset_.block_offset += content_size_; - +void NGBlockLayoutAlgorithm::HandleFloating( + const NGPreviousInflowPosition& previous_inflow_position, + NGBlockNode* child, + NGBlockBreakToken* token) { // Calculate margins in the BFC's writing mode. - curr_child_margins_ = CalculateMargins(child); + NGBoxStrut margins = CalculateMargins(child); NGLogicalOffset origin_offset = constraint_space_->BfcOffset(); origin_offset.inline_offset += border_and_padding_.inline_start; RefPtr<NGUnpositionedFloat> unpositioned_float = NGUnpositionedFloat::Create( child_available_size_, child_percentage_size_, origin_offset, - constraint_space_->BfcOffset(), curr_child_margins_, child, token); + constraint_space_->BfcOffset(), margins, child, token); container_builder_.AddUnpositionedFloat(unpositioned_float); // If there is a break token for a float we must be resuming layout, we must @@ -337,29 +366,28 @@ void NGBlockLayoutAlgorithm::HandleFloating(NGBlockNode* child, // No need to postpone the positioning if we know the correct offset. if (container_builder_.BfcOffset()) { - NGLogicalOffset origin_point = curr_bfc_offset_; // Adjust origin point to the margins of the last child. // Example: <div style="margin-bottom: 20px"><float></div> // <div style="margin-bottom: 30px"></div> - origin_point.block_offset += curr_margin_strut_.Sum(); - PositionPendingFloats(origin_point.block_offset, &container_builder_, + LayoutUnit origin_block_offset = + previous_inflow_position.bfc_block_offset + + previous_inflow_position.margin_strut.Sum(); + PositionPendingFloats(origin_block_offset, &container_builder_, MutableConstraintSpace()); } } -NGLogicalOffset NGBlockLayoutAlgorithm::PrepareChildLayout( +NGInflowChildData NGBlockLayoutAlgorithm::PrepareChildLayout( + const NGPreviousInflowPosition& previous_inflow_position, NGLayoutInputNode* child) { DCHECK(child); DCHECK(!child->IsFloating()); - // TODO(ikilpatrick): Pass in BFC offset from previous in-flow child. - curr_bfc_offset_ = container_builder_.BfcOffset() - ? container_builder_.BfcOffset().value() - : ConstraintSpace().BfcOffset(); - curr_bfc_offset_.block_offset += content_size_; + LayoutUnit bfc_block_offset = previous_inflow_position.bfc_block_offset; // Calculate margins in parent's writing mode. - curr_child_margins_ = CalculateMargins(child); + NGBoxStrut margins = CalculateMargins(child); + NGMarginStrut margin_strut = previous_inflow_position.margin_strut; bool should_position_pending_floats = !IsNewFormattingContextForBlockLevelChild(Style(), *child) && @@ -371,45 +399,50 @@ NGLogicalOffset NGBlockLayoutAlgorithm::PrepareChildLayout( // be positioned before layout. This also resolves the fragment's bfc offset. if (should_position_pending_floats) { LayoutUnit origin_point_block_offset = - curr_bfc_offset_.block_offset + curr_margin_strut_.Sum(); - MaybeUpdateFragmentBfcOffset( - ConstraintSpace(), - {curr_bfc_offset_.inline_offset, origin_point_block_offset}, - &container_builder_); + bfc_block_offset + margin_strut.Sum(); + MaybeUpdateFragmentBfcOffset(ConstraintSpace(), origin_point_block_offset, + &container_builder_); + // TODO(ikilpatrick): Check if origin_point_block_offset is correct - + // MaybeUpdateFragmentBfcOffset might have changed it due to clearance. PositionPendingFloats(origin_point_block_offset, &container_builder_, MutableConstraintSpace()); } - NGLogicalOffset child_bfc_offset = curr_bfc_offset_; - child_bfc_offset.inline_offset += - {border_and_padding_.inline_start + curr_child_margins_.inline_start}; + NGLogicalOffset child_bfc_offset = { + ConstraintSpace().BfcOffset().inline_offset + + border_and_padding_.inline_start + margins.inline_start, + bfc_block_offset}; + + bool is_new_fc = IsNewFormattingContextForBlockLevelChild(Style(), *child); // Append the current margin strut with child's block start margin. // Non empty border/padding, and new FC use cases are handled inside of the // child's layout. - if (!IsNewFormattingContextForBlockLevelChild(Style(), *child)) - curr_margin_strut_.Append(curr_child_margins_.block_start); + if (!is_new_fc) + margin_strut.Append(margins.block_start); // TODO(crbug.com/716930): We should also collapse margins below once we // remove LayoutInline splitting. // Should collapse margins if our child is a legacy block. - if (IsLegacyBlock(*child)) { - curr_bfc_offset_ += - {border_and_padding_.inline_start + curr_child_margins_.inline_start, - curr_margin_strut_.Sum()}; - MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_, - &container_builder_); - PositionPendingFloats(curr_bfc_offset_.block_offset, &container_builder_, + // TODO(ikilpatrick): I think this can be removed. + if (IsLegacyBlock(*child) && !is_new_fc) { + child_bfc_offset.block_offset += margin_strut.Sum(); + MaybeUpdateFragmentBfcOffset( + ConstraintSpace(), child_bfc_offset.block_offset, &container_builder_); + // TODO(ikilpatrick): Check if child_bfc_offset.block_offset is correct - + // MaybeUpdateFragmentBfcOffset might have changed it due to clearance. + PositionPendingFloats(child_bfc_offset.block_offset, &container_builder_, MutableConstraintSpace()); - curr_margin_strut_ = {}; + margin_strut = {}; } - child_bfc_offset.block_offset = curr_bfc_offset_.block_offset; - return child_bfc_offset; + return {child_bfc_offset, margin_strut, margins}; } -void NGBlockLayoutAlgorithm::FinishChildLayout( +NGPreviousInflowPosition NGBlockLayoutAlgorithm::FinishChildLayout( const NGConstraintSpace& child_space, + const NGPreviousInflowPosition& previous_inflow_position, + const NGInflowChildData& child_data, const NGLayoutInputNode* child, NGLayoutResult* layout_result) { // Pull out unpositioned floats to the current fragment. This may needed if @@ -425,97 +458,134 @@ void NGBlockLayoutAlgorithm::FinishChildLayout( // Determine the fragment's position in the parent space. WTF::Optional<NGLogicalOffset> child_bfc_offset; if (child_space.IsNewFormattingContext()) - child_bfc_offset = PositionNewFc(fragment, child_space); + child_bfc_offset = PositionNewFc(*child, previous_inflow_position, fragment, + child_data, child_space); else if (fragment.BfcOffset()) child_bfc_offset = PositionWithBfcOffset(fragment); else if (IsLegacyBlock(*child)) - child_bfc_offset = PositionLegacy(child_space); + child_bfc_offset = PositionLegacy(child_space, child_data); else if (container_builder_.BfcOffset()) - child_bfc_offset = PositionWithParentBfc(child_space, fragment); + child_bfc_offset = PositionWithParentBfc(child_space, child_data, fragment); - NGLogicalOffset logical_offset = CalculateLogicalOffset(child_bfc_offset); + NGLogicalOffset logical_offset = + CalculateLogicalOffset(child_data.margins, child_bfc_offset); - // Update margin strut. - curr_margin_strut_ = fragment.EndMarginStrut(); - curr_margin_strut_.Append(curr_child_margins_.block_end); + NGMarginStrut margin_strut = fragment.EndMarginStrut(); + margin_strut.Append(child_data.margins.block_end); - // Only modify content_size if BlockSize is not empty. It's needed to prevent - // the situation when logical_offset is included in content_size for empty - // blocks. Example: + // Only modify content_size_ if the fragment's BlockSize is not empty. This is + // needed to prevent the situation when logical_offset is included in + // content_size_ for empty blocks. Example: // <div style="overflow:hidden"> // <div style="margin-top: 8px"></div> // <div style="margin-top: 10px"></div> // </div> if (fragment.BlockSize()) - content_size_ = fragment.BlockSize() + logical_offset.block_offset; - max_inline_size_ = - std::max(max_inline_size_, fragment.InlineSize() + - curr_child_margins_.InlineSum() + - border_and_padding_.InlineSum()); + content_size_ = std::max( + content_size_, logical_offset.block_offset + fragment.BlockSize()); + max_inline_size_ = std::max( + max_inline_size_, fragment.InlineSize() + child_data.margins.InlineSum() + + border_and_padding_.InlineSum()); container_builder_.AddChild(layout_result, logical_offset); + + // Determine the child's end BFC block offset for the next child to use. + LayoutUnit child_end_bfc_block_offset; + if (child_bfc_offset) { + // TODO(crbug.com/716930): I think the fragment.BfcOffset() condition here + // can be removed once we've removed inline splitting. + if (fragment.BlockSize() || fragment.BfcOffset()) { + child_end_bfc_block_offset = + child_bfc_offset.value().block_offset + fragment.BlockSize(); + } else { + DCHECK_EQ(LayoutUnit(), fragment.BlockSize()); + child_end_bfc_block_offset = previous_inflow_position.bfc_block_offset; + } + } else { + child_end_bfc_block_offset = ConstraintSpace().BfcOffset().block_offset; + } + + return {child_end_bfc_block_offset, + logical_offset.block_offset + fragment.BlockSize(), margin_strut}; } NGLogicalOffset NGBlockLayoutAlgorithm::PositionNewFc( + const NGLayoutInputNode& child, + const NGPreviousInflowPosition& previous_inflow_position, const NGBoxFragment& fragment, + const NGInflowChildData& child_data, const NGConstraintSpace& child_space) { + const ComputedStyle& child_style = child.Style(); + + LayoutUnit child_bfc_offset_estimate = + child_data.bfc_offset_estimate.block_offset; + // 1. Position all pending floats to a temporary space. RefPtr<NGConstraintSpace> tmp_space = NGConstraintSpaceBuilder(&child_space) .SetIsNewFormattingContext(false) .ToConstraintSpace(child_space.WritingMode()); - PositionFloats(curr_bfc_offset_.block_offset, curr_bfc_offset_.block_offset, - curr_bfc_offset_.block_offset, + PositionFloats(child_bfc_offset_estimate, child_bfc_offset_estimate, + child_bfc_offset_estimate, container_builder_.UnpositionedFloats(), tmp_space.Get()); - NGLogicalOffset origin_offset = curr_bfc_offset_; - origin_offset.inline_offset += border_and_padding_.inline_start; + NGLogicalOffset origin_offset = {ConstraintSpace().BfcOffset().inline_offset + + border_and_padding_.inline_start, + child_bfc_offset_estimate}; + AdjustToClearance( + GetClearanceOffset(ConstraintSpace().Exclusions(), child_style.Clear()), + &origin_offset); // 2. Find an estimated layout opportunity for our fragment. NGLayoutOpportunity opportunity = FindLayoutOpportunityForFragment( tmp_space->Exclusions().get(), child_space.AvailableSize(), origin_offset, - curr_child_margins_, fragment.Size()); + child_data.margins, fragment.Size()); + + NGMarginStrut margin_strut = previous_inflow_position.margin_strut; // 3. If the found opportunity lies on the same line with our estimated // child's BFC offset then merge fragment's margins with the current // MarginStrut. - if (opportunity.offset.block_offset == curr_bfc_offset_.block_offset) - curr_margin_strut_.Append(curr_child_margins_.block_start); - curr_bfc_offset_.block_offset += curr_margin_strut_.Sum(); - curr_margin_strut_ = {}; + if (opportunity.offset.block_offset == child_bfc_offset_estimate) + margin_strut.Append(child_data.margins.block_start); + child_bfc_offset_estimate += margin_strut.Sum(); // 4. The child's BFC block offset is known here. - MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_, + MaybeUpdateFragmentBfcOffset(ConstraintSpace(), child_bfc_offset_estimate, &container_builder_); - PositionPendingFloats(curr_bfc_offset_.block_offset, &container_builder_, + PositionPendingFloats(child_bfc_offset_estimate, &container_builder_, MutableConstraintSpace()); - origin_offset = curr_bfc_offset_; - origin_offset.inline_offset += border_and_padding_.inline_start; + origin_offset = {ConstraintSpace().BfcOffset().inline_offset + + border_and_padding_.inline_start, + child_bfc_offset_estimate}; + AdjustToClearance( + GetClearanceOffset(ConstraintSpace().Exclusions(), child_style.Clear()), + &origin_offset); // 5. Find the final layout opportunity for the fragment after all pending // floats are positioned at the correct BFC block's offset. opportunity = FindLayoutOpportunityForFragment( MutableConstraintSpace()->Exclusions().get(), child_space.AvailableSize(), - origin_offset, curr_child_margins_, fragment.Size()); + origin_offset, child_data.margins, fragment.Size()); - curr_bfc_offset_ = opportunity.offset; - return curr_bfc_offset_; + return opportunity.offset; } NGLogicalOffset NGBlockLayoutAlgorithm::PositionWithBfcOffset( const NGBoxFragment& fragment) { DCHECK(fragment.BfcOffset()); - curr_bfc_offset_.block_offset = fragment.BfcOffset().value().block_offset; - MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_, + LayoutUnit bfc_block_offset = fragment.BfcOffset().value().block_offset; + MaybeUpdateFragmentBfcOffset(ConstraintSpace(), bfc_block_offset, &container_builder_); - PositionPendingFloats(curr_bfc_offset_.block_offset, &container_builder_, + PositionPendingFloats(bfc_block_offset, &container_builder_, MutableConstraintSpace()); return fragment.BfcOffset().value(); } NGLogicalOffset NGBlockLayoutAlgorithm::PositionWithParentBfc( const NGConstraintSpace& space, + const NGInflowChildData& child_data, const NGBoxFragment& fragment) { // The child must be an in-flow zero-block-size fragment, use its end margin // strut for positioning. @@ -523,22 +593,28 @@ NGLogicalOffset NGBlockLayoutAlgorithm::PositionWithParentBfc( DCHECK_EQ(fragment.BlockSize(), LayoutUnit()); NGMarginStrut margin_strut = fragment.EndMarginStrut(); - margin_strut.Append(curr_child_margins_.block_end); - - curr_bfc_offset_ += - {border_and_padding_.inline_start + curr_child_margins_.inline_start, - margin_strut.Sum()}; - AdjustToClearance(space.ClearanceOffset(), &curr_bfc_offset_); - PositionPendingFloatsFromOffset( - curr_bfc_offset_.block_offset, curr_bfc_offset_.block_offset, - &container_builder_, MutableConstraintSpace()); - return curr_bfc_offset_; + margin_strut.Append(child_data.margins.block_end); + + NGLogicalOffset bfc_offset = { + ConstraintSpace().BfcOffset().inline_offset + + border_and_padding_.inline_start + child_data.margins.inline_start, + child_data.bfc_offset_estimate.block_offset + margin_strut.Sum()}; + AdjustToClearance(space.ClearanceOffset(), &bfc_offset); + PositionPendingFloatsFromOffset(bfc_offset.block_offset, + bfc_offset.block_offset, &container_builder_, + MutableConstraintSpace()); + return bfc_offset; } NGLogicalOffset NGBlockLayoutAlgorithm::PositionLegacy( - const NGConstraintSpace& child_space) { - AdjustToClearance(child_space.ClearanceOffset(), &curr_bfc_offset_); - return curr_bfc_offset_; + const NGConstraintSpace& child_space, + const NGInflowChildData& child_data) { + NGLogicalOffset bfc_offset = {ConstraintSpace().BfcOffset().inline_offset + + border_and_padding_.inline_start + + child_data.margins.inline_start, + child_data.bfc_offset_estimate.block_offset}; + AdjustToClearance(child_space.ClearanceOffset(), &bfc_offset); + return bfc_offset; } void NGBlockLayoutAlgorithm::FinalizeForFragmentation() { @@ -609,8 +685,8 @@ NGBoxStrut NGBlockLayoutAlgorithm::CalculateMargins(NGLayoutInputNode* child) { } RefPtr<NGConstraintSpace> NGBlockLayoutAlgorithm::CreateConstraintSpaceForChild( - const NGLogicalOffset& child_bfc_offset, - const NGLayoutInputNode& child) { + const NGLayoutInputNode& child, + const NGInflowChildData& child_data) { NGConstraintSpaceBuilder space_builder(MutableConstraintSpace()); space_builder.SetAvailableSize(child_available_size_) .SetPercentageResolutionSize(child_percentage_size_); @@ -618,8 +694,8 @@ RefPtr<NGConstraintSpace> NGBlockLayoutAlgorithm::CreateConstraintSpaceForChild( const ComputedStyle& child_style = child.Style(); bool is_new_bfc = IsNewFormattingContextForBlockLevelChild(Style(), child); space_builder.SetIsNewFormattingContext(is_new_bfc) - .SetBfcOffset(child_bfc_offset) - .SetMarginStrut(curr_margin_strut_); + .SetBfcOffset(child_data.bfc_offset_estimate) + .SetMarginStrut(child_data.margin_strut); if (!is_new_bfc) { space_builder.SetUnpositionedFloats( @@ -646,7 +722,7 @@ RefPtr<NGConstraintSpace> NGBlockLayoutAlgorithm::CreateConstraintSpaceForChild( // position in the formatting context, and are able to adjust the // fragmentation line. if (is_new_bfc) { - space_available -= child_bfc_offset.block_offset; + space_available -= child_data.bfc_offset_estimate.block_offset; } } space_builder.SetFragmentainerSpaceAvailable(space_available); Index: third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.h diff --git a/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.h b/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.h index 9ce63c41d0663e66ba24618426cf899c58ee19c5..6b465109af92381fd70ea9c020ecea348a25e807 100644 --- a/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.h +++ b/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.h @@ -18,10 +18,12 @@ namespace blink { class NGConstraintSpace; class NGLayoutResult; +struct NGInflowChildData; +struct NGPreviousInflowPosition; // Updates the fragment's BFC offset if it's not already set. void MaybeUpdateFragmentBfcOffset(const NGConstraintSpace&, - const NGLogicalOffset&, + LayoutUnit bfc_block_offset, NGFragmentBuilder* builder); // Positions pending floats starting from {@origin_block_offset} and relative @@ -52,15 +54,19 @@ class CORE_EXPORT NGBlockLayoutAlgorithm // Creates a new constraint space for the current child. RefPtr<NGConstraintSpace> CreateConstraintSpaceForChild( - const NGLogicalOffset& child_bfc_offset, - const NGLayoutInputNode&); + const NGLayoutInputNode& child, + const NGInflowChildData& child_data); // @return Estimated BFC offset for the "to be layout" child. - NGLogicalOffset PrepareChildLayout(NGLayoutInputNode*); + NGInflowChildData PrepareChildLayout(const NGPreviousInflowPosition&, + NGLayoutInputNode*); - void FinishChildLayout(const NGConstraintSpace&, - const NGLayoutInputNode* child, - NGLayoutResult*); + NGPreviousInflowPosition FinishChildLayout( + const NGConstraintSpace&, + const NGPreviousInflowPosition& prev_data, + const NGInflowChildData& child_data, + const NGLayoutInputNode* child, + NGLayoutResult*); // Positions the fragment that establishes a new formatting context. // @@ -81,7 +87,10 @@ class CORE_EXPORT NGBlockLayoutAlgorithm // then it will be placed there and we collapse its margin. // 2) If #new-fc is too big then we need to clear its position and place it // below #float ignoring its vertical margin. - NGLogicalOffset PositionNewFc(const NGBoxFragment&, + NGLogicalOffset PositionNewFc(const NGLayoutInputNode& child, + const NGPreviousInflowPosition&, + const NGBoxFragment&, + const NGInflowChildData& child_data, const NGConstraintSpace& child_space); // Positions the fragment that knows its BFC offset. @@ -95,12 +104,16 @@ class CORE_EXPORT NGBlockLayoutAlgorithm // <div style="padding: 1px"> // <div id="empty-div" style="margins: 1px"></div> NGLogicalOffset PositionWithParentBfc(const NGConstraintSpace&, + const NGInflowChildData& child_data, const NGBoxFragment&); - NGLogicalOffset PositionLegacy(const NGConstraintSpace& child_space); + NGLogicalOffset PositionLegacy(const NGConstraintSpace& child_space, + const NGInflowChildData& child_data); - void HandleOutOfFlowPositioned(NGBlockNode*); - void HandleFloating(NGBlockNode*, NGBlockBreakToken*); + void HandleOutOfFlowPositioned(const NGPreviousInflowPosition&, NGBlockNode*); + void HandleFloating(const NGPreviousInflowPosition&, + NGBlockNode*, + NGBlockBreakToken*); // Final adjustments before fragment creation. We need to prevent the // fragment from crossing fragmentainer boundaries, and rather create a break @@ -112,6 +125,7 @@ class CORE_EXPORT NGBlockLayoutAlgorithm // or {@code known_fragment_offset} if the fragment knows it's offset // @return Fragment's offset relative to the fragment's parent. NGLogicalOffset CalculateLogicalOffset( + const NGBoxStrut& child_margins, const WTF::Optional<NGLogicalOffset>& known_fragment_offset); NGLogicalSize child_available_size_; @@ -120,10 +134,6 @@ class CORE_EXPORT NGBlockLayoutAlgorithm NGBoxStrut border_and_padding_; LayoutUnit content_size_; LayoutUnit max_inline_size_; - // MarginStrut for the previous child. - NGMarginStrut curr_margin_strut_; - NGLogicalOffset curr_bfc_offset_; - NGBoxStrut curr_child_margins_; }; } // namespace blink
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor