// Copyright 2016 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifdef UNSAFE_BUFFERS_BUILD // TODO(crbug.com/351564777): Remove this and convert code to safer constructs. #pragma allow_unsafe_buffers #endif #include "third_party/blink/renderer/core/layout/inline/line_breaker.h" #include "base/containers/adapters.h" #include "base/ranges/algorithm.h" #include "third_party/blink/renderer/core/frame/web_feature.h" #include "third_party/blink/renderer/core/layout/block_break_token.h" #include "third_party/blink/renderer/core/layout/constraint_space.h" #include "third_party/blink/renderer/core/layout/constraint_space_builder.h" #include "third_party/blink/renderer/core/layout/floats_utils.h" #include "third_party/blink/renderer/core/layout/fragmentation_utils.h" #include "third_party/blink/renderer/core/layout/inline/inline_break_token.h" #include "third_party/blink/renderer/core/layout/inline/inline_cursor.h" #include "third_party/blink/renderer/core/layout/inline/inline_item_result_ruby_column.h" #include "third_party/blink/renderer/core/layout/inline/inline_item_segment.h" #include "third_party/blink/renderer/core/layout/inline/inline_node.h" #include "third_party/blink/renderer/core/layout/inline/line_break_candidate.h" #include "third_party/blink/renderer/core/layout/inline/line_info.h" #include "third_party/blink/renderer/core/layout/inline/ruby_utils.h" #include "third_party/blink/renderer/core/layout/layout_object_inlines.h" #include "third_party/blink/renderer/core/layout/layout_text_combine.h" #include "third_party/blink/renderer/core/layout/length_utils.h" #include "third_party/blink/renderer/core/layout/logical_fragment.h" #include "third_party/blink/renderer/core/layout/physical_box_fragment.h" #include "third_party/blink/renderer/core/layout/positioned_float.h" #include "third_party/blink/renderer/core/layout/space_utils.h" #include "third_party/blink/renderer/core/layout/svg/resolved_text_layout_attributes_iterator.h" #include "third_party/blink/renderer/core/layout/unpositioned_float.h" #include "third_party/blink/renderer/core/style/computed_style.h" #include "third_party/blink/renderer/core/svg/svg_text_content_element.h" #include "third_party/blink/renderer/platform/fonts/shaping/shape_result_view.h" #include "third_party/blink/renderer/platform/fonts/shaping/shaping_line_breaker.h" #include "third_party/blink/renderer/platform/text/bidi_paragraph.h" #include "third_party/blink/renderer/platform/text/character.h" namespace blink { namespace { inline LineBreakStrictness StrictnessFromLineBreak(LineBreak line_break) { … } // Returns smallest negative left and right bearing in `box_fragment`. // This function is used for calculating side bearing. LineBoxStrut ComputeNegativeSideBearings( const PhysicalBoxFragment& box_fragment) { … } // This rule comes from the spec[1]. // Note: We don't apply inline kerning for vertical writing mode with text // orientation other than `sideways` because characters are laid out vertically. // [1] https://drafts.csswg.org/css-inline/#initial-letter-inline-position bool ShouldApplyInlineKerning(const PhysicalBoxFragment& box_fragment) { … } // CSS-defined white space characters, excluding the newline character. // In most cases, the line breaker consider break opportunities are before // spaces because it handles trailing spaces differently from other normal // characters, but breaking before newline characters is not desired. inline bool IsBreakableSpace(UChar c) { … } inline bool IsBreakableSpaceOrOtherSeparator(UChar c) { … } inline bool IsAllBreakableSpaces(const String& string, unsigned start, unsigned end) { … } inline bool IsBidiTrailingSpace(UChar c) { … } inline LayoutUnit HyphenAdvance(const ComputedStyle& style, bool is_ltr, const HyphenResult& hyphen_result, std::optional<LayoutUnit>& cache) { … } // True if the item is "trailable". Trailable items should be included in the // line if they are after the soft wrap point. // // Note that some items are ambiguous; e.g., text is trailable if it has leading // spaces, and open tags are trailable if spaces follow. This function returns // true for such cases. inline bool IsTrailableItemType(InlineItem::InlineItemType type) { … } inline bool CanBreakAfterLast(const InlineItemResults& item_results) { … } inline bool ShouldCreateLineBox(const InlineItemResults& item_results) { … } inline bool HasUnpositionedFloats(const InlineItemResults& item_results) { … } LayoutUnit ComputeInlineEndSize(const ConstraintSpace& space, const ComputedStyle* style) { … } bool NeedsAccurateEndPosition(const InlineItem& line_end_item) { … } inline bool NeedsAccurateEndPosition(const LineInfo& line_info, const InlineItem& line_end_item) { … } inline void ComputeCanBreakAfter(InlineItemResult* item_result, bool auto_wrap, const LazyLineBreakIterator& break_iterator) { … } inline void RemoveLastItem(LineInfo* line_info) { … } // To correctly determine if a float is allowed to be on the same line as its // content, we need to determine if it has any ancestors with inline-end // padding, border, or margin. // The inline-end size from all of these ancestors contribute to the "used // size" of the float, and may cause the float to be pushed down. LayoutUnit ComputeFloatAncestorInlineEndSize( const ConstraintSpace& space, const HeapVector<InlineItem>& items, wtf_size_t item_index) { … } // See LineBreaker::SplitTextIntoSegments(). void CollectCharIndex(void* context, unsigned char_index, Glyph, gfx::Vector2dF, float, bool, CanvasRotationInVertical, const SimpleFontData*) { … } inline LayoutTextCombine* MayBeTextCombine(const InlineItem* item) { … } LayoutUnit MaxLineWidth(const LineInfo& base_line, const HeapVector<LineInfo, 1>& annotation_lines) { … } // Represents data associated with an `InlineItemResult`. class FastMinTextContext { … }; } // namespace inline bool LineBreaker::ShouldAutoWrap(const ComputedStyle& style) const { … } void LineBreaker::UpdateAvailableWidth() { … } LineBreaker::LineBreaker(InlineNode node, LineBreakerMode mode, const ConstraintSpace& space, const LineLayoutOpportunity& line_opportunity, const LeadingFloats& leading_floats, const InlineBreakToken* break_token, const ColumnSpannerPath* column_spanner_path, ExclusionSpace* exclusion_space) : … { … } LineBreaker::~LineBreaker() = default; void LineBreaker::SetLineOpportunity( const LineLayoutOpportunity& line_opportunity) { … } void LineBreaker::OverrideAvailableWidth(LayoutUnit available_width) { … } void LineBreaker::SetBreakAt(const LineBreakPoint& offset) { … } inline InlineItemResult* LineBreaker::AddItem(const InlineItem& item, unsigned end_offset, LineInfo* line_info) { … } inline InlineItemResult* LineBreaker::AddItem(const InlineItem& item, LineInfo* line_info) { … } InlineItemResult* LineBreaker::AddEmptyItem(const InlineItem& item, LineInfo* line_info) { … } // Call |HandleOverflow()| if the position is beyond the available space. inline bool LineBreaker::HandleOverflowIfNeeded(LineInfo* line_info) { … } void LineBreaker::SetIntrinsicSizeOutputs( MaxSizeCache* max_size_cache, bool* depends_on_block_constraints_out) { … } // Compute the base direction for bidi algorithm for this line. void LineBreaker::ComputeBaseDirection() { … } void LineBreaker::RecalcClonedBoxDecorations() { … } // Add a hyphen string to the |InlineItemResult|. // // This function changes |InlineItemResult::inline_size|, but does not change // |position_| LayoutUnit LineBreaker::AddHyphen(InlineItemResults* item_results, wtf_size_t index, InlineItemResult* item_result) { … } LayoutUnit LineBreaker::AddHyphen(InlineItemResults* item_results, wtf_size_t index) { … } LayoutUnit LineBreaker::AddHyphen(InlineItemResults* item_results, InlineItemResult* item_result) { … } // Remove the hyphen string from the |InlineItemResult|. // // This function changes |InlineItemResult::inline_size|, but does not change // |position_| LayoutUnit LineBreaker::RemoveHyphen(InlineItemResults* item_results) { … } // Add a hyphen string to the last inflow item in |item_results| if it is // hyphenated. This can restore the hyphenation state after rewind. void LineBreaker::RestoreLastHyphen(InlineItemResults* item_results) { … } // Set the final hyphenation results to |item_results|. void LineBreaker::FinalizeHyphen(InlineItemResults* item_results) { … } // Initialize internal states for the next line. void LineBreaker::PrepareNextLine(LineInfo* line_info) { … } void LineBreaker::NextLine(LineInfo* line_info) { … } void LineBreaker::BreakLine(LineInfo* line_info) { … } void LineBreaker::ComputeLineLocation(LineInfo* line_info) const { … } // Atomic inlines have break opportunities before and after, even when the // adjacent character is U+00A0 NO-BREAK SPACE character, except when sticky // images quirk is applied. // Note: We treat text combine as text content instead of atomic inline box[1]. // [1] https://drafts.csswg.org/css-writing-modes-3/#text-combine-layout bool LineBreaker::CanBreakAfterAtomicInline(const InlineItem& item) const { … } bool LineBreaker::CanBreakAfter(const InlineItem& item) const { … } bool LineBreaker::MayBeAtomicInline(wtf_size_t offset) const { … } const InlineItem* LineBreaker::TryGetAtomicInlineItemAfter( const InlineItem& item) const { … } unsigned LineBreaker::IgnorableBidiControlLength(const InlineItem& item) const { … } void LineBreaker::HandleText(const InlineItem& item, const ShapeResult& shape_result, LineInfo* line_info) { … } // In SVG <text>, we produce InlineItemResult split into segments partitioned // by x/y/dx/dy/rotate attributes. // // Split in PrepareLayout() or after producing FragmentItem would need // additional memory overhead. So we split in LineBreaker while it converts // InlineItems to InlineItemResults. void LineBreaker::SplitTextIntoSegments(const InlineItem& item, LineInfo* line_info) { … } bool LineBreaker::ShouldCreateNewSvgSegment() const { … } LineBreaker::BreakResult LineBreaker::BreakText( InlineItemResult* item_result, const InlineItem& item, const ShapeResult& item_shape_result, LayoutUnit available_width, LayoutUnit available_width_with_hyphens, LineInfo* line_info) { … } bool LineBreaker::BreakTextAt(InlineItemResult* item_result, const InlineItem& item, ShapingLineBreaker& breaker, LineInfo* line_info) { … } // Breaks the text item at the previous break opportunity from // |item_result->text_offset.end|. Returns false if there were no previous break // opportunities. bool LineBreaker::BreakTextAtPreviousBreakOpportunity( InlineItemResult* item_result) { … } // This function handles text item for min-content. The specialized logic is // because min-content is very expensive by breaking at every break opportunity // and producing as many lines as the number of break opportunities. // // This function breaks the text in InlineItem at every break opportunity, // computes the maximum width of all words, and creates one InlineItemResult // that has the maximum width. For example, for a text item of "1 2 34 5 6", // only the width of "34" matters for min-content. // // The first word and the last word, "1" and "6" in the example above, are // handled in normal |HandleText()| because they may form a word with the // previous/next item. bool LineBreaker::HandleTextForFastMinContent(InlineItemResult* item_result, const InlineItem& item, const ShapeResult& shape_result, LineInfo* line_info) { … } void LineBreaker::HandleEmptyText(const InlineItem& item, LineInfo* line_info) { … } // Re-shape the specified range of |InlineItem|. const ShapeResult* LineBreaker::ShapeText(const InlineItem& item, unsigned start, unsigned end, ShapeOptions options) { … } void LineBreaker::AppendCandidates(const InlineItemResult& item_result, const LineInfo& line_info, LineBreakCandidateContext& context) { … } bool LineBreaker::CanBreakInside(const LineInfo& line_info) { … } bool LineBreaker::CanBreakInside(const InlineItemResult& item_result) { … } // Compute a new ShapeResult for the specified end offset. // The end is re-shaped if it is not safe-to-break. const ShapeResultView* LineBreaker::TruncateLineEndResult( const LineInfo& line_info, const InlineItemResult& item_result, unsigned end_offset) { … } // Update |ShapeResult| in |item_result| to match to its |start_offset| and // |end_offset|. The end is re-shaped if it is not safe-to-break. void LineBreaker::UpdateShapeResult(const LineInfo& line_info, InlineItemResult* item_result) { … } inline void LineBreaker::HandleTrailingSpaces(const InlineItem& item, LineInfo* line_info) { … } void LineBreaker::HandleTrailingSpaces(const InlineItem& item, const ShapeResult* shape_result, LineInfo* line_info) { … } void LineBreaker::RewindTrailingOpenTags(LineInfo* line_info) { … } // Remove trailing collapsible spaces in |line_info|. // https://drafts.csswg.org/css-text-3/#white-space-phase-2 void LineBreaker::RemoveTrailingCollapsibleSpace(LineInfo* line_info) { … } // Compute the width of trailing spaces without removing it. LayoutUnit LineBreaker::TrailingCollapsibleSpaceWidth(LineInfo* line_info) { … } // Find trailing collapsible space if exists. The result is cached to // |trailing_collapsible_space_|. void LineBreaker::ComputeTrailingCollapsibleSpace(LineInfo* line_info) { … } // Per UAX#9 L1, any spaces logically at the end of a line must be reset to the // paragraph's bidi level. If there are any such trailing spaces in an item // result together with other non-space characters, this method splits them into // their own item result. // // Furthermore, item results can't override their item's bidi level, so this // method instead marks all such item results with `has_only_trailing_spaces`, // which will cause them to be treated as having the base bidi level in // InlineLayoutAlgorithm::BidiReorder. void LineBreaker::SplitTrailingBidiPreservedSpace(LineInfo* line_info) { … } // |item| is |nullptr| if this is an implicit forced break. void LineBreaker::HandleForcedLineBreak(const InlineItem* item, LineInfo* line_info) { … } // Measure control items; new lines and tab, that are similar to text, affect // layout, but do not need shaping/painting. void LineBreaker::HandleControlItem(const InlineItem& item, LineInfo* line_info) { … } void LineBreaker::HandleBidiControlItem(const InlineItem& item, LineInfo* line_info) { … } void LineBreaker::HandleAtomicInline(const InlineItem& item, LineInfo* line_info) { … } void LineBreaker::ComputeMinMaxContentSizeForBlockChild( const InlineItem& item, InlineItemResult* item_result) { … } void LineBreaker::HandleBlockInInline(const InlineItem& item, const BlockBreakToken* block_break_token, LineInfo* line_info) { … } bool LineBreaker::HandleRuby(LineInfo* line_info, LayoutUnit retry_size) { … } bool LineBreaker::IsMonolithicRuby( const LineInfo& base_line, const HeapVector<LineInfo, 1>& annotation_line_list) const { … } LineInfo LineBreaker::CreateSubLineInfo( InlineItemTextIndex start, wtf_size_t end_item_index, LineBreakerMode mode, LayoutUnit limit, WhitespaceState initial_whitespace_state) { … } InlineItemResult* LineBreaker::AddRubyColumnResult( const InlineItem& item, const LineInfo& base_line_info, const HeapVector<LineInfo, 1>& annotation_line_list, const Vector<AnnotationBreakTokenData, 1>& annotation_data_list, LayoutUnit ruby_size, bool is_continuation, LineInfo& line_info) { … } bool LineBreaker::CanBreakAfterRubyColumn( const InlineItemResult& column_result, wtf_size_t column_end_item_index) const { … } // Figure out if the float should be pushed after the current line. This // should only be considered if we're not resuming the float, after having // broken inside or before it in the previous fragmentainer. Otherwise we must // attempt to place it. bool LineBreaker::ShouldPushFloatAfterLine( UnpositionedFloat* unpositioned_float, LineInfo* line_info) { … } // Performs layout and positions a float. // // If there is a known available_width (e.g. something has resolved the // container BFC block offset) it will attempt to position the float on the // current line. // Additionally updates the available_width for the line as the float has // (probably) consumed space. // // If the float is too wide *or* we already have UnpositionedFloats we add it // as an UnpositionedFloat. This should be positioned *immediately* after we // are done with the current line. // We have this check if there are already UnpositionedFloats as we aren't // allowed to position a float "above" another float which has come before us // in the document. void LineBreaker::HandleFloat(const InlineItem& item, const BlockBreakToken* float_break_token, LineInfo* line_info) { … } void LineBreaker::UpdateLineOpportunity() { … } // Restore the states changed by `HandleFloat` to before // `item_results[new_end]`. void LineBreaker::RewindFloats(unsigned new_end, LineInfo& line_info, InlineItemResults& item_results) { … } void LineBreaker::HandleInitialLetter(const InlineItem& item, LineInfo* line_info) { … } void LineBreaker::HandleOutOfFlowPositioned(const InlineItem& item, LineInfo* line_info) { … } bool LineBreaker::ComputeOpenTagResult(const InlineItem& item, const ConstraintSpace& constraint_space, bool is_in_svg_text, InlineItemResult* item_result) { … } void LineBreaker::HandleOpenTag(const InlineItem& item, LineInfo* line_info) { … } void LineBreaker::HandleCloseTag(const InlineItem& item, LineInfo* line_info) { … } // Handles when the last item overflows. // At this point, item_results does not fit into the current line, and there // are no break opportunities in item_results.back(). void LineBreaker::HandleOverflow(LineInfo* line_info) { … } void LineBreaker::RetryAfterOverflow(LineInfo* line_info, InlineItemResults* item_results) { … } // Rewind to |new_end| on overflow. If trailable items follow at |new_end|, they // are included (not rewound). void LineBreaker::RewindOverflow(unsigned new_end, LineInfo* line_info) { … } void LineBreaker::Rewind(unsigned new_end, LineInfo* line_info) { … } // Returns the style to use for |item_result_index|. Normally when handling // items sequentially, the current style is updated on open/close tag. When // rewinding, this function computes the style for the specified item. const ComputedStyle& LineBreaker::ComputeCurrentStyle( unsigned item_result_index, LineInfo* line_info) const { … } void LineBreaker::SetCurrentStyle(const ComputedStyle& style) { … } void LineBreaker::SetCurrentStyleForce(const ComputedStyle& style) { … } bool LineBreaker::IsPreviousItemOfType(InlineItem::InlineItemType type) { … } void LineBreaker::MoveToNextOf(const InlineItem& item) { … } void LineBreaker::MoveToNextOf(const InlineItemResult& item_result) { … } void LineBreaker::SetInputRange(InlineItemTextIndex start, wtf_size_t end_item_index, WhitespaceState initial_whitespace_state, const LineBreaker* parent) { … } const InlineBreakToken* LineBreaker::CreateBreakToken( const LineInfo& line_info) { … } } // namespace blink
Codebase Browser
chromium