Introduce a wrapper class to handle text node in TextIterator

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 134 matching lines @@
 
 bool IsRenderedAsTable(const Node* node) {
   if (!node || !node->IsElementNode())
     return false;
   LayoutObject* layout_object = node->GetLayoutObject();
   return layout_object && layout_object->IsTable();
 }
 
 }  // namespace
 
+TextIteratorTextNodeHandler::TextIteratorTextNodeHandler(
+    const TextIteratorBehavior& behavior,
+    TextIteratorTextState* text_state)
+    : behavior_(behavior), text_state_(text_state) {}
+
 template <typename Strategy>
 TextIteratorAlgorithm<Strategy>::TextIteratorAlgorithm(
     const PositionTemplate<Strategy>& start,
     const PositionTemplate<Strategy>& end,
     const TextIteratorBehavior& behavior)
-    : offset_(0),
-      start_container_(nullptr),
+    : start_container_(nullptr),
       start_offset_(0),
       end_container_(nullptr),
       end_offset_(0),
       needs_another_newline_(false),
-      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)),
-      needs_handle_pre_formatted_text_node_(false),
-      handled_first_letter_(false),
       should_stop_(false),
       handle_shadow_root_(false),
-      text_state_(behavior_) {
+      text_state_(behavior_),
+      text_node_handler_(behavior_, &text_state_) {
   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());
 }
 
+void TextIteratorTextNodeHandler::SetBoundaries(Node* start_container,
+                                                int start_offset,
+                                                Node* end_container,
+                                                int end_offset) {
+  start_container_ = start_container;
+  start_offset_ = start_offset;
+  end_container_ = end_container;
+  end_offset_ = end_offset;
+}
+
 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);
 
+  // TODO(xiaochengh): There is no need to pass the entire range. Instead, we
+  // can pass the start and end offsets when calling HandleTextNode().
+  text_node_handler_.SetBoundaries(start_container, start_offset, end_container,
+                                   end_offset);
+
   // Remember the range - this does not change.
   start_container_ = start_container;
   start_offset_ = start_offset;
   end_container_ = end_container;
   end_offset_ = end_offset;
   end_node_ =
       end_container && !end_container->IsCharacterDataNode() && end_offset > 0
           ? Strategy::ChildAt(*end_container, end_offset - 1)
           : nullptr;
 
@@ skipping 41 matching lines @@
 
 template <typename Strategy>
 bool TextIteratorAlgorithm<Strategy>::IsInsideAtomicInlineElement() const {
   if (AtEnd() || length() != 1 || !node_)
     return false;
 
   LayoutObject* layout_object = node_->GetLayoutObject();
   return layout_object && layout_object->IsAtomicInlineLevel();
 }
 
