Introduce InlineTextBoxesOf() for ease of loop over InlineTextBox of LayoutText

third_party/WebKit/Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 211 matching lines @@
 }
 
 void LayoutText::RemoveAndDestroyTextBoxes() {
   if (!DocumentBeingDestroyed()) {
     if (FirstTextBox()) {
       if (IsBR()) {
         RootInlineBox* next = FirstTextBox()->Root().NextRootBox();
         if (next)
           next->MarkDirty();
       }
-      for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox())
+      for (InlineTextBox* box : InlineTextBoxesOf(*this))
         box->Remove();
     } else if (Parent()) {
       Parent()->DirtyLinesFromChangedChild(this);
     }
   }
   DeleteTextBoxes();
 }
 
 void LayoutText::WillBeDestroyed() {
   if (SecureTextTimer* secure_text_timer =
@@ skipping 57 matching lines @@
   return (e && e->IsTextNode()) ? ToText(e)->DataImpl() : 0;
 }
 
 String LayoutText::PlainText() const {
   if (GetNode())
     return blink::PlainText(EphemeralRange::RangeOfContents(*GetNode()));
 
   // FIXME: this is just a stopgap until TextIterator is adapted to support
   // generated text.
   StringBuilder plain_text_builder;
-  for (InlineTextBox* text_box = FirstTextBox(); text_box;
-       text_box = text_box->NextTextBox()) {
+  for (InlineTextBox* text_box : InlineTextBoxesOf(*this)) {
     String text = text_.Substring(text_box->Start(), text_box->Len())
                       .SimplifyWhiteSpace(WTF::kDoNotStripWhiteSpace);
     plain_text_builder.Append(text);
     if (text_box->NextTextBox() &&
         text_box->NextTextBox()->Start() > text_box->end() && text.length() &&
         !text.Right(1).ContainsOnlyWhitespace())
       plain_text_builder.Append(kSpaceCharacter);
   }
   return plain_text_builder.ToString();
 }
 
 void LayoutText::AbsoluteRects(Vector<IntRect>& rects,
                                const LayoutPoint& accumulated_offset) const {
-  for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox()) {
+  for (InlineTextBox* box : InlineTextBoxesOf(*this)) {
     rects.push_back(EnclosingIntRect(LayoutRect(
         LayoutPoint(accumulated_offset) + box->Location(), box->Size())));
   }
 }
 
 static FloatRect LocalQuadForTextBox(InlineTextBox* box,
                                      unsigned start,
                                      unsigned end) {
   unsigned real_end = std::min(box->end() + 1, end);
   LayoutRect r = box->LocalSelectionRect(start, real_end);
@@ skipping 36 matching lines @@
       return ellipsis->SelectionRect();
   }
 
   return IntRect();
 }
 
 void LayoutText::Quads(Vector<FloatQuad>& quads,
                        ClippingOption option,
                        LocalOrAbsoluteOption local_or_absolute,
                        MapCoordinatesFlags mode) const {
-  for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox()) {
+  for (InlineTextBox* box : InlineTextBoxesOf(*this)) {
     FloatRect boundaries(box->FrameRect());
 
     // Shorten the width of this text box if it ends in an ellipsis.
     // FIXME: ellipsisRectForBox should switch to return FloatRect soon with the
     // subpixellayout branch.
     IntRect ellipsis_rect = (option == kClipToEllipsis)
                                 ? EllipsisRectForBox(box, 0, TextLength())
                                 : IntRect();
     if (!ellipsis_rect.IsEmpty()) {
       if (Style()->IsHorizontalWritingMode())
@@ skipping 34 matching lines @@
       static_cast<unsigned>(this->CaretMaxOffset());
 
   // Narrows |start| and |end| into |caretMinOffset| and |careMaxOffset|
   // to ignore unrendered leading and trailing whitespaces.
   start = std::min(std::max(caret_min_offset, start), caret_max_offset);
   end = std::min(std::max(caret_min_offset, end), caret_max_offset);
 
   // This function is always called in sequence that this check should work.
   bool has_checked_box_in_range = !quads.IsEmpty();
 
-  for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox()) {
+  for (InlineTextBox* box : InlineTextBoxesOf(*this)) {
     // Note: box->end() returns the index of the last character, not the index
     // past it
     if (start <= box->Start() && box->end() < end) {
       LayoutRect r(box->FrameRect());
       if (!has_checked_box_in_range) {
         has_checked_box_in_range = true;
         quads.clear();
       }
       quads.push_back(LocalToAbsoluteQuad(FloatRect(r)));
     } else if ((box->Start() <= start && start <= box->end()) ||
@@ skipping 193 matching lines @@
   if (!FirstTextBox() || TextLength() == 0)
     return CreatePositionWithAffinity(0);
 
   LayoutUnit point_line_direction =
       FirstTextBox()->IsHorizontal() ? point.X() : point.Y();
   LayoutUnit point_block_direction =
       FirstTextBox()->IsHorizontal() ? point.Y() : point.X();
   bool blocks_are_flipped = Style()->IsFlippedBlocksWritingMode();
 
   InlineTextBox* last_box = nullptr;
-  for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox()) {
+  for (InlineTextBox* box : InlineTextBoxesOf(*this)) {
     if (box->IsLineBreak() && !box->PrevLeafChild() && box->NextLeafChild() &&
         !box->NextLeafChild()->IsLineBreak())
       box = box->NextTextBox();
 
     RootInlineBox& root_box = box->Root();
     LayoutUnit top = std::min(root_box.SelectionTop(), root_box.LineTop());
     if (point_block_direction > top ||
         (!blocks_are_flipped && point_block_direction == top)) {
       LayoutUnit bottom = root_box.SelectionBottom();
       if (root_box.NextRootBox())
@@ skipping 729 matching lines @@
     return true;
   }
   for (unsigned i = 0; i < length; ++i) {
     if (!Style()->IsCollapsibleWhiteSpace(Characters16()[i]))
       return false;
   }
   return true;
 }
 
 bool LayoutText::IsRenderedCharacter(int offset_in_node) const {
-  for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox()) {
+  for (InlineTextBox* box : InlineTextBoxesOf(*this)) {
     if (offset_in_node < static_cast<int>(box->Start()) &&
         !ContainsReversedText()) {
       // The offset we're looking for is before this node this means the offset
       // must be in content that is not laid out. Return false.
       return false;
     }
     if (offset_in_node >= static_cast<int>(box->Start()) &&
         offset_in_node < static_cast<int>(box->Start() + box->Len()))
       return true;
   }
@@ skipping 37 matching lines @@
       if (GetSelectionState() == SelectionState::kStart) {
         end_pos = TextLength();
 
         // to handle selection from end of text to end of line
         if (start_pos && start_pos == end_pos)
           start_pos = end_pos - 1;
       } else if (GetSelectionState() == SelectionState::kEnd) {
         start_pos = 0;
       }
 
-      for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox()) {
+      for (InlineTextBox* box : InlineTextBoxesOf(*this)) {
         if (box->IsSelected(start_pos, end_pos)) {
           box->Root().SetHasSelectedChildren(true);
         }
       }
     } else {
-      for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox()) {
+      for (InlineTextBox* box : InlineTextBoxesOf(*this)) {
         box->Root().SetHasSelectedChildren(state == SelectionState::kInside);
       }
     }
   }
 
   // The containing block can be null in case of an orphaned tree.
   LayoutBlock* containing_block = this->ContainingBlock();
   if (containing_block && !containing_block->IsLayoutView())
     containing_block->SetSelectionState(state);
 }
@@ skipping 10 matching lines @@
   int delta = new_len - old_len;
   unsigned end = len ? offset + len - 1 : offset;
 
   RootInlineBox* first_root_box = nullptr;
   RootInlineBox* last_root_box = nullptr;
 
   bool dirtied_lines = false;
 
   // Dirty all text boxes that include characters in between offset and
   // offset+len.
-  for (InlineTextBox* curr = FirstTextBox(); curr; curr = curr->NextTextBox()) {
+  for (InlineTextBox* curr : InlineTextBoxesOf(*this)) {
     // FIXME: This shouldn't rely on the end of a dirty line box. See
     // https://bugs.webkit.org/show_bug.cgi?id=97264
     // Text run is entirely before the affected range.
     if (curr->end() < offset)
       continue;
 
     // Text run is entirely after the affected range.
     if (curr->Start() > end) {
       curr->OffsetRun(delta);
       RootInlineBox* root = &curr->Root();
@@ skipping 185 matching lines @@
 
 void LayoutText::DirtyOrDeleteLineBoxesIfNeeded(bool full_layout) {
   if (full_layout)
     DeleteTextBoxes();
   else if (!lines_dirty_)
     DirtyLineBoxes();
   lines_dirty_ = false;
 }
 
 void LayoutText::DirtyLineBoxes() {
-  for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox())
+  for (InlineTextBox* box : InlineTextBoxesOf(*this))
     box->DirtyLineBoxes();
   lines_dirty_ = false;
 }
 
 InlineTextBox* LayoutText::CreateTextBox(int start, unsigned short length) {
   return new InlineTextBox(LineLayoutItem(this), start, length);
 }
 
 InlineTextBox* LayoutText::CreateInlineTextBox(int start,
                                                unsigned short length) {
@@ skipping 100 matching lines @@
 
 LayoutRect LayoutText::LinesBoundingBox() const {
   LayoutRect result;
 
   DCHECK_EQ(!FirstTextBox(),
             !LastTextBox());  // Either both are null or both exist.
   if (FirstTextBox() && LastTextBox()) {
     // Return the width of the minimal left side and the maximal right side.
     float logical_left_side = 0;
     float logical_right_side = 0;
-    for (InlineTextBox* curr = FirstTextBox(); curr;
-         curr = curr->NextTextBox()) {
+    for (InlineTextBox* curr : InlineTextBoxesOf(*this)) {
       if (curr == FirstTextBox() || curr->LogicalLeft() < logical_left_side)
         logical_left_side = curr->LogicalLeft().ToFloat();
       if (curr == FirstTextBox() || curr->LogicalRight() > logical_right_side)
         logical_right_side = curr->LogicalRight().ToFloat();
     }
 
     bool is_horizontal = Style()->IsHorizontalWritingMode();
 
     float x = is_horizontal ? logical_left_side : FirstTextBox()->X().ToFloat();
     float y = is_horizontal ? FirstTextBox()->Y().ToFloat() : logical_left_side;
     float width = is_horizontal ? logical_right_side - logical_left_side
                                 : LastTextBox()->LogicalBottom() - x;
     float height = is_horizontal ? LastTextBox()->LogicalBottom() - y
                                  : logical_right_side - logical_left_side;
     result = EnclosingLayoutRect(FloatRect(x, y, width, height));
   }
 
   return result;
 }
 
 LayoutRect LayoutText::VisualOverflowRect() const {
   if (!FirstTextBox())
     return LayoutRect();
 
   // Return the width of the minimal left side and the maximal right side.
   LayoutUnit logical_left_side = LayoutUnit::Max();
   LayoutUnit logical_right_side = LayoutUnit::Min();
-  for (InlineTextBox* curr = FirstTextBox(); curr; curr = curr->NextTextBox()) {
+  for (InlineTextBox* curr : InlineTextBoxesOf(*this)) {
     LayoutRect logical_visual_overflow = curr->LogicalOverflowRect();
     logical_left_side =
         std::min(logical_left_side, logical_visual_overflow.X());
     logical_right_side =
         std::max(logical_right_side, logical_visual_overflow.MaxX());
   }
 
   LayoutUnit logical_top = FirstTextBox()->LogicalTopVisualOverflow();
   LayoutUnit logical_width = logical_right_side - logical_left_side;
   LayoutUnit logical_height =
@@ skipping 53 matching lines @@
       end_pos = TextLength();
     else if (GetSelectionState() == SelectionState::kEnd)
       start_pos = 0;
   }
 
   LayoutRect rect;
 
   if (start_pos == end_pos)
     return rect;
 
-  for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox()) {
+  for (InlineTextBox* box : InlineTextBoxesOf(*this)) {
     rect.Unite(box->LocalSelectionRect(start_pos, end_pos));
     rect.Unite(LayoutRect(EllipsisRectForBox(box, start_pos, end_pos)));
   }
 
   return rect;
 }
 
 int LayoutText::CaretMinOffset() const {
   InlineTextBox* box = FirstTextBox();
   if (!box)
@@ skipping 10 matching lines @@
     return TextLength();
 
   int max_offset = box->Start() + box->Len();
   for (box = box->PrevTextBox(); box; box = box->PrevTextBox())
     max_offset = std::max<int>(max_offset, box->Start() + box->Len());
   return max_offset;
 }
 
 unsigned LayoutText::ResolvedTextLength() const {
   int len = 0;
-  for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox())
+  for (InlineTextBox* box : InlineTextBoxesOf(*this))
     len += box->Len();
   return len;
 }
 
 void LayoutText::MomentarilyRevealLastTypedCharacter(
     unsigned last_typed_character_offset) {
   if (!g_secure_text_timers)
     g_secure_text_timers = new SecureTextTimerMap;
 
   SecureTextTimer* secure_text_timer = g_secure_text_timers->at(this);
   if (!secure_text_timer) {
     secure_text_timer = new SecureTextTimer(this);
     g_secure_text_timers->insert(this, secure_text_timer);
   }
   secure_text_timer->RestartWithNewText(last_typed_character_offset);
 }
 
 PassRefPtr<AbstractInlineTextBox> LayoutText::FirstAbstractInlineTextBox() {
   return AbstractInlineTextBox::GetOrCreate(LineLayoutText(this),
                                             first_text_box_);
 }
 
 void LayoutText::InvalidateDisplayItemClients(
     PaintInvalidationReason invalidation_reason) const {
   ObjectPaintInvalidator paint_invalidator(*this);
   paint_invalidator.InvalidateDisplayItemClient(*this, invalidation_reason);
 
-  for (InlineTextBox* box = FirstTextBox(); box; box = box->NextTextBox()) {
+  for (InlineTextBox* box : InlineTextBoxesOf(*this)) {
     paint_invalidator.InvalidateDisplayItemClient(*box, invalidation_reason);
     if (box->Truncation() != kCNoTruncation) {
       if (EllipsisBox* ellipsis_box = box->Root().GetEllipsisBox())
         paint_invalidator.InvalidateDisplayItemClient(*ellipsis_box,
                                                       invalidation_reason);
     }
   }
 }
 
 // TODO(lunalu): Would be better to dump the bounding box x and y rather than
 // the first run's x and y, but that would involve updating many test results.
 LayoutRect LayoutText::DebugRect() const {
   IntRect lines_box = EnclosingIntRect(LinesBoundingBox());
   LayoutRect rect = LayoutRect(
       IntRect(FirstRunX(), FirstRunY(), lines_box.Width(), lines_box.Height()));
   LayoutBlock* block = ContainingBlock();
   if (block && HasTextBoxes())
     block->AdjustChildDebugRect(rect);
 
   return rect;
 }
 
+// -----
+InlineTextBoxRange::Iterator::Iterator(InlineTextBox* current)
+    : current_(current) {}
+
+InlineTextBoxRange::Iterator& InlineTextBoxRange::Iterator::operator++() {
+  current_ = current_->NextTextBox();
+  return *this;
+}
+
+InlineTextBox* InlineTextBoxRange::Iterator::operator*() const {
+  DCHECK(current_);
+  return current_;
+}
+
+InlineTextBoxRange::InlineTextBoxRange(const LayoutText& layout_text)
+    : layout_text_(&layout_text) {}
+
+InlineTextBoxRange InlineTextBoxesOf(const LayoutText& layout_text) {
+  return InlineTextBoxRange(layout_text);
+}
+
 }  // namespace blink