Templatize NGInlineItemsBuilder to take a OffsetMappingBuilder parameter

third_party/WebKit/Source/core/layout/ng/inline/ng_inline_items_builder.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/ng/inline/ng_inline_items_builder.h"
 
 #include "core/layout/LayoutObject.h"
 #include "core/layout/ng/inline/ng_inline_node.h"
 #include "core/style/ComputedStyle.h"
 
 namespace blink {
 
-NGInlineItemsBuilder::~NGInlineItemsBuilder() {
+template <typename OffsetMappingBuilder>
+NGInlineItemsBuilderTemplate<
+    OffsetMappingBuilder>::~NGInlineItemsBuilderTemplate() {
   DCHECK_EQ(0u, exits_.size());
   DCHECK_EQ(text_.length(), items_->IsEmpty() ? 0 : items_->back().EndOffset());
 }
 
-String NGInlineItemsBuilder::ToString() {
+template <typename OffsetMappingBuilder>
+String NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::ToString() {
   // Segment Break Transformation Rules[1] defines to keep trailing new lines,
   // but it will be removed in Phase II[2]. We prefer not to add trailing new
   // lines and collapsible spaces in Phase I.
   // [1] https://drafts.csswg.org/css-text-3/#line-break-transform
   // [2] https://drafts.csswg.org/css-text-3/#white-space-phase-2
   RemoveTrailingCollapsibleSpaceIfExists();
 
   return text_.ToString();
 }
 
@@ skipping 87 matching lines @@
   return c == kSpaceCharacter || c == kTabulationCharacter ||
          c == kNewlineCharacter;
 }
 
 // Characters needing a separate control item than other text items.
 // It makes the line breaker easier to handle.
 static inline bool IsControlItemCharacter(UChar c) {
   return c == kTabulationCharacter || c == kNewlineCharacter;
 }
 
-void NGInlineItemsBuilder::Append(const String& string,
-                                  const ComputedStyle* style,
-                                  LayoutObject* layout_object) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::Append(
+    const String& string,
+    const ComputedStyle* style,
+    LayoutObject* layout_object) {
   if (string.IsEmpty())
     return;
   text_.ReserveCapacity(string.length());
 
   EWhiteSpace whitespace = style->WhiteSpace();
   if (!ComputedStyle::CollapseWhiteSpace(whitespace))
     return AppendWithoutWhiteSpaceCollapsing(string, style, layout_object);
   if (ComputedStyle::PreserveNewline(whitespace) && !is_svgtext_)
     return AppendWithPreservingNewlines(string, style, layout_object);
 
   AppendWithWhiteSpaceCollapsing(string, 0, string.length(), style,
                                  layout_object);
 }
 
-void NGInlineItemsBuilder::AppendWithWhiteSpaceCollapsing(
-    const String& string,
-    unsigned start,
-    unsigned end,
-    const ComputedStyle* style,
-    LayoutObject* layout_object) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::
+    AppendWithWhiteSpaceCollapsing(const String& string,
+                                   unsigned start,
+                                   unsigned end,
+                                   const ComputedStyle* style,
+                                   LayoutObject* layout_object) {
   unsigned start_offset = text_.length();
   for (unsigned i = start; i < end;) {
     UChar c = string[i];
     if (c == kNewlineCharacter) {
       // LayoutBR does not set preserve_newline, but should be preserved.
       if (!i && end == 1 && layout_object && layout_object->IsBR()) {
         AppendForcedBreak(style, layout_object);
         return;
       }
 
@@ skipping 27 matching lines @@
   }
 
   if (text_.length() > start_offset) {
     AppendItem(items_, NGInlineItem::kText, start_offset, text_.length(), style,
                layout_object);
   }
 }
 
 // Even when without whitespace collapsing, control characters (newlines and
 // tabs) are in their own control items to make the line breaker easier.
-void NGInlineItemsBuilder::AppendWithoutWhiteSpaceCollapsing(
-    const String& string,
-    const ComputedStyle* style,
-    LayoutObject* layout_object) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::
+    AppendWithoutWhiteSpaceCollapsing(const String& string,
+                                      const ComputedStyle* style,
+                                      LayoutObject* layout_object) {
   for (unsigned start = 0; start < string.length();) {
     UChar c = string[start];
     if (IsControlItemCharacter(c)) {
       Append(NGInlineItem::kControl, c, style, layout_object);
       start++;
       continue;
     }
 
     size_t end = string.Find(IsControlItemCharacter, start + 1);
     if (end == kNotFound)
       end = string.length();
     unsigned start_offset = text_.length();
     text_.Append(string, start, end - start);
     AppendItem(items_, NGInlineItem::kText, start_offset, text_.length(), style,
                layout_object);
     start = end;
   }
 
   last_collapsible_space_ = CollapsibleSpace::kNone;
 }
 
-void NGInlineItemsBuilder::AppendWithPreservingNewlines(
-    const String& string,
-    const ComputedStyle* style,
-    LayoutObject* layout_object) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::
+    AppendWithPreservingNewlines(const String& string,
+                                 const ComputedStyle* style,
+                                 LayoutObject* layout_object) {
   for (unsigned start = 0; start < string.length();) {
     if (string[start] == kNewlineCharacter) {
       AppendForcedBreak(style, layout_object);
       start++;
       continue;
     }
 
     size_t end = string.find(kNewlineCharacter, start + 1);
     if (end == kNotFound)
       end = string.length();
     AppendWithWhiteSpaceCollapsing(string, start, end, style, layout_object);
     start = end;
   }
 }
 
-void NGInlineItemsBuilder::AppendForcedBreak(const ComputedStyle* style,
-                                             LayoutObject* layout_object) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::AppendForcedBreak(
+    const ComputedStyle* style,
+    LayoutObject* layout_object) {
   // Remove collapsible spaces immediately before a preserved newline.
   RemoveTrailingCollapsibleSpaceIfExists();
 
   Append(NGInlineItem::kControl, kNewlineCharacter, style, layout_object);
 
   // Remove collapsible spaces immediately after a preserved newline.
   last_collapsible_space_ = CollapsibleSpace::kSpace;
 }
 
-void NGInlineItemsBuilder::Append(NGInlineItem::NGInlineItemType type,
-                                  UChar character,
-                                  const ComputedStyle* style,
-                                  LayoutObject* layout_object) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::Append(
+    NGInlineItem::NGInlineItemType type,
+    UChar character,
+    const ComputedStyle* style,
+    LayoutObject* layout_object) {
   DCHECK_NE(character, kSpaceCharacter);
   DCHECK_NE(character, kZeroWidthSpaceCharacter);
 
   text_.Append(character);
   unsigned end_offset = text_.length();
   AppendItem(items_, type, end_offset - 1, end_offset, style, layout_object);
   last_collapsible_space_ = CollapsibleSpace::kNone;
 }
 
-void NGInlineItemsBuilder::AppendOpaque(NGInlineItem::NGInlineItemType type,
-                                        UChar character) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::AppendOpaque(
+    NGInlineItem::NGInlineItemType type,
+    UChar character) {
   text_.Append(character);
   unsigned end_offset = text_.length();
   AppendItem(items_, type, end_offset - 1, end_offset, nullptr, nullptr);
 }
 
-void NGInlineItemsBuilder::AppendOpaque(NGInlineItem::NGInlineItemType type,
-                                        const ComputedStyle* style,
-                                        LayoutObject* layout_object) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::AppendOpaque(
+    NGInlineItem::NGInlineItemType type,
+    const ComputedStyle* style,
+    LayoutObject* layout_object) {
   unsigned end_offset = text_.length();
   AppendItem(items_, type, end_offset, end_offset, style, layout_object);
 }
 
 // Removes the collapsible newline at the end of |text_| if exists and the
 // removal conditions met.
-void NGInlineItemsBuilder::RemoveTrailingCollapsibleNewlineIfNeeded(
-    const String& after,
-    unsigned after_index,
-    const ComputedStyle* after_style) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::
+    RemoveTrailingCollapsibleNewlineIfNeeded(const String& after,
+                                             unsigned after_index,
+                                             const ComputedStyle* after_style) {
   DCHECK_EQ(last_collapsible_space_, CollapsibleSpace::kNewline);
 
   if (text_.IsEmpty() || text_[text_.length() - 1] != kSpaceCharacter)
     return;
 
   const ComputedStyle* before_style = after_style;
   if (!items_->IsEmpty()) {
     NGInlineItem& item = items_->back();
     if (text_.length() < item.EndOffset() + 2)
       before_style = item.Style();
   }
 
   if (ShouldRemoveNewline(text_, before_style, after, after_index, after_style))
     RemoveTrailingCollapsibleSpace(text_.length() - 1);
 }
 
 // Removes the collapsible space at the end of |text_| if exists.
-void NGInlineItemsBuilder::RemoveTrailingCollapsibleSpaceIfExists() {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<
+    OffsetMappingBuilder>::RemoveTrailingCollapsibleSpaceIfExists() {
   if (last_collapsible_space_ == CollapsibleSpace::kNone || text_.IsEmpty())
     return;
 
   // Look for the last space character since characters that are opaque to
   // whitespace collapsing may be appended.
   for (unsigned i = text_.length(); i;) {
     UChar ch = text_[--i];
     if (ch == kSpaceCharacter) {
       RemoveTrailingCollapsibleSpace(i);
       return;
     }
 
     // AppendForcedBreak sets CollapsibleSpace::kSpace to ignore leading
     // spaces. In this case, the trailing collapsible space does not exist.
     if (ch == kNewlineCharacter)
       return;
   }
   NOTREACHED();
 }
 
 // Removes the collapsible space at the specified index.
-void NGInlineItemsBuilder::RemoveTrailingCollapsibleSpace(unsigned index) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<
+    OffsetMappingBuilder>::RemoveTrailingCollapsibleSpace(unsigned index) {
   DCHECK_NE(last_collapsible_space_, CollapsibleSpace::kNone);
   DCHECK(!text_.IsEmpty());
   DCHECK_EQ(text_[index], kSpaceCharacter);
 
   text_.erase(index);
   last_collapsible_space_ = CollapsibleSpace::kNone;
 
   // Adjust items if the removed space is already included.
   for (unsigned i = items_->size(); i > 0;) {
     NGInlineItem& item = (*items_)[--i];
     if (index >= item.EndOffset())
       return;
     if (item.StartOffset() <= index) {
       if (item.Length() == 1) {
         DCHECK_EQ(item.StartOffset(), index);
         DCHECK_EQ(item.Type(), NGInlineItem::kText);
         items_->erase(i);
       } else {
         item.SetEndOffset(item.EndOffset() - 1);
       }
       return;
     }
 
     // Trailing spaces can be removed across non-character items.
     // Adjust their offsets if after the removed index.
     item.SetOffset(item.StartOffset() - 1, item.EndOffset() - 1);
   }
 }
 
-void NGInlineItemsBuilder::AppendBidiControl(const ComputedStyle* style,
-                                             UChar ltr,
-                                             UChar rtl) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::AppendBidiControl(
+    const ComputedStyle* style,
+    UChar ltr,
+    UChar rtl) {
   AppendOpaque(NGInlineItem::kBidiControl,
                IsLtr(style->Direction()) ? ltr : rtl);
 }
 
-void NGInlineItemsBuilder::EnterBlock(const ComputedStyle* style) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::EnterBlock(
+    const ComputedStyle* style) {
   // Handle bidi-override on the block itself.
   switch (style->GetUnicodeBidi()) {
     case UnicodeBidi::kNormal:
     case UnicodeBidi::kEmbed:
     case UnicodeBidi::kIsolate:
       // Isolate and embed values are enforced by default and redundant on the
       // block elements.
       // Direction is handled as the paragraph level by
       // NGBidiParagraph::SetParagraph().
       if (style->Direction() == TextDirection::kRtl)
         has_bidi_controls_ = true;
       break;
     case UnicodeBidi::kBidiOverride:
     case UnicodeBidi::kIsolateOverride:
       AppendBidiControl(style, kLeftToRightOverrideCharacter,
                         kRightToLeftOverrideCharacter);
       Enter(nullptr, kPopDirectionalFormattingCharacter);
       break;
     case UnicodeBidi::kPlaintext:
       // Plaintext is handled as the paragraph level by
       // NGBidiParagraph::SetParagraph().
       has_bidi_controls_ = true;
       break;
   }
 }
 
-void NGInlineItemsBuilder::EnterInline(LayoutObject* node) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::EnterInline(
+    LayoutObject* node) {
   // https://drafts.csswg.org/css-writing-modes-3/#bidi-control-codes-injection-table
   const ComputedStyle* style = node->Style();
   switch (style->GetUnicodeBidi()) {
     case UnicodeBidi::kNormal:
       break;
     case UnicodeBidi::kEmbed:
       AppendBidiControl(style, kLeftToRightEmbedCharacter,
                         kRightToLeftEmbedCharacter);
       Enter(node, kPopDirectionalFormattingCharacter);
       break;
@@ skipping 16 matching lines @@
       AppendBidiControl(style, kLeftToRightOverrideCharacter,
                         kRightToLeftOverrideCharacter);
       Enter(node, kPopDirectionalIsolateCharacter);
       Enter(node, kPopDirectionalFormattingCharacter);
       break;
   }
 
   AppendOpaque(NGInlineItem::kOpenTag, style, node);
 }
 
-void NGInlineItemsBuilder::Enter(LayoutObject* node, UChar character_to_exit) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::Enter(
+    LayoutObject* node,
+    UChar character_to_exit) {
   exits_.push_back(OnExitNode{node, character_to_exit});
   has_bidi_controls_ = true;
 }
 
-void NGInlineItemsBuilder::ExitBlock() {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::ExitBlock() {
   Exit(nullptr);
 }
 
-void NGInlineItemsBuilder::ExitInline(LayoutObject* node) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::ExitInline(
+    LayoutObject* node) {
   DCHECK(node);
 
   AppendOpaque(NGInlineItem::kCloseTag, node->Style(), node);
 
   Exit(node);
 }
 
-void NGInlineItemsBuilder::Exit(LayoutObject* node) {
+template <typename OffsetMappingBuilder>
+void NGInlineItemsBuilderTemplate<OffsetMappingBuilder>::Exit(
+    LayoutObject* node) {
   while (!exits_.IsEmpty() && exits_.back().node == node) {
     AppendOpaque(NGInlineItem::kBidiControl, exits_.back().character);
     exits_.pop_back();
   }
 }
 
+template class CORE_TEMPLATE_EXPORT
+    NGInlineItemsBuilderTemplate<EmptyOffsetMappingBuilder>;
+
 }  // namespace blink