-template <typename Strategy>
-bool TextIteratorAlgorithm<Strategy>::HandleRemainingTextRuns() {
+bool TextIteratorTextNodeHandler::HandleRemainingTextRuns() {
   if (ShouldProceedToRemainingText())
     ProceedToRemainingText();
   // Handle remembered text box
   if (text_box_) {
     HandleTextBox();
-    return text_state_.PositionNode();
+    return text_state_->PositionNode();
   }
   // Handle remembered pre-formatted text node.
   if (!needs_handle_pre_formatted_text_node_)
     return false;
   HandlePreFormattedTextNode();
-  return text_state_.PositionNode();
+  return text_state_->PositionNode();
 }
 
 template <typename Strategy>
 void TextIteratorAlgorithm<Strategy>::Advance() {
   if (should_stop_)
     return;
 
   if (node_)
     DCHECK(!node_->GetDocument().NeedsLayoutTreeUpdate()) << node_;
 
   text_state_.ResetRunInformation();
 
   // TODO(xiaochengh): Wrap the following code into HandleRememberedProgress().
 
   // handle remembered node that needed a newline after the text node's newline
   if (needs_another_newline_) {
     // Emit the extra newline, and position it *inside* m_node, after m_node's
     // contents, in case it's a block, in the same way that we position the
     // first newline. The range for the emitted newline should start where the
     // line break begins.
     // FIXME: It would be cleaner if we emitted two newlines during the last
     // iteration, instead of using m_needsAnotherNewline.
     Node* last_child = Strategy::LastChild(*node_);
     Node* base_node = last_child ? last_child : node_.Get();
     SpliceBuffer('\n', Strategy::Parent(*base_node), base_node, 1, 1);
     needs_another_newline_ = false;
     return;
   }
 
-  if (HandleRemainingTextRuns())
+  if (text_node_handler_.HandleRemainingTextRuns())
     return;
 
   while (node_ && (node_ != past_end_node_ || shadow_depth_ > 0)) {
     if (!should_stop_ && StopsOnFormControls() &&
         HTMLFormControlElement::EnclosingFormControlElement(node_))
       should_stop_ = true;
 
     // if the range ends at offset 0 of an element, represent the
     // position, but not the content, of that element e.g. if the
     // node is a blockflow element, emit a newline that
@@ skipping 183 matching lines @@
     return false;
 
   DCHECK(fragment->GetFirstLetterPseudoElement());
   LayoutObject* pseudo_element_layout_object =
       fragment->GetFirstLetterPseudoElement()->GetLayoutObject();
   return pseudo_element_layout_object &&
          pseudo_element_layout_object->Style()->Visibility() ==
              EVisibility::kVisible;
 }
 
-template <typename Strategy>
-bool TextIteratorAlgorithm<Strategy>::ShouldHandleFirstLetter(
+bool TextIteratorTextNodeHandler::ShouldHandleFirstLetter(
     const LayoutText& layout_text) const {
   if (handled_first_letter_)
     return false;
   if (!layout_text.IsTextFragment())
     return false;
   const LayoutTextFragment& text_fragment = ToLayoutTextFragment(layout_text);
   return offset_ < static_cast<int>(text_fragment.TextStartOffset());
 }
 
-template <typename Strategy>
-void TextIteratorAlgorithm<Strategy>::HandlePreFormattedTextNode() {
+void TextIteratorTextNodeHandler::HandlePreFormattedTextNode() {
   // TODO(xiaochengh): Get rid of repeated computation of these fields.
   LayoutText* const layout_object = text_node_->GetLayoutObject();
   const String str = layout_object->GetText();
 
   needs_handle_pre_formatted_text_node_ = false;
 
   if (last_text_node_ended_with_collapsed_space_ &&
       HasVisibleTextNode(layout_object)) {
     if (!behavior_.CollapseTrailingSpace() ||
         (offset_ > 0 && str[offset_ - 1] == ' ')) {
@@ skipping 48 matching lines @@
     TextControlElement* control = EnclosingTextControl(node_);
     // For security reason, we don't expose suggested value if it is
     // auto-filled.
     if (control && control->IsAutofilled())
       return true;
   }
 
   DCHECK_NE(last_text_node_, node_)
       << "We should never call HandleTextNode on the same node twice";
   last_text_node_ = ToText(node_);
+  return text_node_handler_.HandleTextNode(ToText(node_));
+}
 
-  text_node_ = ToText(node_);
+bool TextIteratorTextNodeHandler::HandleTextNode(Text* node) {
+  text_node_ = node;
   offset_ = text_node_ == start_container_ ? start_offset_ : 0;
   handled_first_letter_ = false;
   first_letter_text_ = nullptr;
 
   LayoutText* layout_object = text_node_->GetLayoutObject();
   String str = layout_object->GetText();
 
   // handle pre-formatted text
   if (!layout_object->Style()->CollapseWhiteSpace()) {
     HandlePreFormattedTextNode();
@@ skipping 32 matching lines @@
               InlineTextBox::CompareByStart);
     sorted_text_boxes_position_ = 0;
     text_box_ = sorted_text_boxes_.IsEmpty() ? 0 : sorted_text_boxes_[0];
   }
 
   HandleTextBox();
   return true;
 }
 
 // Restore the collapsed space for copy & paste. See http://crbug.com/318925
-template <typename Strategy>
-size_t TextIteratorAlgorithm<Strategy>::RestoreCollapsedTrailingSpace(
+size_t TextIteratorTextNodeHandler::RestoreCollapsedTrailingSpace(
     InlineTextBox* next_text_box,
     size_t subrun_end) {
   if (next_text_box || !text_box_->Root().NextRootBox() ||
       text_box_->Root().LastChild() != text_box_)
     return subrun_end;
 
   const String& text = text_node_->GetLayoutObject()->GetText();
   if (text.EndsWith(' ') == 0 || subrun_end != text.length() - 1 ||
       text[subrun_end - 1] == ' ')
     return subrun_end;
 
   // If there is the leading space in the next line, we don't need to restore
   // the trailing space.
   // Example: <div style="width: 2em;"><b><i>foo </i></b> bar</div>
   InlineBox* first_box_of_next_line =
       text_box_->Root().NextRootBox()->FirstChild();
   if (!first_box_of_next_line)
     return subrun_end + 1;
   Node* first_node_of_next_line =
       first_box_of_next_line->GetLineLayoutItem().GetNode();
   if (!first_node_of_next_line ||
       first_node_of_next_line->nodeValue()[0] != ' ')
     return subrun_end + 1;
 
   return subrun_end;
 }
 
-template <typename Strategy>
-void TextIteratorAlgorithm<Strategy>::HandleTextBox() {
+void TextIteratorTextNodeHandler::HandleTextBox() {
   LayoutText* layout_object =
       first_letter_text_ ? first_letter_text_ : text_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();
     // Start and end offsets in |str|, i.e., str[start..end - 1] should be
@@ skipping 10 matching lines @@
       // 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_ ||
                               (text_box_ == first_text_box &&
                                text_box_start == run_start && run_start > 0);
       if (need_space &&
           !layout_object->Style()->IsCollapsibleWhiteSpace(
-              text_state_.LastCharacter()) &&
-          text_state_.LastCharacter()) {
+              text_state_->LastCharacter()) &&
+          text_state_->LastCharacter()) {
         if (run_start > 0 && str[run_start - 1] == ' ') {
           unsigned space_run_start = run_start - 1;
           while (space_run_start > 0 && str[space_run_start - 1] == ' ')
             --space_run_start;
           EmitText(text_node_, layout_object, space_run_start,
                    space_run_start + 1);
         } else {
           SpliceBuffer(kSpaceCharacter, text_node_, 0, run_start, run_start);
         }
         return;
@@ skipping 46 matching lines @@
                 RestoreCollapsedTrailingSpace(next_text_box, subrun_end);
           }
 
           offset_ = text_start_offset + subrun_end;
           EmitText(text_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()) <
+        if (static_cast<unsigned>(text_state_->PositionEndOffset()) <
             text_box_end)
           return;
 
         if (behavior_.DoesNotEmitSpaceBeyondRangeEnd()) {
           // If the subrun went to the text box end and this end is also the end
           // of the range, do not advance to the next text box and do not
           // generate a space, just stop.
           if (text_box_end == end) {
             text_box_ = nullptr;
             return;
@@ skipping 18 matching lines @@
         ++sorted_text_boxes_position_;
     }
   }
 
   if (ShouldProceedToRemainingText()) {
     ProceedToRemainingText();
     HandleTextBox();
   }
 }
 
-template <typename Strategy>
-bool TextIteratorAlgorithm<Strategy>::ShouldProceedToRemainingText() const {
+bool TextIteratorTextNodeHandler::ShouldProceedToRemainingText() const {
   if (text_box_ || !remaining_text_box_)
     return false;
   if (text_node_ != end_container_)
     return true;
   return offset_ < end_offset_;
 }
 
-template <typename Strategy>
-void TextIteratorAlgorithm<Strategy>::ProceedToRemainingText() {
+void TextIteratorTextNodeHandler::ProceedToRemainingText() {
   text_box_ = remaining_text_box_;
   remaining_text_box_ = 0;
   first_letter_text_ = nullptr;
   offset_ = text_node_->GetLayoutObject()->TextStartOffset();
 }
 
-template <typename Strategy>
-void TextIteratorAlgorithm<Strategy>::HandleTextNodeFirstLetter(
+void TextIteratorTextNodeHandler::HandleTextNodeFirstLetter(
     LayoutTextFragment* layout_object) {
   handled_first_letter_ = true;
 
   if (!layout_object->IsRemainingTextLayoutObject())
     return;
 
   FirstLetterPseudoElement* first_letter_element =
       layout_object->GetFirstLetterPseudoElement();
   if (!first_letter_element)
     return;
@@ skipping 20 matching lines @@
 
   // FIXME: Add isSVGImageElement.
   if (isHTMLImageElement(element))
     return true;
   if (isHTMLInputElement(ToHTMLElement(*node)) &&
       toHTMLInputElement(*node).type() == InputTypeNames::image)
     return true;
   return false;
 }
 
-template <typename Strategy>
-bool TextIteratorAlgorithm<Strategy>::FixLeadingWhiteSpaceForReplacedElement(
+bool TextIteratorTextNodeHandler::FixLeadingWhiteSpaceForReplacedElement(
     Node* parent) {
   // This is a hacky way for white space fixup in legacy layout. With LayoutNG,
   // we can get rid of this function.
 
   if (behavior_.CollapseTrailingSpace()) {
     if (text_node_) {
       String str = text_node_->GetLayoutObject()->GetText();
       if (last_text_node_ended_with_collapsed_space_ && offset_ > 0 &&
           str[offset_ - 1] == ' ') {
         SpliceBuffer(kSpaceCharacter, parent, text_node_, 1, 1);
@@ skipping 17 matching lines @@
   if (layout_object->Style()->Visibility() != EVisibility::kVisible &&
       !IgnoresStyleVisibility())
     return false;
 
   if (EmitsObjectReplacementCharacter()) {
     SpliceBuffer(kObjectReplacementCharacter, Strategy::Parent(*node_), node_,
                  0, 1);
     return true;
   }
 
-  DCHECK_EQ(last_text_node_, text_node_);
+  DCHECK_EQ(last_text_node_, text_node_handler_.GetNode());
   if (last_text_node_) {
-    if (FixLeadingWhiteSpaceForReplacedElement(
+    if (text_node_handler_.FixLeadingWhiteSpaceForReplacedElement(
             Strategy::Parent(*last_text_node_)))
       return false;
   }
 
   if (EntersTextControls() && layout_object->IsTextControl()) {
     // The shadow tree should be already visited.
     return true;
   }
 
   if (EmitsCharactersBetweenAllVisiblePositions()) {
@@ skipping 281 matching lines @@
                    1, 1);
     }
   }
 
   // If nothing was emitted, see if we need to emit a space.
   if (!text_state_.PositionNode() && ShouldEmitSpaceBeforeAndAfterNode(node_))
     SpliceBuffer(kSpaceCharacter, Strategy::Parent(*base_node), base_node, 1,
                  1);
 }
 
-template <typename Strategy>
-void TextIteratorAlgorithm<Strategy>::ResetCollapsedWhiteSpaceFixup() {
+void TextIteratorTextNodeHandler::ResetCollapsedWhiteSpaceFixup() {
   // This is a hacky way for white space fixup in legacy layout. With LayoutNG,
   // we can get rid of this function.
   last_text_node_ended_with_collapsed_space_ = false;
 }
 
 template <typename Strategy>
 void TextIteratorAlgorithm<Strategy>::SpliceBuffer(UChar c,
                                                    Node* text_node,
                                                    Node* offset_base_node,
                                                    int text_start_offset,
                                                    int text_end_offset) {
   text_state_.SpliceBuffer(c, text_node, offset_base_node, text_start_offset,
                            text_end_offset);
+  text_node_handler_.ResetCollapsedWhiteSpaceFixup();
+}
+
+void TextIteratorTextNodeHandler::SpliceBuffer(UChar c,
+                                               Node* text_node,
+                                               Node* offset_base_node,
+                                               int text_start_offset,
+                                               int text_end_offset) {
+  text_state_->SpliceBuffer(c, text_node, offset_base_node, text_start_offset,
+                            text_end_offset);
   ResetCollapsedWhiteSpaceFixup();
 }
 
-template <typename Strategy>
-void TextIteratorAlgorithm<Strategy>::EmitText(Node* text_node,
-                                               LayoutText* layout_object,
-                                               int text_start_offset,
-                                               int text_end_offset) {
-  text_state_.EmitText(text_node, layout_object, text_start_offset,
-                       text_end_offset);
+void TextIteratorTextNodeHandler::EmitText(Node* text_node,
+                                           LayoutText* layout_object,
+                                           int text_start_offset,
+                                           int text_end_offset) {
+  text_state_->EmitText(text_node, layout_object, text_start_offset,
+                        text_end_offset);
   ResetCollapsedWhiteSpaceFixup();
 }
 
 template <typename Strategy>
 EphemeralRangeTemplate<Strategy> TextIteratorAlgorithm<Strategy>::Range()
     const {
   // use the current run information, if we have it
   if (text_state_.PositionNode()) {
     return EphemeralRangeTemplate<Strategy>(StartPositionInCurrentContainer(),
                                             EndPositionInCurrentContainer());
@@ skipping 168 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