Add member TextIterator::text_node_

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 503 matching lines @@
     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() {
   // TODO(xiaochengh): Get rid of repeated computation of these fields.
-  Text* const text_node = ToText(node_);
-  LayoutText* const layout_object = text_node->GetLayoutObject();
+  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] == ' ')) {
-      SpliceBuffer(kSpaceCharacter, text_node, 0, offset_, offset_);
+      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_ &&
+          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);
+      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_)
+  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);
+  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";
 
-  offset_ = node_ == start_container_ ? start_offset_ : 0;
+  text_node_ = ToText(node_);
+  offset_ = text_node_ == start_container_ ? start_offset_ : 0;
   handled_first_letter_ = false;
   first_letter_text_ = nullptr;
 
-  Text* text_node = ToText(node_);
-  LayoutText* layout_object = text_node->GetLayoutObject();
+  LayoutText* layout_object = text_node_->GetLayoutObject();
 
-  last_text_node_ = text_node;
+  last_text_node_ = text_node_;
   String str = layout_object->GetText();
 
   // handle pre-formatted text
   if (!layout_object->Style()->CollapseWhiteSpace()) {
     HandlePreFormattedTextNode();
     return true;
   }
 
   if (layout_object->FirstTextBox())
     text_box_ = layout_object->FirstTextBox();
@@ skipping 35 matching lines @@
 
 // Restore the collapsed space for copy & paste. See http://crbug.com/318925
 template <typename Strategy>
 size_t TextIteratorAlgorithm<Strategy>::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 = ToLayoutText(node_->GetLayoutObject())->GetText();
+  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() {
-  LayoutText* layout_object = first_letter_text_
-                                  ? first_letter_text_
-                                  : ToLayoutText(node_->GetLayoutObject());
+  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
     // emitted (after handling whitespace collapsing).
     const unsigned start = offset_ - layout_object->TextStartOffset();
     const unsigned end =
-        (node_ == end_container_)
+        (text_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_ ||
                               (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()) {
-        if (last_text_node_ == node_ && run_start > 0 &&
+        if (last_text_node_ == text_node_ && 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(node_, layout_object, space_run_start, space_run_start + 1);
+          EmitText(text_node_, layout_object, space_run_start,
+                   space_run_start + 1);
         } else {
-          SpliceBuffer(kSpaceCharacter, node_, 0, run_start, run_start);
+          SpliceBuffer(kSpaceCharacter, text_node_, 0, run_start, 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 16 matching lines @@
              next_text_box->GetLineLayoutItem().IsEqual(layout_object));
 
       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', node_, 0, run_start, run_start);
-          else
-            SpliceBuffer(kSpaceCharacter, node_, 0, run_start, run_start + 1);
+          if (layout_object->Style()->WhiteSpace() == EWhiteSpace::kPreLine) {
+            SpliceBuffer('\n', text_node_, 0, run_start, run_start);
+          } else {
+            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(node_, layout_object, run_start, 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()) <
             text_box_end)
           return;
 
         if (behavior_.DoesNotEmitSpaceBeyondRangeEnd()) {
@@ skipping 28 matching lines @@
   if (ShouldProceedToRemainingText()) {
     ProceedToRemainingText();
     HandleTextBox();
   }
 }
 
 template <typename Strategy>
 bool TextIteratorAlgorithm<Strategy>::ShouldProceedToRemainingText() const {
   if (text_box_ || !remaining_text_box_)
     return false;
-  if (node_ != end_container_)
+  if (text_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;
-  offset_ = ToLayoutText(node_->GetLayoutObject())->TextStartOffset();
+  offset_ = text_node_->GetLayoutObject()->TextStartOffset();
 }
 
 template <typename Strategy>
 void TextIteratorAlgorithm<Strategy>::HandleTextNodeFirstLetter(
     LayoutTextFragment* layout_object) {
   handled_first_letter_ = true;
 
   if (!layout_object->IsRemainingTextLayoutObject())
     return;
 
@@ skipping 565 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