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
 
+TextNodeContentExtractor::TextNodeContentExtractor(
+    const TextIteratorBehavior& behavior,
+    TextIteratorTextState& text_state)
+    : start_offset_(0),

[yosin_UTC9, 2017/05/25 06:44:09]

Initialization of member variables should be done in class declaration for ease
of adding/removing member variables.

+      end_offset_(0),
+      offset_(0),
+      text_box_(nullptr),
+      needs_handle_pre_formatted_text_node_(false),
+      handled_first_letter_(false),
+      remaining_text_box_(nullptr),
+      first_letter_text_(nullptr),
+      last_text_node_ended_with_collapsed_space_(false),
+      sorted_text_boxes_position_(0),
+      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_extractor_(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 TextNodeContentExtractor::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);
 
+  text_extractor_.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 TextNodeContentExtractor::HandleRemainingTextRuns() {
   if (ShouldProceedToRemainingText())
     ProceedToRemainingText();
   // handle remembered text box
   if (text_box_) {
     HandleTextBox();
     return text_state_.PositionNode();
   }
   if (needs_handle_pre_formatted_text_node_) {
     HandlePreFormattedTextNode();
     return text_state_.PositionNode();
@@ 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_extractor_.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 TextNodeContentExtractor::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 TextNodeContentExtractor::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_) {
     last_text_node_ended_with_collapsed_space_ = false;
     if (HasVisibleTextNode(layout_object)) {
       if (!behavior_.CollapseTrailingSpace() ||
           (offset_ > 0 && str[offset_ - 1] == ' ')) {
-        SpliceBuffer(kSpaceCharacter, text_node_, 0, offset_, offset_);
+        text_state_.SpliceBuffer(kSpaceCharacter, text_node_, 0, offset_,
+                                 offset_);
         needs_handle_pre_formatted_text_node_ = true;
         return;
       }
     }
   }
   if (ShouldHandleFirstLetter(*layout_object)) {
     HandleTextNodeFirstLetter(ToLayoutTextFragment(layout_object));
     if (first_letter_text_) {
       const String first_letter = first_letter_text_->GetText();
       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);
+      text_state_.EmitText(text_node_, first_letter_text_, run_start, run_end);
       first_letter_text_ = nullptr;
       text_box_ = 0;
       offset_ = run_end;
       if (!stops_in_first_letter)
         needs_handle_pre_formatted_text_node_ = true;
       return;
     }
     // We are here only if the DOM and/or layout trees are broken.
     // For robustness, we should stop processing this node.
     NOTREACHED();
     return;
   }
   if (layout_object->Style()->Visibility() != EVisibility::kVisible &&
       !IgnoresStyleVisibility())
     return;
   DCHECK_GE(static_cast<unsigned>(offset_), layout_object->TextStartOffset());
   const unsigned run_start = offset_ - layout_object->TextStartOffset();
   const unsigned str_length = str.length();
   const unsigned end = (text_node_ == end_container_)
                            ? end_offset_ - layout_object->TextStartOffset()
                            : str_length;
   const unsigned run_end = std::min(str_length, end);
 
   if (run_start >= run_end)
     return;
 
-  EmitText(text_node_, text_node_->GetLayoutObject(), run_start, run_end);
+  text_state_.EmitText(text_node_, text_node_->GetLayoutObject(), run_start,
+                       run_end);
 }
 
 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;
   }
 
   DCHECK_NE(last_text_node_, node_)
       << "We should never call HandleTextNode on the same node twice";
   last_text_node_ = ToText(node_);
+  return text_extractor_.HandleTextNode(ToText(node_));
+}
 
