Un-insanify first-letter handling in TextIterator (to some degree)

third_party/WebKit/Source/core/editing/iterators/TextIterator.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2005 Alexey Proskuryakov.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 44 matching lines @@
 #include "platform/fonts/Font.h"
 #include "platform/wtf/text/CString.h"
 #include "platform/wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 
-const int kInvalidTextOffset = -1;
-
 template <typename Strategy>
 TextIteratorBehavior AdjustBehaviorFlags(const TextIteratorBehavior&);
 
 template <>
 TextIteratorBehavior AdjustBehaviorFlags<EditingStrategy>(
     const TextIteratorBehavior& behavior) {
   if (!behavior.ForSelectionToString())
     return behavior;
   return TextIteratorBehavior::Builder(behavior)
       .SetExcludeAutofilledValue(true)
@@ skipping 91 matching lines @@
       text_box_(nullptr),
       remaining_text_box_(nullptr),
       first_letter_text_(nullptr),
       last_text_node_(nullptr),
       last_text_node_ended_with_collapsed_space_(false),
       sorted_text_boxes_position_(0),
       behavior_(AdjustBehaviorFlags<Strategy>(behavior)),
       handled_first_letter_(false),
       should_stop_(false),
       handle_shadow_root_(false),
-      first_letter_start_offset_(kInvalidTextOffset),
-      remaining_text_start_offset_(kInvalidTextOffset),
       text_state_(behavior_) {
   DCHECK(start.IsNotNull());
   DCHECK(end.IsNotNull());
 
   // TODO(dglazkov): TextIterator should not be created for documents that don't
   // have a frame, but it currently still happens in some cases. See
   // http://crbug.com/591877 for details.
   DCHECK(!start.GetDocument()->View() ||
          !start.GetDocument()->View()->NeedsLayout());
   DCHECK(!start.GetDocument()->NeedsLayoutTreeUpdate());
 
   if (start.CompareTo(end) > 0) {
     Initialize(end.ComputeContainerNode(), end.ComputeOffsetInContainerNode(),
                start.ComputeContainerNode(),
                start.ComputeOffsetInContainerNode());
     return;
   }
   Initialize(start.ComputeContainerNode(), start.ComputeOffsetInContainerNode(),
              end.ComputeContainerNode(), end.ComputeOffsetInContainerNode());
 }
 
 template <typename Strategy>
-bool TextIteratorAlgorithm<Strategy>::PrepareForFirstLetterInitialization() {
-  if (node_ != start_container_)
-    return false;
-
-  if (node_->getNodeType() != Node::kTextNode)
-    return false;
-
-  Text* text_node = ToText(node_);
-  LayoutText* layout_object = text_node->GetLayoutObject();
-  if (!layout_object || !layout_object->IsTextFragment())
-    return false;
-
-  LayoutTextFragment* text_fragment = ToLayoutTextFragment(layout_object);
-  if (!text_fragment->IsRemainingTextLayoutObject())
-    return false;
-
-  if (static_cast<unsigned>(start_offset_) >=
-      text_fragment->TextStartOffset()) {
-    remaining_text_start_offset_ =
-        start_offset_ - text_fragment->TextStartOffset();
-  } else {
-    first_letter_start_offset_ = start_offset_;
-  }
-  offset_ = 0;
-
-  return true;
-}
-
-template <typename Strategy>
-bool TextIteratorAlgorithm<Strategy>::HasNotAdvancedToStartPosition() {
-  if (AtEnd())
-    return false;
-  if (remaining_text_start_offset_ == kInvalidTextOffset)
-    return false;
-  return node_ == start_container_;
-}
-
-template <typename Strategy>
 void TextIteratorAlgorithm<Strategy>::Initialize(Node* start_container,
                                                  int start_offset,
                                                  Node* end_container,
                                                  int end_offset) {
   DCHECK(start_container);
   DCHECK(end_container);
 
   // Remember the range - this does not change.
   start_container_ = start_container;
   start_offset_ = start_offset;
@@ skipping 13 matching lines @@
     node_ = child;
   else if (!start_offset)
     node_ = start_container;
   else
     node_ = Strategy::NextSkippingChildren(*start_container);
 
   if (!node_)
     return;
 
   fully_clipped_stack_.SetUpFullyClippedStack(node_);
-  if (!PrepareForFirstLetterInitialization())
-    offset_ = node_ == start_container_ ? start_offset_ : 0;
+  offset_ = node_ == start_container_ ? start_offset_ : 0;
   iteration_progress_ = kHandledNone;
 
   // Calculate first out of bounds node.
   past_end_node_ = end_container
                        ? PastLastNode<Strategy>(*end_container, end_offset)
                        : nullptr;
 
   // Identify the first run.
   Advance();
-
-  // The current design cannot start in a text node with arbitrary offset, if
-  // the node has :first-letter. Instead, we start with offset 0, and have extra
-  // advance() calls until we have moved to/past the starting position.
-  while (HasNotAdvancedToStartPosition())
-    Advance();
-
-  // Clear temporary data for initialization with :first-letter.
-  first_letter_start_offset_ = kInvalidTextOffset;
-  remaining_text_start_offset_ = kInvalidTextOffset;
 }
 
 template <typename Strategy>
 TextIteratorAlgorithm<Strategy>::~TextIteratorAlgorithm() {
   if (!handle_shadow_root_)
     return;
   Document* document = OwnerDocument();
   if (!document)
     return;
   if (behavior_.ForInnerText())
@@ skipping 253 matching lines @@
              EVisibility::kVisible;
 }
 
 template <typename Strategy>
 bool TextIteratorAlgorithm<Strategy>::ShouldHandleFirstLetter(
     const LayoutText& layout_text) const {
   if (handled_first_letter_)
     return false;
   if (!layout_text.IsTextFragment())
     return false;
-  // TODO(xiaochengh): Handle the case where :first-letter has multiple chars,
-  // and eliminate the hack with first_letter/remaining_text_start_offset_.
-  return !offset_;
+  const LayoutTextFragment& text_fragment = ToLayoutTextFragment(layout_text);
+  return offset_ < static_cast<int>(text_fragment.TextStartOffset());
 }
 
 template <typename Strategy>
 bool TextIteratorAlgorithm<Strategy>::HandleTextNode() {
   if (ExcludesAutofilledValue()) {
     TextControlElement* control = EnclosingTextControl(node_);
     // For security reason, we don't expose suggested value if it is
     // auto-filled.
     if (control && control->IsAutofilled())
       return true;
   }
 
   Text* text_node = ToText(node_);
   LayoutText* layout_object = text_node->GetLayoutObject();
 
   last_text_node_ = text_node;
   String str = layout_object->GetText();
 
   // handle pre-formatted text
   if (!layout_object->Style()->CollapseWhiteSpace()) {
     if (last_text_node_ended_with_collapsed_space_ &&
         HasVisibleTextNode(layout_object)) {
       if (behavior_.CollapseTrailingSpace()) {
         if (offset_ > 0 && str[offset_ - 1] == ' ') {
           SpliceBuffer(kSpaceCharacter, text_node, 0, offset_, offset_);

[Xiaocheng, 2017/05/16 23:33:31]

I don't think this line is reachable. I'll remove it in another patch.

Same applies to a similar line in HandleReplacedElement().

           return false;
         }
       } else {
         SpliceBuffer(kSpaceCharacter, text_node, 0, offset_, offset_);
         return false;
       }
     }
     if (ShouldHandleFirstLetter(*layout_object)) {
       HandleTextNodeFirstLetter(ToLayoutTextFragment(layout_object));
       if (first_letter_text_) {
         String first_letter = first_letter_text_->GetText();
-        EmitText(text_node, first_letter_text_, offset_,
-                 offset_ + first_letter.length());
+        const unsigned run_start = offset_;
+        const bool stops_in_first_letter =
+            text_node == end_container_ &&
+            end_offset_ <= static_cast<int>(first_letter.length());
+        const unsigned run_end =
+            stops_in_first_letter ? end_offset_ : first_letter.length();
+        EmitText(text_node, first_letter_text_, run_start, run_end);
         first_letter_text_ = nullptr;
         text_box_ = 0;
-        return false;
+        offset_ = run_end;
+        return stops_in_first_letter;
       }
+      // We are here only if the DOM and/or layout trees are broken.
+      NOTREACHED();
     }
     if (layout_object->Style()->Visibility() != EVisibility::kVisible &&
         !IgnoresStyleVisibility())
       return false;
-    const unsigned run_start = offset_;
+    const unsigned run_start = offset_ - layout_object->TextStartOffset();
     const unsigned str_length = str.length();
-    const unsigned end = (text_node == end_container_) ? end_offset_ : INT_MAX;
+    const unsigned end = (text_node == end_container_)
+                             ? end_offset_ - layout_object->TextStartOffset()
+                             : INT_MAX;
     const unsigned run_end = std::min(str_length, end);
 
     if (run_start >= run_end)
       return true;
 
     EmitText(text_node, text_node->GetLayoutObject(), run_start, run_end);
     return true;
   }
 
   if (layout_object->FirstTextBox())
@@ skipping 62 matching lines @@
     return subrun_end + 1;
 
   return subrun_end;
 }
 
 template <typename Strategy>
 void TextIteratorAlgorithm<Strategy>::HandleTextBox() {
   LayoutText* layout_object = first_letter_text_
                                   ? first_letter_text_
                                   : ToLayoutText(node_->GetLayoutObject());
+  const unsigned text_start_offset = layout_object->TextStartOffset();
 
   if (layout_object->Style()->Visibility() != EVisibility::kVisible &&
       !IgnoresStyleVisibility()) {
     text_box_ = nullptr;
   } else {
     String str = layout_object->GetText();
-    const unsigned start = offset_;
-    const unsigned end = (node_ == end_container_)
-                             ? static_cast<unsigned>(end_offset_)
-                             : INT_MAX;
+    // Start and end offsets in |str|, i.e., str[start..end - 1] should be
+    // emitted (after handling whitespace collapsing).
+    const unsigned start = offset_ - layout_object->TextStartOffset();
+    const unsigned end =
+        (node_ == end_container_)
+            ? static_cast<unsigned>(end_offset_) - text_start_offset
+            : INT_MAX;
     while (text_box_) {
       const unsigned text_box_start = text_box_->Start();
       const unsigned run_start = std::max(text_box_start, start);
 
       // Check for collapsed space at the start of this run.
       InlineTextBox* first_text_box =
           layout_object->ContainsReversedText()
               ? (sorted_text_boxes_.IsEmpty() ? 0 : sorted_text_boxes_[0])
               : layout_object->FirstTextBox();
       const bool need_space = last_text_node_ended_with_collapsed_space_ ||
@@ skipping 44 matching lines @@
         // or a run of characters that does not include a newline.
         // This effectively translates newlines to spaces without copying the
         // text.
         if (str[run_start] == '\n') {
           // We need to preserve new lines in case of PreLine.
           // See bug crbug.com/317365.
           if (layout_object->Style()->WhiteSpace() == EWhiteSpace::kPreLine)
             SpliceBuffer('\n', node_, 0, run_start, run_start);
           else
             SpliceBuffer(kSpaceCharacter, node_, 0, run_start, run_start + 1);
-          offset_ = run_start + 1;
+          offset_ = text_start_offset + run_start + 1;
         } else {
           size_t subrun_end = str.find('\n', run_start);
           if (subrun_end == kNotFound || subrun_end > run_end) {
             subrun_end = run_end;
             subrun_end =
                 RestoreCollapsedTrailingSpace(next_text_box, subrun_end);
           }
 
-          offset_ = subrun_end;
+          offset_ = text_start_offset + subrun_end;
           EmitText(node_, layout_object, run_start, subrun_end);
         }
 
         // If we are doing a subrun that doesn't go to the end of the text box,
         // come back again to finish handling this text box; don't advance to
         // the next one.
         if (static_cast<unsigned>(text_state_.PositionEndOffset()) <
             text_box_end)
           return;
 
@@ skipping 27 matching lines @@
   }
 
   if (ShouldProceedToRemainingText()) {
     ProceedToRemainingText();
     HandleTextBox();
   }
 }
 
 template <typename Strategy>
 bool TextIteratorAlgorithm<Strategy>::ShouldProceedToRemainingText() const {
-  // TODO(xiaochengh): Handle the case where the iterator should stop in
-  // :first-letter.
-  return !text_box_ && remaining_text_box_;
+  if (text_box_ || !remaining_text_box_)
+    return false;
+  if (node_ != end_container_)
+    return true;
+  return offset_ < end_offset_;
 }
 
 template <typename Strategy>
 void TextIteratorAlgorithm<Strategy>::ProceedToRemainingText() {
   text_box_ = remaining_text_box_;
   remaining_text_box_ = 0;
   first_letter_text_ = nullptr;
-  // TODO(xiaochengh): |offset_| should be set to the starting offset of the
-  // remaining text;
-  offset_ = 0;
+  offset_ = ToLayoutText(node_->GetLayoutObject())->TextStartOffset();
 }
 
 template <typename Strategy>
 void TextIteratorAlgorithm<Strategy>::HandleTextNodeFirstLetter(
     LayoutTextFragment* layout_object) {
   handled_first_letter_ = true;
 
   if (!layout_object->IsRemainingTextLayoutObject())
     return;
 
@@ skipping 368 matching lines @@
                                                    int text_end_offset) {
   // Since m_lastTextNodeEndedWithCollapsedSpace seems better placed in
   // TextIterator, but is always reset when we call spliceBuffer, we
   // wrap TextIteratorTextState::spliceBuffer() with this function.
   text_state_.SpliceBuffer(c, text_node, offset_base_node, text_start_offset,
                            text_end_offset);
   last_text_node_ended_with_collapsed_space_ = false;
 }
 
 template <typename Strategy>
-int TextIteratorAlgorithm<Strategy>::AdjustedStartForFirstLetter(
-    const Node& text_node,
-    const LayoutText& layout_object,
-    int text_start_offset,
-    int text_end_offset) {
-  if (first_letter_start_offset_ == kInvalidTextOffset)
-    return text_start_offset;
-  if (text_node != start_container_)
-    return text_start_offset;
-  if (!layout_object.IsTextFragment())
-    return text_start_offset;
-  if (ToLayoutTextFragment(layout_object).IsRemainingTextLayoutObject())
-    return text_start_offset;
-  if (text_end_offset <= first_letter_start_offset_)
-    return text_start_offset;
-  int adjusted_offset = std::max(text_start_offset, first_letter_start_offset_);
-  first_letter_start_offset_ = kInvalidTextOffset;
-  return adjusted_offset;
-}
-
-template <typename Strategy>
-int TextIteratorAlgorithm<Strategy>::AdjustedStartForRemainingText(
-    const Node& text_node,
-    const LayoutText& layout_object,
-    int text_start_offset,
-    int text_end_offset) {
-  if (remaining_text_start_offset_ == kInvalidTextOffset)
-    return text_start_offset;
-  if (text_node != start_container_)
-    return text_start_offset;
-  if (!layout_object.IsTextFragment())
-    return text_start_offset;
-  if (!ToLayoutTextFragment(layout_object).IsRemainingTextLayoutObject())
-    return text_start_offset;
-  if (text_end_offset <= remaining_text_start_offset_)
-    return text_start_offset;
-  int adjusted_offset =
-      std::max(text_start_offset, remaining_text_start_offset_);
-  remaining_text_start_offset_ = kInvalidTextOffset;
-  return adjusted_offset;
-}
-
-template <typename Strategy>
 void TextIteratorAlgorithm<Strategy>::EmitText(Node* text_node,
                                                LayoutText* layout_object,
                                                int text_start_offset,
                                                int text_end_offset) {
-  text_start_offset = AdjustedStartForFirstLetter(
-      *text_node, *layout_object, text_start_offset, text_end_offset);
-  text_start_offset = AdjustedStartForRemainingText(
-      *text_node, *layout_object, text_start_offset, text_end_offset);
   // Since m_lastTextNodeEndedWithCollapsedSpace seems better placed in
   // TextIterator, but is always reset when we call spliceBuffer, we
   // wrap TextIteratorTextState::spliceBuffer() with this function.
   text_state_.EmitText(text_node, layout_object, text_start_offset,
                        text_end_offset);
   last_text_node_ended_with_collapsed_space_ = false;
 }
 
 template <typename Strategy>
 EphemeralRangeTemplate<Strategy> TextIteratorAlgorithm<Strategy>::Range()
@@ skipping 173 matching lines @@
 String PlainText(const EphemeralRangeInFlatTree& range,
                  const TextIteratorBehavior& behavior) {
   return CreatePlainText<EditingInFlatTreeStrategy>(range, behavior);
 }
 
 template class CORE_TEMPLATE_EXPORT TextIteratorAlgorithm<EditingStrategy>;
 template class CORE_TEMPLATE_EXPORT
     TextIteratorAlgorithm<EditingInFlatTreeStrategy>;
 
 }  // namespace blink