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,

[yosin_UTC9, 2017/05/29 06:42:31]

This function name can be misleading, e.g. we can call this function multiple
times.
It is better to call |Initialize()| with DCHECK(!start_container),
DCHECK(!end_container), DDCHKE_EQ(start_offset_, 0), DCHECK_EQ(end_offset_, 0)

It seems we'll call this function multiple times, it it better to call
|Start()|?

[Xiaocheng, 2017/05/29 07:01:37]

This function is only called once. It copies the iteration range from
TextIterator to TextNodeHandler, so that the code moved to TextNodeHandler can
still use them, so that the code change is small.

In fact, as stated by the TODO (in TI.h), this function will be completely
removed by a subsequent patch. So there's no need to rename it to unnecessarily
lengthen the iteration.

[yosin_UTC9, 2017/05/29 07:43:56]

Could you add TODO about we'll remove this function?
I think it is better to have DCHECK() to verify this function called once.

[Xiaocheng, 2017/05/29 08:59:28]

Renamed and added DCHECK.

+                                                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();
   }
   // Handle remembered pre-formatted text node.
   if (!needs_handle_pre_formatted_text_node_)
     return false;
@@ skipping 21 matching lines @@
     // 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 117 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) {
+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()) {
@@ skipping 170 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