Make LayoutSelection::SetSelection() local

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 144 matching lines @@
   SelectedMap() = default;
   SelectedMap(SelectedMap&& other) {
     object_map = std::move(other.object_map);
     block_map = std::move(other.block_map);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SelectedMap);
 };
 
-static SelectedMap CollectSelectedMap(
-    const SelectionPaintRange& range,
-    LayoutSelection::SelectionPaintInvalidationMode
-        block_paint_invalidation_mode) {
+enum class CollectSelectedMapOption {
+  kCollectBlock,
+  kNotCollectBlock,
+};
+static SelectedMap CollectSelectedMap(const SelectionPaintRange& range,

[yosin_UTC9, 2017/05/29 07:59:37]

nit: Could you add a blank line between enum and function?

[yoichio, 2017/05/30 04:15:03]

Done.

+                                      CollectSelectedMapOption option) {
   if (range.IsNull())
     return SelectedMap();
 
   SelectedMap selected_map;
 
   LayoutObject* const stop =
       LayoutObjectAfterPosition(range.EndLayoutObject(), range.EndOffset());
   for (LayoutObject* runner = range.StartLayoutObject();
        runner && (runner != stop); runner = runner->NextInPreOrder()) {
     if (!runner->CanBeSelectionLeaf() && runner != range.StartLayoutObject() &&
         runner != range.EndLayoutObject())
       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) {
+    if (option == CollectSelectedMapOption::kCollectBlock) {
       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();
       }
     }
   }
@@ skipping 15 matching lines @@
   LayoutObject* const stop =
       LayoutObjectAfterPosition(range.EndLayoutObject(), range.EndOffset());
   for (LayoutObject* runner = range.StartLayoutObject();
        runner && runner != stop; runner = runner->NextInPreOrder()) {
     if (runner != range.StartLayoutObject() &&
         runner != range.EndLayoutObject() && runner->CanBeSelectionLeaf())
       runner->SetSelectionStateIfNeeded(SelectionInside);
   }
 }
 
-void LayoutSelection::SetSelection(
+static void SetSelectionStateAndShouldInvalidateSelection(

[yosin_UTC9, 2017/05/29 07:59:37]

nit:
s/SetSelectionStateAndShouldInvalidateSelection/SetSelectionStateAndInvalidate/
or better name, we don't need to have |Should| in function name.

[yoichio, 2017/05/29 08:36:26]

Fmm, actually we don't invalidate LayoutObject yet.
Just turn |ShouldInvalidateSelection| flag on.

[yosin_UTC9, 2017/05/29 09:38:15]

How about SetSelectionStateAndPaintInvalidationFlag?
LayoutObject::ClearPaintInvalidationFlags() has
bitfiels_.SetShouldInvalidateSelection(false);

[yoichio, 2017/05/30 04:15:03]

Sine this is a local function and used only once, exact descriptive naming is 
 not needed.
Added some comment.

     const SelectionPaintRange& new_range,
-    SelectionPaintInvalidationMode block_paint_invalidation_mode) {
-  DCHECK(!new_range.IsNull());
-
-  // Just return if the selection hasn't changed.
-  if (paint_range_ == new_range)
-    return;
-
-  DCHECK(frame_selection_->GetDocument().GetLayoutView()->GetFrameView());
-  DCHECK(!frame_selection_->GetDocument().NeedsLayoutTreeUpdate());
-
+    const SelectionPaintRange& old_range) {
   SelectedMap old_selected_map =
-      CollectSelectedMap(paint_range_, block_paint_invalidation_mode);
+      CollectSelectedMap(old_range, CollectSelectedMapOption::kCollectBlock);
 
   // Now clear the selection.
   for (auto layout_object : old_selected_map.object_map.Keys())
     layout_object->SetSelectionStateIfNeeded(SelectionNone);
 
   SetSelectionState(new_range);
 
   // Now that the selection state has been updated for the new objects, walk
   // them again and put them in the new objects list.
   // TODO(editing-dev): |new_selected_map| doesn't really need to store the
   // SelectionState, it's just more convenient to have it use the same data
   // structure as |old_selected_map|.
   SelectedMap new_selected_map =
-      CollectSelectedMap(new_range, kPaintInvalidationNewXOROld);
+      CollectSelectedMap(new_range, CollectSelectedMapOption::kCollectBlock);
 
   // Have any of the old selected objects changed compared to the new selection?
   for (const auto& pair : old_selected_map.object_map) {
     LayoutObject* obj = pair.key;
     SelectionState new_selection_state = obj->GetSelectionState();
     SelectionState old_selection_state = pair.value;
     if (new_selection_state != old_selection_state ||
         (new_range.StartLayoutObject() == obj &&
-         new_range.StartOffset() != paint_range_.StartOffset()) ||
+         new_range.StartOffset() != old_range.StartOffset()) ||
         (new_range.EndLayoutObject() == obj &&
-         new_range.EndOffset() != paint_range_.EndOffset())) {
+         new_range.EndOffset() != old_range.EndOffset())) {
       obj->SetShouldInvalidateSelection();
       new_selected_map.object_map.erase(obj);
     }
   }
 
   // Any new objects that remain were not found in the old objects dict, and so
   // they need to be updated.
   for (auto layout_object : new_selected_map.object_map.Keys())
     layout_object->SetShouldInvalidateSelection();
 
   // Have any of the old blocks changed?
   for (const auto& pair : old_selected_map.block_map) {
     LayoutBlock* block = pair.key;
     SelectionState new_selection_state = block->GetSelectionState();
     SelectionState old_selection_state = pair.value;
     if (new_selection_state != old_selection_state) {
       block->SetShouldInvalidateSelection();
       new_selected_map.block_map.erase(block);
     }
   }
 
   // Any new blocks that remain were not found in the old blocks dict, and so
   // they need to be updated.
   for (auto layout_object : new_selected_map.block_map.Keys())
     layout_object->SetShouldInvalidateSelection();
