Refactor Most{Back,For}wardCaretPosition()

third_party/WebKit/Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights
  * reserved.
  *
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 1569 matching lines @@
       position.AnchorNode(), Strategy::CaretMaxOffset(*position.AnchorNode()));
 }
 
 template <typename Strategy>
 static PositionTemplate<Strategy> MostBackwardCaretPosition(
     const PositionTemplate<Strategy>& position,
     EditingBoundaryCrossingRule rule) {
   DCHECK(!NeedsLayoutTreeUpdate(position)) << position;
   TRACE_EVENT0("input", "VisibleUnits::mostBackwardCaretPosition");
 
-  Node* start_node = position.AnchorNode();
+  Node* const start_node = position.AnchorNode();
   if (!start_node)
     return PositionTemplate<Strategy>();
 
   // iterate backward from there, looking for a qualified position
-  Node* boundary = EnclosingVisualBoundary<Strategy>(start_node);
+  Node* const boundary = EnclosingVisualBoundary<Strategy>(start_node);
   // FIXME: PositionIterator should respect Before and After positions.
   PositionIteratorAlgorithm<Strategy> last_visible(
       AdjustPositionForBackwardIteration<Strategy>(position));
-  PositionIteratorAlgorithm<Strategy> current_pos = last_visible;
-  bool start_editable = HasEditableStyle(*start_node);
+  const bool start_editable = HasEditableStyle(*start_node);
   Node* last_node = start_node;
   bool boundary_crossed = false;
-  for (; !current_pos.AtStart(); current_pos.Decrement()) {
+  for (PositionIteratorAlgorithm<Strategy> current_pos = last_visible;
+       !current_pos.AtStart(); current_pos.Decrement()) {
     Node* current_node = current_pos.GetNode();
     // Don't check for an editability change if we haven't moved to a different
     // node, to avoid the expense of computing hasEditableStyle().
     if (current_node != last_node) {
       // Don't change editability.
-      bool current_editable = HasEditableStyle(*current_node);
+      const bool current_editable = HasEditableStyle(*current_node);
       if (start_editable != current_editable) {
         if (rule == kCannotCrossEditingBoundary)
           break;
         boundary_crossed = true;
       }
       last_node = current_node;
     }
 
     // If we've moved to a position that is visually distinct, return the last
     // saved position. There is code below that terminates early if we're
     // *about* to move to a visually distinct position.
     if (EndsOfNodeAreVisuallyDistinctPositions(current_node) &&
         current_node != boundary)
       return last_visible.DeprecatedComputePosition();
 
     // skip position in non-laid out or invisible node
-    LayoutObject* layout_object =
+    LayoutObject* const layout_object =
         AssociatedLayoutObjectOf(*current_node, current_pos.OffsetInLeafNode());
     if (!layout_object ||
         layout_object->Style()->Visibility() != EVisibility::kVisible)
       continue;
 
     if (rule == kCanCrossEditingBoundary && boundary_crossed) {
       last_visible = current_pos;
       break;
     }
 
@@ skipping 11 matching lines @@
     // Return position after tables and nodes which have content that can be
     // ignored.
     if (EditingIgnoresContent(*current_node) ||
         IsDisplayInsideTable(current_node)) {
       if (current_pos.AtEndOfNode())
         return PositionTemplate<Strategy>::AfterNode(current_node);
       continue;
     }
 
     // return current position if it is in laid out text
-    if (layout_object->IsText() &&
-        ToLayoutText(layout_object)->FirstTextBox()) {
-      LayoutText* const text_layout_object = ToLayoutText(layout_object);
-      const unsigned text_start_offset = text_layout_object->TextStartOffset();
-      if (current_node != start_node) {
-        // This assertion fires in layout tests in the case-transform.html test
-        // because of a mix-up between offsets in the text in the DOM tree with
-        // text in the layout tree which can have a different length due to case
-        // transformation.
-        // Until we resolve that, disable this so we can run the layout tests!
-        // DCHECK_GE(currentOffset, layoutObject->caretMaxOffset());
-        return PositionTemplate<Strategy>(
-            current_node, layout_object->CaretMaxOffset() + text_start_offset);
-      }
+    if (!layout_object->IsText())
+      continue;
+    LayoutText* const text_layout_object = ToLayoutText(layout_object);
+    if (!text_layout_object->FirstTextBox())
+      continue;
+    const unsigned text_start_offset = text_layout_object->TextStartOffset();
+    if (current_node != start_node) {
+      // This assertion fires in layout tests in the case-transform.html test
+      // because of a mix-up between offsets in the text in the DOM tree with
+      // text in the layout tree which can have a different length due to case
+      // transformation.
+      // Until we resolve that, disable this so we can run the layout tests!
+      // DCHECK_GE(currentOffset, layoutObject->caretMaxOffset());
+      return PositionTemplate<Strategy>(
+          current_node, layout_object->CaretMaxOffset() + text_start_offset);
+    }
 
-      if (CanBeBackwardCaretPosition(text_layout_object,
-                                     current_pos.OffsetInLeafNode())) {
-        return current_pos.ComputePosition();
-      }
+    if (CanBeBackwardCaretPosition(text_layout_object,
+                                   current_pos.OffsetInLeafNode())) {
+      return current_pos.ComputePosition();
     }
   }
   return last_visible.DeprecatedComputePosition();
 }
 
 // The text continues on the next line only if the last text box is not on this
 // line and none of the boxes on this line have a larger start offset.
 static bool DoesContinueOnNextLine(const LayoutText& text_layout_object,
                                    InlineBox* box,
                                    unsigned text_offset) {
@@ skipping 77 matching lines @@
   return MostBackwardCaretPosition<EditingInFlatTreeStrategy>(position, rule);
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> MostForwardCaretPosition(
     const PositionTemplate<Strategy>& position,
     EditingBoundaryCrossingRule rule) {
   DCHECK(!NeedsLayoutTreeUpdate(position)) << position;
   TRACE_EVENT0("input", "VisibleUnits::mostForwardCaretPosition");
 
-  Node* start_node = position.AnchorNode();
+  Node* const start_node = position.AnchorNode();
   if (!start_node)
     return PositionTemplate<Strategy>();
 
   // iterate forward from there, looking for a qualified position
-  Node* boundary = EnclosingVisualBoundary<Strategy>(start_node);
+  Node* const boundary = EnclosingVisualBoundary<Strategy>(start_node);
   // FIXME: PositionIterator should respect Before and After positions.
   PositionIteratorAlgorithm<Strategy> last_visible(
       position.IsAfterAnchor()
           ? PositionTemplate<Strategy>::EditingPositionOf(
                 position.AnchorNode(),
                 Strategy::CaretMaxOffset(*position.AnchorNode()))
           : position);
-  PositionIteratorAlgorithm<Strategy> current_pos = last_visible;
-  bool start_editable = HasEditableStyle(*start_node);
+  const bool start_editable = HasEditableStyle(*start_node);
   Node* last_node = start_node;
   bool boundary_crossed = false;
-  for (; !current_pos.AtEnd(); current_pos.Increment()) {
+  for (PositionIteratorAlgorithm<Strategy> current_pos = last_visible;
+       !current_pos.AtEnd(); current_pos.Increment()) {
     Node* current_node = current_pos.GetNode();
     // Don't check for an editability change if we haven't moved to a different
     // node, to avoid the expense of computing hasEditableStyle().
     if (current_node != last_node) {
       // Don't change editability.
-      bool current_editable = HasEditableStyle(*current_node);
+      const bool current_editable = HasEditableStyle(*current_node);
       if (start_editable != current_editable) {
         if (rule == kCannotCrossEditingBoundary)
           break;
         boundary_crossed = true;
       }
 
       last_node = current_node;
     }
 
     // stop before going above the body, up into the head
     // return the last visible streamer position
     if (isHTMLBodyElement(*current_node) && current_pos.AtEndOfNode())
       break;
 
     // Do not move to a visually distinct position.
     if (EndsOfNodeAreVisuallyDistinctPositions(current_node) &&
         current_node != boundary)
       return last_visible.DeprecatedComputePosition();
     // Do not move past a visually disinct position.
     // Note: The first position after the last in a node whose ends are visually
     // distinct positions will be [boundary->parentNode(),
     // originalBlock->nodeIndex() + 1].
     if (boundary && Strategy::Parent(*boundary) == current_node)
       return last_visible.DeprecatedComputePosition();
 
     // skip position in non-laid out or invisible node
-    LayoutObject* layout_object =
+    LayoutObject* const layout_object =
         AssociatedLayoutObjectOf(*current_node, current_pos.OffsetInLeafNode());
     if (!layout_object ||
         layout_object->Style()->Visibility() != EVisibility::kVisible)
       continue;
 
-    if (rule == kCanCrossEditingBoundary && boundary_crossed) {
-      last_visible = current_pos;
-      break;
-    }
+    if (rule == kCanCrossEditingBoundary && boundary_crossed)
+      return current_pos.DeprecatedComputePosition();
 
     // track last visible streamer position
     if (IsStreamer<Strategy>(current_pos))
       last_visible = current_pos;
 
     // Return position before tables and nodes which have content that can be
     // ignored.
     if (EditingIgnoresContent(*current_node) ||
         IsDisplayInsideTable(current_node)) {
       if (current_pos.OffsetInLeafNode() <= layout_object->CaretMinOffset())
         return PositionTemplate<Strategy>::EditingPositionOf(
             current_node, layout_object->CaretMinOffset());
       continue;
     }
 
     // return current position if it is in laid out text
-    if (layout_object->IsText() &&
-        ToLayoutText(layout_object)->FirstTextBox()) {
-      LayoutText* const text_layout_object = ToLayoutText(layout_object);
-      const unsigned text_start_offset = text_layout_object->TextStartOffset();
-      if (current_node != start_node) {
-        DCHECK(current_pos.AtStartOfNode());
-        return PositionTemplate<Strategy>(
-            current_node, layout_object->CaretMinOffset() + text_start_offset);
-      }
+    if (!layout_object->IsText())
+      continue;
+    LayoutText* const text_layout_object = ToLayoutText(layout_object);
+    if (!text_layout_object->FirstTextBox())
+      continue;
+    const unsigned text_start_offset = text_layout_object->TextStartOffset();
+    if (current_node != start_node) {
+      DCHECK(current_pos.AtStartOfNode());
+      return PositionTemplate<Strategy>(
+          current_node, layout_object->CaretMinOffset() + text_start_offset);
+    }
 
-      if (CanBeForwardCaretPosition(text_layout_object,
-                                    current_pos.OffsetInLeafNode())) {
-        return current_pos.ComputePosition();
-      }
+    if (CanBeForwardCaretPosition(text_layout_object,
+                                  current_pos.OffsetInLeafNode())) {
+      return current_pos.ComputePosition();
     }
   }
   return last_visible.DeprecatedComputePosition();
 }
 
 // TODO(editing-dev): This function is just moved out from
 // |MostForwardCaretPosition()|. We should study this function more and
 // name it appropriately. See https://trac.webkit.org/changeset/32438/
 // which introduce this.
 static bool CanBeForwardCaretPosition(const LayoutText* text_layout_object,
@@ skipping 898 matching lines @@
 
 IntRect ComputeTextRect(const EphemeralRangeInFlatTree& range) {
   return EnclosingIntRect(ComputeTextRectTemplate(range));
 }
 
 FloatRect ComputeTextFloatRect(const EphemeralRange& range) {
   return ComputeTextRectTemplate(range);
 }
 
 }  // namespace blink