Make NGInlineItemsBuilder construct whitespace-collapsed offset mapping

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

 // 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.
 
 #ifndef NGInlineItemsBuilder_h
 #define NGInlineItemsBuilder_h
 
 #include "core/CoreExport.h"
 #include "core/layout/ng/inline/ng_inline_node.h"
 #include "platform/wtf/Allocator.h"
@@ skipping 23 matching lines @@
   explicit NGInlineItemsBuilder(Vector<NGInlineItem>* items) : items_(items) {}
   ~NGInlineItemsBuilder();
 
   String ToString();
 
   void SetIsSVGText(bool value) { is_svgtext_ = value; }
 
   // Returns whether the items contain any Bidi controls.
   bool HasBidiControls() const { return has_bidi_controls_; }
 
+  using AppendResult = std::pair<bool, Vector<unsigned>>;
+
   // Append a string.
   // When appending, spaces are collapsed according to CSS Text, The white space
   // processing rules
   // https://drafts.csswg.org/css-text-3/#white-space-rules
   // @param style The style for the string.
   // If a nullptr, it should skip shaping. Atomic inlines and bidi controls use
   // this.
   // @param LayoutObject The LayoutObject for the string.
   // If a nullptr, it does not generate BidiRun. Bidi controls use this.
-  void Append(const String&, const ComputedStyle*, LayoutObject* = nullptr);
+  // @return A pair, where the boolean denotes if the appending results in the
+  // removal of a preceeding collapsible space, and the vector gives the indexes
+  // of the collapsed spaces in the appended string.

[yoichio, 2017/06/16 01:47:48]

Does this value have enough information to build offset mapping between
  "foo   bar  baz"
to"foo bar baz" and how do you manage it?

[Xiaocheng, 2017/06/16 01:59:14]

Yes. The returned vector will contain the indexes of removed spaces: {4, 5, 10}.
See the unit tests for more examples.

The caller can use the return value to construct mapping function. I haven't
proceeded to that part, yet.

+  AppendResult Append(const String&,
+                      const ComputedStyle*,
+                      LayoutObject* = nullptr);
 
   // Append a character.
   // Currently this function is for adding control characters such as
   // objectReplacementCharacter, and does not support all space collapsing logic
   // as its String version does.
   // See the String version for using nullptr for ComputedStyle and
   // LayoutObject.
   void Append(NGInlineItem::NGInlineItemType,
               UChar,
               const ComputedStyle* = nullptr,
               LayoutObject* = nullptr);
 
   // Append a non-character item.
   void Append(NGInlineItem::NGInlineItemType,
               const ComputedStyle* = nullptr,
               LayoutObject* = nullptr);
 
   // Append a Bidi control character, for LTR or RTL depends on the style.
   void AppendBidiControl(const ComputedStyle*, UChar ltr, UChar rtl);
 
   void EnterBlock(const ComputedStyle*);
   void ExitBlock();
   void EnterInline(LayoutObject*);
   void ExitInline(LayoutObject*);
 
+  // Returns true if the finalization removes a previous collapsible space.
+  bool Finalize();

[Xiaocheng, 2017/06/16 00:09:44]

This function is refactored out from ToString(), so that:
- ToString() no longer has side-effect
- Whether the finalization removes a trailing space is explicitly returned.

+
  private:
   Vector<NGInlineItem>* items_;
   StringBuilder text_;
 
   typedef struct OnExitNode {
     LayoutObject* node;
     UChar character;
   } OnExitNode;
   Vector<OnExitNode> exits_;
 
   enum class CollapsibleSpace { kNone, kSpace, kNewline };
 
   CollapsibleSpace last_collapsible_space_ = CollapsibleSpace::kSpace;
   bool is_svgtext_ = false;
   bool has_bidi_controls_ = false;
 
-  void AppendWithWhiteSpaceCollapsing(const String&,
-                                      unsigned start,
-                                      unsigned end,
-                                      const ComputedStyle*,
-                                      LayoutObject*);
-  void AppendWithoutWhiteSpaceCollapsing(const String&,
-                                         const ComputedStyle*,
-                                         LayoutObject*);
-  void AppendWithPreservingNewlines(const String&,
-                                    const ComputedStyle*,
-                                    LayoutObject*);
+  AppendResult AppendWithWhiteSpaceCollapsing(const String&,
+                                              unsigned start,
+                                              unsigned end,
+                                              const ComputedStyle*,
+                                              LayoutObject*);
+  AppendResult AppendWithoutWhiteSpaceCollapsing(const String&,
+                                                 const ComputedStyle*,
+                                                 LayoutObject*);
+  AppendResult AppendWithPreservingNewlines(const String&,
+                                            const ComputedStyle*,
+                                            LayoutObject*);
 
-  void AppendForcedBreak(const ComputedStyle*, LayoutObject*);
+  // Returns if a previous collapsible space is removed.
+  bool AppendForcedBreak(const ComputedStyle*, LayoutObject*);
 
   // Because newlines may be removed depends on following characters, newlines
   // at the end of input string is not added to |text_| but instead
   // |has_pending_newline_| flag is set.
   // This function determines whether to add the newline or ignore.
   void ProcessPendingNewline(const String&, const ComputedStyle*);
 
-  // Removes the collapsible space at the end of |text_| if exists.
-  void RemoveTrailingCollapsibleSpaceIfExists(unsigned*);
+  // Removes the collapsible space at the end of |text_| if exists. Returns true
+  // is a collapsible space is removed.
+  bool RemoveTrailingCollapsibleSpaceIfExists(unsigned*);
   void RemoveTrailingCollapsibleSpace(unsigned*);
 
-  void RemoveTrailingCollapsibleNewlineIfNeeded(unsigned*,
+  // Returns true if a collapsible newline is removed.
+  bool RemoveTrailingCollapsibleNewlineIfNeeded(unsigned*,
                                                 const String&,
                                                 unsigned,
                                                 const ComputedStyle*);
 
   void Enter(LayoutObject*, UChar);
   void Exit(LayoutObject*);
 };
 
 }  // namespace blink
 
 #endif  // NGInlineItemsBuilder_h