-
-  paint_range_ = new_range;
 }
 
 std::pair<int, int> LayoutSelection::SelectionStartEnd() {
   Commit();
   if (paint_range_.IsNull())
     return std::make_pair(-1, -1);
   return std::make_pair(paint_range_.StartOffset(), paint_range_.EndOffset());
 }
 
 void LayoutSelection::ClearSelection() {
   // For querying Layer::compositingState()
   // This is correct, since destroying layout objects needs to cause eager paint
   // invalidations.
   DisableCompositingQueryAsserts disabler;
 
   // Just return if the selection is already empty.
   if (paint_range_.IsNull())
     return;
 
-  const SelectedMap& old_selected_map =
-      CollectSelectedMap(paint_range_, kPaintInvalidationNewMinusOld);
+  const SelectedMap& old_selected_map = CollectSelectedMap(
+      paint_range_, CollectSelectedMapOption::kNotCollectBlock);
   // Clear SelectionState and invalidation.
   for (auto layout_object : old_selected_map.object_map.Keys()) {
     const SelectionState old_state = layout_object->GetSelectionState();
     layout_object->SetSelectionStateIfNeeded(SelectionNone);
     if (layout_object->GetSelectionState() == old_state)
       continue;
     layout_object->SetShouldInvalidateSelection();
   }
 
   // Reset selection.
@@ skipping 41 matching lines @@
   if (start_pos.IsNull() || end_pos.IsNull() ||
       selection.VisibleStart().DeepEquivalent() ==
           selection.VisibleEnd().DeepEquivalent())
     return;
   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(
-      SelectionPaintRange(start_layout_object, start_pos.ComputeEditingOffset(),
-                          end_layout_object, end_pos.ComputeEditingOffset()));
+
+  SelectionPaintRange new_range(
+      start_layout_object, start_pos.ComputeEditingOffset(), end_layout_object,
+      end_pos.ComputeEditingOffset());
+  // Just return if the selection hasn't changed.
+  if (paint_range_ == new_range)
+    return;
+
+  DCHECK(frame_selection_->GetDocument().GetLayoutView()->GetFrameView());
+  DCHECK(!frame_selection_->GetDocument().NeedsLayoutTreeUpdate());
+  SetSelectionStateAndShouldInvalidateSelection(new_range, paint_range_);
+  paint_range_ = new_range;
 }
 
 void LayoutSelection::OnDocumentShutdown() {
   has_pending_selection_ = false;
   paint_range_ = SelectionPaintRange();
 }
 
 static LayoutRect SelectionRectForLayoutObject(const LayoutObject* object) {
   if (!object->IsRooted())
     return LayoutRect();
@@ skipping 58 matching lines @@
 
     o->SetShouldInvalidateSelection();
   }
 }
 
 DEFINE_TRACE(LayoutSelection) {
   visitor->Trace(frame_selection_);
 }
 
 }  // namespace blink