-  text_node_ = ToText(node_);
+bool TextNodeContentExtractor::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 TextNodeContentExtractor::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 TextNodeContentExtractor::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 17 matching lines @@
                                text_box_start == run_start && run_start > 0);
       last_text_node_ended_with_collapsed_space_ = false;
       if (need_space &&
           !layout_object->Style()->IsCollapsibleWhiteSpace(
               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);
+          text_state_.EmitText(text_node_, layout_object, space_run_start,

[yosin_UTC9, 2017/05/25 06:44:09]

Let's introduce TextNodeContentExtract::EmitText() to make patch smaller and
ease of use.
I think we will have base class to share this function between Legacy and NG.

It seems we can move TI::EmitText() to TextNodeContentExtarct.

[Xiaocheng, 2017/05/25 23:47:58]

Done.

+                               space_run_start + 1);
         } else {
-          SpliceBuffer(kSpaceCharacter, text_node_, 0, run_start, run_start);
+          text_state_.SpliceBuffer(kSpaceCharacter, text_node_, 0, run_start,

[yosin_UTC9, 2017/05/25 06:44:09]

Let's introduce TextNodeContentExtract::SpliceBuffer() to make patch smaller and
ease of use.
I think we will have base class to share this function between Legacy and NG.

[Xiaocheng, 2017/05/25 23:47:58]

Done.

+                                   run_start);
         }
         return;
       }
       const unsigned text_box_end = text_box_start + text_box_->Len();
       const unsigned run_end = std::min(text_box_end, end);
 
       // Determine what the next text box will be, but don't advance yet
       InlineTextBox* next_text_box = nullptr;
       if (layout_object->ContainsReversedText()) {
         if (sorted_text_boxes_position_ + 1 < sorted_text_boxes_.size())
@@ skipping 17 matching lines @@
 
       if (run_start < run_end) {
         // Handle either a single newline character (which becomes a space),
         // 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', text_node_, 0, run_start, run_start);
+            text_state_.SpliceBuffer('\n', text_node_, 0, run_start, run_start);
           } else {
-            SpliceBuffer(kSpaceCharacter, text_node_, 0, run_start,
-                         run_start + 1);
+            text_state_.SpliceBuffer(kSpaceCharacter, text_node_, 0, run_start,
+                                     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_ = text_start_offset + subrun_end;
-          EmitText(text_node_, layout_object, run_start, subrun_end);
+          text_state_.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()) <
             text_box_end)
           return;
 
         if (behavior_.DoesNotEmitSpaceBeyondRangeEnd()) {
@@ skipping 24 matching lines @@
         ++sorted_text_boxes_position_;
     }
   }
 
   if (ShouldProceedToRemainingText()) {
     ProceedToRemainingText();
     HandleTextBox();
   }
 }
 
-template <typename Strategy>
-bool TextIteratorAlgorithm<Strategy>::ShouldProceedToRemainingText() const {
+bool TextNodeContentExtractor::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 TextNodeContentExtractor::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 TextNodeContentExtractor::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 TextNodeContentExtractor::FixLeadingWhiteSpaceForReplacedElement(
     Node* parent) {
   if (!last_text_node_ended_with_collapsed_space_)
     return false;
   last_text_node_ended_with_collapsed_space_ = false;
 
   if (!behavior_.CollapseTrailingSpace()) {
-    SpliceBuffer(kSpaceCharacter, parent, text_node_, 1, 1);
+    text_state_.SpliceBuffer(kSpaceCharacter, parent, text_node_, 1, 1);
     return true;
   }
   if (text_node_) {
     const String str = text_node_->GetLayoutObject()->GetText();
     if (offset_ > 0 && str[offset_ - 1] == ' ') {
-      SpliceBuffer(kSpaceCharacter, parent, text_node_, 1, 1);
+      text_state_.SpliceBuffer(kSpaceCharacter, parent, text_node_, 1, 1);
       return true;
     }
   }
 
   return false;
 }
 
 template <typename Strategy>
 bool TextIteratorAlgorithm<Strategy>::HandleReplacedElement() {
   if (fully_clipped_stack_.Top())
     return false;
 
   LayoutObject* layout_object = node_->GetLayoutObject();
   if (layout_object->Style()->Visibility() != EVisibility::kVisible &&
       !IgnoresStyleVisibility())
     return false;
 
   if (EmitsObjectReplacementCharacter()) {
     SpliceBuffer(kObjectReplacementCharacter, Strategy::Parent(*node_), node_,
                  0, 1);
     return true;
   }
 
   if (last_text_node_) {
-    if (FixLeadingWhiteSpaceForReplacedElement(
+    if (text_extractor_.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 491 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