Cleanup traversing in LayoutSelection.cpp::CollectSelectedMap()

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights
  * reserved.
  *
  * 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 82 matching lines @@
 
 static LayoutObject* LayoutObjectAfterPosition(LayoutObject* object,
                                                unsigned offset) {
   if (!object)
     return nullptr;
 
   LayoutObject* child = object->ChildAt(offset);
   return child ? child : object->NextInPreOrderAfterChildren();
 }
 
-// When exploring the LayoutTree looking for the nodes involved in the
-// Selection, sometimes it's required to change the traversing direction because
-// the "start" position is below the "end" one.

[yosin_UTC9, 2017/05/23 09:01:36]

It seems patch[1] introduce backward traversal to support CSS Region.
Since, Blink doesn't support CSS Region, we can remove safely.

Please add this info into description for future reference.

[1] https://chromiumcodereview.appspot.com/23674007 [CSSRegions] Not possible to
clear the selection when mixing content from different FlowThreads 

-static inline LayoutObject* GetNextOrPrevLayoutObjectBasedOnDirection(
-    const LayoutObject* o,
-    const LayoutObject* stop,
-    bool& continue_exploring,
-    bool& exploring_backwards) {
-  LayoutObject* next;
-  if (exploring_backwards) {
-    next = o->PreviousInPreOrder();
-    continue_exploring = next && !(next)->IsLayoutView();
-  } else {
-    next = o->NextInPreOrder();
-    continue_exploring = next && next != stop;
-    exploring_backwards = !next && (next != stop);
-    if (exploring_backwards) {
-      next = stop->PreviousInPreOrder();
-      continue_exploring = next && !next->IsLayoutView();
-    }
-  }
-
-  return next;
-}
-
 // Objects each have a single selection rect to examine.
 using SelectedObjectMap = HashMap<LayoutObject*, SelectionState>;
 // Blocks contain selected objects and fill gaps between them, either on the
 // left, right, or in between lines and blocks.
 // In order to get the visual rect right, we have to examine left, middle, and
 // right rects individually, since otherwise the union of those rects might
 // remain the same even when changes have occurred.
 using SelectedBlockMap = HashMap<LayoutBlock*, SelectionState>;
 struct SelectedMap {
   STACK_ALLOCATED();
@@ skipping 10 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SelectedMap);
 };
 
 static SelectedMap CollectSelectedMap(
     LayoutObject* selection_start,
     LayoutObject* selection_end,
     int selection_end_pos,
     LayoutSelection::SelectionPaintInvalidationMode
         block_paint_invalidation_mode) {
   SelectedMap selected_map;
-  LayoutObject* runner = selection_start;
+
   LayoutObject* const stop =
       LayoutObjectAfterPosition(selection_end, selection_end_pos);
-  bool exploring_backwards = false;
-  bool continue_exploring = runner && (runner != stop);
-  while (continue_exploring) {
-    if ((runner->CanBeSelectionLeaf() || runner == selection_start ||
-         runner == selection_end) &&
-        runner->GetSelectionState() != SelectionNone) {
-      // Blocks are responsible for painting line gaps and margin gaps.  They
-      // must be examined as well.
-      selected_map.object_map.Set(runner, runner->GetSelectionState());
-      if (block_paint_invalidation_mode ==
-          LayoutSelection::kPaintInvalidationNewXOROld) {
-        LayoutBlock* containing_block = runner->ContainingBlock();
-        while (containing_block && !containing_block->IsLayoutView()) {
-          SelectedBlockMap::AddResult result = selected_map.block_map.insert(
-              containing_block, containing_block->GetSelectionState());
-          if (!result.is_new_entry)
-            break;
-          containing_block = containing_block->ContainingBlock();
-        }
+  for (LayoutObject* runner = selection_start; runner && (runner != stop);
+       runner = runner->NextInPreOrder()) {
+    if (!runner->CanBeSelectionLeaf() && runner != selection_start &&
+        runner != selection_end)
+      continue;
+    if (runner->GetSelectionState() == SelectionNone)
+      continue;
+
+    // Blocks are responsible for painting line gaps and margin gaps.  They
+    // must be examined as well.
+    selected_map.object_map.Set(runner, runner->GetSelectionState());
+    if (block_paint_invalidation_mode ==
+        LayoutSelection::kPaintInvalidationNewXOROld) {
+      LayoutBlock* containing_block = runner->ContainingBlock();
+      while (containing_block && !containing_block->IsLayoutView()) {
+        SelectedBlockMap::AddResult result = selected_map.block_map.insert(
+            containing_block, containing_block->GetSelectionState());
+        if (!result.is_new_entry)
+          break;
+        containing_block = containing_block->ContainingBlock();
       }
     }
-
-    runner = GetNextOrPrevLayoutObjectBasedOnDirection(
-        runner, stop, continue_exploring, exploring_backwards);
   }
   return selected_map;
 }
 
 // Update the selection status of all LayoutObjects between |start| and |end|.
 static void SetSelectionState(LayoutObject* start,
                               LayoutObject* end,
                               int end_pos) {
   if (start && start == end) {
     start->SetSelectionStateIfNeeded(SelectionBoth);
@@ skipping 144 matching lines @@
   if (IsVisuallyEquivalentCandidate(candidate))
     end_pos = candidate;
 
   // We can get into a state where the selection endpoints map to the same
   // |VisiblePosition| when a selection is deleted because we don't yet notify
   // the |FrameSelection| of text removal.
   if (start_pos.IsNull() || end_pos.IsNull() ||
       selection.VisibleStart().DeepEquivalent() ==
           selection.VisibleEnd().DeepEquivalent())
     return;
+  DCHECK(start_pos <= end_pos);

[yosin_UTC9, 2017/05/23 09:01:36]

nit: DCHECK_LE(start_pos, end_pos)

   LayoutObject* start_layout_object = start_pos.AnchorNode()->GetLayoutObject();
   LayoutObject* end_layout_object = end_pos.AnchorNode()->GetLayoutObject();
   if (!start_layout_object || !end_layout_object)
     return;
   DCHECK(start_layout_object->View() == end_layout_object->View());
   SetSelection(start_layout_object, start_pos.ComputeEditingOffset(),
                end_layout_object, end_pos.ComputeEditingOffset());
 }
 
 void LayoutSelection::OnDocumentShutdown() {
@@ skipping 62 matching lines @@
 
     o->SetShouldInvalidateSelection();
   }
 }
 
 DEFINE_TRACE(LayoutSelection) {
   visitor->Trace(frame_selection_);
 }
 
 }  // namespace blink