Refactor EndOfLineAlgorithm()

third_party/WebKit/Source/core/editing/VisibleUnitsLine.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 376 matching lines @@
   return CreateVisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
 }
 
 // TODO(yosin) Rename this function to reflect the fact it ignores bidi levels.
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> EndOfLineAlgorithm(
     const VisiblePositionTemplate<Strategy>& current_position) {
   DCHECK(current_position.IsValid()) << current_position;
   // TODO(yosin) this is the current behavior that might need to be fixed.
   // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
-  VisiblePositionTemplate<Strategy> vis_pos =
+  const VisiblePositionTemplate<Strategy>& candidate_position =
       EndPositionForLine(current_position, kUseInlineBoxOrdering);
 
   // Make sure the end of line is at the same line as the given input
   // position. Else use the previous position to obtain end of line. This
   // condition happens when the input position is before the space character
   // at the end of a soft-wrapped non-editable line. In this scenario,
   // |endPositionForLine()| would incorrectly hand back a position in the next
   // line instead. This fix is to account for the discrepancy between lines
   // with "webkit-line-break:after-white-space" style versus lines without
   // that style, which would break before a space by default.
-  if (!InSameLine(current_position, vis_pos)) {
-    vis_pos = PreviousPositionOf(current_position);
-    if (vis_pos.IsNull())
-      return VisiblePositionTemplate<Strategy>();
-    vis_pos = EndPositionForLine(vis_pos, kUseInlineBoxOrdering);
+  if (InSameLine(current_position, candidate_position)) {
+    return HonorEditingBoundaryAtOrAfter(candidate_position,
+                                         current_position.DeepEquivalent());
   }
-
-  return HonorEditingBoundaryAtOrAfter(vis_pos,
-                                       current_position.DeepEquivalent());
+  const VisiblePositionTemplate<Strategy>& adjusted_position =
+      PreviousPositionOf(current_position);
+  if (adjusted_position.IsNull())
+    return VisiblePositionTemplate<Strategy>();
+  return HonorEditingBoundaryAtOrAfter(
+      EndPositionForLine(adjusted_position, kUseInlineBoxOrdering),
+      current_position.DeepEquivalent());
 }
 
 // TODO(yosin) Rename this function to reflect the fact it ignores bidi levels.
 VisiblePosition EndOfLine(const VisiblePosition& current_position) {
   return EndOfLineAlgorithm<EditingStrategy>(current_position);
 }
 
 VisiblePositionInFlatTree EndOfLine(
     const VisiblePositionInFlatTree& current_position) {
   return EndOfLineAlgorithm<EditingInFlatTreeStrategy>(current_position);
@@ skipping 260 matching lines @@
   // to the end of the line we're on.
   Element* root_element = HasEditableStyle(*node, editable_type)
                               ? RootEditableElement(*node, editable_type)
                               : node->GetDocument().documentElement();
   if (!root_element)
     return VisiblePosition();
   return VisiblePosition::LastPositionInNode(root_element);
 }
 
 }  // namespace blink