Refactor some first-letter handling code 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 324 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 (!text_box_ && remaining_text_box_) {
-    text_box_ = remaining_text_box_;
-    remaining_text_box_ = 0;
-    first_letter_text_ = nullptr;
-    offset_ = 0;
-  }
+  if (ShouldProceedToRemainingText())
+    ProceedToRemainingText();
   // handle remembered text box
   if (text_box_) {
     HandleTextBox();
     if (text_state_.PositionNode())
       return;
   }
 
   while (node_ && (node_ != past_end_node_ || shadow_depth_ > 0)) {
     if (!should_stop_ && StopsOnFormControls() &&
         HTMLFormControlElement::EnclosingFormControlElement(node_))
@@ skipping 194 matching lines @@
 
   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(
+    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_;
+}
+
+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()) {
-    int run_start = offset_;
     if (last_text_node_ended_with_collapsed_space_ &&
         HasVisibleTextNode(layout_object)) {
       if (behavior_.CollapseTrailingSpace()) {
-        if (run_start > 0 && str[run_start - 1] == ' ') {
-          SpliceBuffer(kSpaceCharacter, text_node, 0, run_start, run_start);
+        if (offset_ > 0 && str[offset_ - 1] == ' ') {
+          SpliceBuffer(kSpaceCharacter, text_node, 0, offset_, offset_);
           return false;
         }
       } else {
-        SpliceBuffer(kSpaceCharacter, text_node, 0, run_start, run_start);
+        SpliceBuffer(kSpaceCharacter, text_node, 0, offset_, offset_);
         return false;
       }
     }
-    if (!handled_first_letter_ && layout_object->IsTextFragment() && !offset_) {
+    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());
         first_letter_text_ = nullptr;
         text_box_ = 0;
         return false;
       }
     }
     if (layout_object->Style()->Visibility() != EVisibility::kVisible &&
         !IgnoresStyleVisibility())
       return false;
-    int str_length = str.length();
-    int end = (text_node == end_container_) ? end_offset_ : INT_MAX;
-    int run_end = std::min(str_length, end);
+    const unsigned run_start = offset_;
+    const unsigned str_length = str.length();
+    const unsigned end = (text_node == end_container_) ? end_offset_ : 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())
     text_box_ = layout_object->FirstTextBox();
 
-  bool should_handle_first_letter =
-      !handled_first_letter_ && layout_object->IsTextFragment() && !offset_;
+  const bool should_handle_first_letter =
+      ShouldHandleFirstLetter(*layout_object);
   if (should_handle_first_letter)
     HandleTextNodeFirstLetter(ToLayoutTextFragment(layout_object));
 
   if (!layout_object->FirstTextBox() && str.length() > 0 &&
       !should_handle_first_letter) {
     if (layout_object->Style()->Visibility() != EVisibility::kVisible &&
         !IgnoresStyleVisibility())
       return false;
     last_text_node_ended_with_collapsed_space_ =
         true;  // entire block is collapsed space
@@ skipping 54 matching lines @@
 void TextIteratorAlgorithm<Strategy>::HandleTextBox() {
   LayoutText* layout_object = first_letter_text_
                                   ? first_letter_text_
                                   : ToLayoutText(node_->GetLayoutObject());
 
   if (layout_object->Style()->Visibility() != EVisibility::kVisible &&
       !IgnoresStyleVisibility()) {
     text_box_ = nullptr;
   } else {
     String str = layout_object->GetText();
-    unsigned start = offset_;
-    unsigned end = (node_ == end_container_)
-                       ? static_cast<unsigned>(end_offset_)
-                       : INT_MAX;
+    const unsigned start = offset_;
+    const unsigned end = (node_ == end_container_)
+                             ? static_cast<unsigned>(end_offset_)
+                             : INT_MAX;
     while (text_box_) {
-      unsigned text_box_start = text_box_->Start();
-      unsigned run_start = std::max(text_box_start, start);
+      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();
-      bool need_space = last_text_node_ended_with_collapsed_space_ ||
-                        (text_box_ == first_text_box &&
-                         text_box_start == run_start && run_start > 0);
+      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 &&
             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);
         } else {
           SpliceBuffer(kSpaceCharacter, node_, 0, run_start, run_start);
         }
         return;
       }
-      unsigned text_box_end = text_box_start + text_box_->Len();
-      unsigned run_end = std::min(text_box_end, end);
+      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())
           next_text_box = sorted_text_boxes_[sorted_text_boxes_position_ + 1];
       } else {
         next_text_box = text_box_->NextTextBox();
       }
 
@@ skipping 46 matching lines @@
           // 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;
           }
         }
 
         // Advance and return
-        unsigned next_run_start =
+        const unsigned next_run_start =
             next_text_box ? next_text_box->Start() : str.length();
         if (next_run_start > run_end)
           last_text_node_ended_with_collapsed_space_ =
               true;  // collapsed space between runs or at the end
 
         text_box_ = next_text_box;
         if (layout_object->ContainsReversedText())
           ++sorted_text_boxes_position_;
         return;
       }
       // Advance and continue
       text_box_ = next_text_box;
       if (layout_object->ContainsReversedText())
         ++sorted_text_boxes_position_;
     }
   }
 
-  if (!text_box_ && remaining_text_box_) {
-    text_box_ = remaining_text_box_;
-    remaining_text_box_ = 0;
-    first_letter_text_ = nullptr;
-    offset_ = 0;
+  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_;
+}
+
+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;
+}
+
+template <typename Strategy>
 void TextIteratorAlgorithm<Strategy>::HandleTextNodeFirstLetter(
     LayoutTextFragment* layout_object) {
   handled_first_letter_ = true;
 
   if (!layout_object->IsRemainingTextLayoutObject())
     return;
 
   FirstLetterPseudoElement* first_letter_element =
       layout_object->GetFirstLetterPseudoElement();
   if (!first_letter_element)
@@ skipping 609 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