Make NGInlineItemsBuilder construct whitespace-collapsed offset mapping

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/api/ng_offset_mapping_builder.h"
 #include "core/layout/ng/inline/ng_inline_node.h"
 #include "core/style/ComputedStyle.h"
 
 namespace blink {
 
 NGInlineItemsBuilder::~NGInlineItemsBuilder() {
   DCHECK_EQ(0u, exits_.size());
   DCHECK_EQ(text_.length(), items_->IsEmpty() ? 0 : items_->back().EndOffset());
 }
 
@@ skipping 131 matching lines @@
   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;
       }
 
-      if (last_collapsible_space_ == CollapsibleSpace::kNone)
+      if (last_collapsible_space_ == CollapsibleSpace::kNone) {
         text_.Append(kSpaceCharacter);
+        if (mapping_builder_)
+          mapping_builder_->AppendIdentityMapping(1);
+      } else {
+        if (mapping_builder_)
+          mapping_builder_->AppendCollapsedMapping(1);
+      }
       last_collapsible_space_ = CollapsibleSpace::kNewline;
       i++;
       continue;
     }
 
     if (c == kSpaceCharacter || c == kTabulationCharacter) {
       if (last_collapsible_space_ == CollapsibleSpace::kNone) {
         text_.Append(kSpaceCharacter);
         last_collapsible_space_ = CollapsibleSpace::kSpace;
+        if (mapping_builder_)
+          mapping_builder_->AppendIdentityMapping(1);
+      } else {
+        if (mapping_builder_)
+          mapping_builder_->AppendCollapsedMapping(1);
       }
       i++;
       continue;
     }
 
     if (last_collapsible_space_ == CollapsibleSpace::kNewline) {
       RemoveTrailingCollapsibleNewlineIfNeeded(string, i, style);
       start_offset = std::min(start_offset, text_.length());
     }
 
     size_t end_of_non_space = string.Find(IsCollapsibleSpace, i + 1);
     if (end_of_non_space == kNotFound)
       end_of_non_space = string.length();
     text_.Append(string, i, end_of_non_space - i);
+    if (mapping_builder_)
+      mapping_builder_->AppendIdentityMapping(end_of_non_space - i);

[yosin_UTC9, 2017/06/28 01:44:21]

So, do we call mapping builder for every word?

[Xiaocheng, 2017/06/28 02:05:20]

Yes. To decouple the mapping builder with impl details in whitespace collapsing
and inline collection, it should be notified of every change to |text_| and
every collapsed space.

     i = end_of_non_space;
     last_collapsible_space_ = CollapsibleSpace::kNone;
   }
 
   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) {
   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);
+    if (mapping_builder_)
+      mapping_builder_->AppendIdentityMapping(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,
@@ skipping 26 matching lines @@
 }
 
 void NGInlineItemsBuilder::Append(NGInlineItem::NGInlineItemType type,
                                   UChar character,
                                   const ComputedStyle* style,
                                   LayoutObject* layout_object) {
   DCHECK_NE(character, kSpaceCharacter);
   DCHECK_NE(character, kZeroWidthSpaceCharacter);
 
   text_.Append(character);
+  if (mapping_builder_)
+    mapping_builder_->AppendIdentityMapping(1);
   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) {
   text_.Append(character);
+  if (mapping_builder_)
+    mapping_builder_->AppendIdentityMapping(1);
   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) {
   unsigned end_offset = text_.length();
   AppendItem(items_, type, end_offset, end_offset, style, layout_object);
 }
@@ skipping 43 matching lines @@
 }
 
 // Removes the collapsible space at the specified index.
 void NGInlineItemsBuilder::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;
+  if (mapping_builder_)
+    mapping_builder_->CollapseTrailingSpace(text_.length() - index);
 
   // 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);
@@ skipping 99 matching lines @@
 }
 
 void NGInlineItemsBuilder::Exit(LayoutObject* node) {
   while (!exits_.IsEmpty() && exits_.back().node == node) {
     AppendOpaque(NGInlineItem::kBidiControl, exits_.back().character);
     exits_.pop_back();
   }
 }
 
 }  // namespace blink