Introduce SelectionPaintRange in LayoutSelection

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 14 matching lines @@
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/html/TextControlElement.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/PaintLayer.h"
 
 namespace blink {
 
+SelectionPaintRange::SelectionPaintRange(LayoutObject* start_layout_object,
+                                         int start_offset,
+                                         LayoutObject* end_layout_object,
+                                         int end_offset)
+    : start_layout_object_(start_layout_object),
+      start_offset_(start_offset),
+      end_layout_object_(end_layout_object),
+      end_offset_(end_offset) {
+  DCHECK(start_layout_object_);
+  DCHECK(end_layout_object_);
+  if (start_layout_object_ == end_layout_object_)

[yosin_UTC9, 2017/05/25 04:29:15]

nit: early-return style is better.

[yoichio, 2017/05/25 08:29:03]

Done.

+    DCHECK_LT(start_offset_, end_offset_);
+}
+
+bool SelectionPaintRange::operator==(const SelectionPaintRange& other) const {
+  return start_layout_object_ == other.start_layout_object_ &&
+         start_offset_ == other.start_offset_ &&
+         end_layout_object_ == other.end_layout_object_ &&
+         end_offset_ == other.end_offset_;
+}
+
+LayoutObject* SelectionPaintRange::StartLayoutObject() const {
+  DCHECK(!IsNull());
+  return start_layout_object_;
+}
+
+int SelectionPaintRange::StartOffset() const {
+  DCHECK(!IsNull());
+  return start_offset_;
+}
+
+LayoutObject* SelectionPaintRange::EndLayoutObject() const {
+  DCHECK(!IsNull());
+  return end_layout_object_;
+}
+
+int SelectionPaintRange::EndOffset() const {
+  DCHECK(!IsNull());
+  return end_offset_;
+}
+
 LayoutSelection::LayoutSelection(FrameSelection& frame_selection)
     : frame_selection_(&frame_selection),
       has_pending_selection_(false),
-      selection_start_(nullptr),
-      selection_end_(nullptr),
-      selection_start_pos_(-1),
-      selection_end_pos_(-1) {}
+      paint_range_(SelectionPaintRange()) {}
 
 SelectionInFlatTree LayoutSelection::CalcVisibleSelection(
     const VisibleSelectionInFlatTree& original_selection) const {
   const PositionInFlatTree& start = original_selection.Start();
   const PositionInFlatTree& end = original_selection.end();
   SelectionType selection_type = original_selection.GetSelectionType();
   const TextAffinity affinity = original_selection.Affinity();
 
   bool paint_block_cursor =
       frame_selection_->ShouldShowBlockCursor() &&
@@ skipping 65 matching lines @@
   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(
-    LayoutObject* selection_start,
-    LayoutObject* selection_end,
-    int selection_end_pos,
+    const SelectionPaintRange& range,
     LayoutSelection::SelectionPaintInvalidationMode
         block_paint_invalidation_mode) {
+  DCHECK(!range.IsNull());
   SelectedMap selected_map;
 
   LayoutObject* const stop =
-      LayoutObjectAfterPosition(selection_end, selection_end_pos);
-  for (LayoutObject* runner = selection_start; runner && (runner != stop);
-       runner = runner->NextInPreOrder()) {
-    if (!runner->CanBeSelectionLeaf() && runner != selection_start &&
-        runner != selection_end)
+      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) {
       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();
       }
     }
   }
   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);
+static void SetSelectionState(const SelectionPaintRange& range) {
+  DCHECK(!range.IsNull());
+  if (range.StartLayoutObject() == range.EndLayoutObject()) {
+    range.StartLayoutObject()->SetSelectionStateIfNeeded(SelectionBoth);
   } else {
-    if (start)
-      start->SetSelectionStateIfNeeded(SelectionStart);
-    if (end)
-      end->SetSelectionStateIfNeeded(SelectionEnd);
+    range.StartLayoutObject()->SetSelectionStateIfNeeded(SelectionStart);
+    range.EndLayoutObject()->SetSelectionStateIfNeeded(SelectionEnd);
   }
 
-  LayoutObject* const stop = LayoutObjectAfterPosition(end, end_pos);
-  for (LayoutObject* runner = start; runner && runner != stop;
-       runner = runner->NextInPreOrder()) {
-    if (runner != start && runner != end && runner->CanBeSelectionLeaf())
+  LayoutObject* const stop =
+      LayoutObjectAfterPosition(range.EndLayoutObject(), range.EndOffset());
+  for (LayoutObject* runner = range.StartLayoutObject();
+       runner && runner != stop; runner = runner->NextInPreOrder()) {
+    if (runner != range.StartLayoutObject() &&

[yosin_UTC9, 2017/05/25 04:29:16]

We have a pattern her:

L213
runner != range.start() && runner != range.end() && runner->CanBeSelectionLeaf()

L397
runner == range.start() || runner == range.end() || runner->CanBeSelectionLeaf()

L425
runner != range.start() && runner != range.end() &&
!runner->CanBeSelectionLeaf()

We can have a function 
// Better name please.
PaintSelectionRange::IsInside(LayoutObject* o) { return start_ == o && end_ ==
o; }

[yoichio, 2017/05/25 08:29:03]

Acknowledged.

[yosin_UTC9, 2017/05/25 09:40:31]

What do you mean "Acknowledged"? I would like to introduce IsInside() to replace
them to simplify code.

+        runner != range.EndLayoutObject() && runner->CanBeSelectionLeaf())
       runner->SetSelectionStateIfNeeded(SelectionInside);
   }
 }
 
 void LayoutSelection::SetSelection(
-    LayoutObject* start,
-    int start_pos,
-    LayoutObject* end,
-    int end_pos,
+    const SelectionPaintRange& new_range,
     SelectionPaintInvalidationMode block_paint_invalidation_mode) {
-  DCHECK(start);
-  DCHECK(end);
+  DCHECK(!new_range.IsNull());
 
   // Just return if the selection hasn't changed.
-  if (selection_start_ == start && selection_start_pos_ == start_pos &&
-      selection_end_ == end && selection_end_pos_ == end_pos)
+  if (paint_range_ == new_range)
     return;
 
   DCHECK(frame_selection_->GetDocument().GetLayoutView()->GetFrameView());
   DCHECK(!frame_selection_->GetDocument().NeedsLayoutTreeUpdate());
 
   SelectedMap old_selected_map =
-      CollectSelectedMap(selection_start_, selection_end_, selection_end_pos_,
-                         block_paint_invalidation_mode);
+      CollectSelectedMap(paint_range_, block_paint_invalidation_mode);
 
   // Now clear the selection.
   for (auto layout_object : old_selected_map.object_map.Keys())
     layout_object->SetSelectionStateIfNeeded(SelectionNone);
 
-  SetSelectionState(start, end, end_pos);
+  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(start, end, end_pos, kPaintInvalidationNewXOROld);
+      CollectSelectedMap(new_range, kPaintInvalidationNewXOROld);
 
   // 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 ||
-        (start == obj && start_pos != selection_start_pos_) ||
-        (end == obj && end_pos != selection_end_pos_)) {
+        (new_range.StartLayoutObject() == obj &&
+         new_range.StartOffset() != paint_range_.StartOffset()) ||
+        (new_range.EndLayoutObject() == obj &&
+         new_range.EndOffset() != paint_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();
 
-  // set selection start and end
-  selection_start_ = start;
-  selection_start_pos_ = start_pos;
-  selection_end_ = end;
-  selection_end_pos_ = end_pos;
+  paint_range_ = new_range;
 }
 
 std::pair<int, int> LayoutSelection::SelectionStartEnd() {
   Commit();
-  return std::make_pair(selection_start_pos_, selection_end_pos_);
+  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 hasn't changed.
-  if (!selection_start_) {
-    DCHECK_EQ(selection_end_, nullptr);
-    DCHECK_EQ(selection_start_pos_, -1);
-    DCHECK_EQ(selection_end_pos_, -1);
+  // Just return if the selection is already empty.
+  if (paint_range_.IsNull())
     return;
-  }
 
   const SelectedMap& old_selected_map =
-      CollectSelectedMap(selection_start_, selection_end_, selection_end_pos_,
-                         kPaintInvalidationNewMinusOld);
+      CollectSelectedMap(paint_range_, kPaintInvalidationNewMinusOld);
   // 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 start and end.
-  selection_start_ = nullptr;
-  selection_start_pos_ = -1;
-  selection_end_ = nullptr;
-  selection_end_pos_ = -1;
+  // Reset selection.
+  paint_range_ = SelectionPaintRange();
 }
 
 void LayoutSelection::Commit() {
   if (!HasPendingSelection())
     return;
   has_pending_selection_ = false;
 
   const VisibleSelectionInFlatTree& original_selection =
       frame_selection_->ComputeVisibleSelectionInFlatTree();
 
@@ skipping 30 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(start_layout_object, start_pos.ComputeEditingOffset(),
-               end_layout_object, end_pos.ComputeEditingOffset());
+  SetSelection(
+      SelectionPaintRange(start_layout_object, start_pos.ComputeEditingOffset(),
+                          end_layout_object, end_pos.ComputeEditingOffset()));
 }
 
 void LayoutSelection::OnDocumentShutdown() {
   has_pending_selection_ = false;
-  selection_start_ = nullptr;
-  selection_end_ = nullptr;
-  selection_start_pos_ = -1;
-  selection_end_pos_ = -1;
+  paint_range_ = SelectionPaintRange();
 }
 
 static LayoutRect SelectionRectForLayoutObject(const LayoutObject* object) {
   if (!object->IsRooted())
     return LayoutRect();
 
   if (!object->CanUpdateSelectionOnRootLineBoxes())
     return LayoutRect();
 
   return object->SelectionRectInViewCoordinates();
 }
 
 IntRect LayoutSelection::SelectionBounds() {
   // Now create a single bounding box rect that encloses the whole selection.
   LayoutRect sel_rect;
 
   typedef HashSet<const LayoutBlock*> VisitedContainingBlockSet;
   VisitedContainingBlockSet visited_containing_blocks;
 
   Commit();
-  LayoutObject* os = selection_start_;
-  LayoutObject* stop =
-      LayoutObjectAfterPosition(selection_end_, selection_end_pos_);
+  LayoutObject* os = paint_range_.StartLayoutObject();
+  LayoutObject* stop = LayoutObjectAfterPosition(paint_range_.EndLayoutObject(),
+                                                 paint_range_.EndOffset());
   while (os && os != stop) {

[yosin_UTC9, 2017/05/25 04:29:16]

Note: We can rewrite this while-statement to for-statement as
LayoutSelection::InvalidatePaintForSelection()

for (LayoutObjet* os = paint_range_.StartLayoutObject(); os && os != stop; os =
os->NextInPreOrder()) {
 ...
}

Both functions use same stop condition, range.EndLayoutObject() and step,
NextInPreOrder().
So, we can use range pattern in SelectionPaintRange.
e.g.

class SelectionPaintRange {
  class Iterator 
    : public std::iterator<std::input_iterator_tag, LayoutObject*> {
     ...
     Iterator& operator++() { current_ = current_->NextInPreOrder(); return
*this; }
     bool operator==(const Iterator& other) const { return current_ ==
other.current_; }
     ...
    private:
     LayoutObject* crrent_;
  };
  Iterator begin() const { return Iterator(StartLayoutObject()); }
  Iterator end() const { return Iterator(EndLayoutObject()); }
};

[yoichio, 2017/05/25 08:29:03]

Acknowledged.

[yosin_UTC9, 2017/05/25 09:40:31]

Since introducing iterator is big. We should do in another patch.

-    if ((os->CanBeSelectionLeaf() || os == selection_start_ ||
-         os == selection_end_) &&
+    if ((os->CanBeSelectionLeaf() || os == paint_range_.StartLayoutObject() ||
+         os == paint_range_.EndLayoutObject()) &&
         os->GetSelectionState() != SelectionNone) {
       // Blocks are responsible for painting line gaps and margin gaps. They
       // must be examined as well.
       sel_rect.Unite(SelectionRectForLayoutObject(os));
       const LayoutBlock* cb = os->ContainingBlock();
       while (cb && !cb->IsLayoutView()) {
         sel_rect.Unite(SelectionRectForLayoutObject(cb));
         VisitedContainingBlockSet::AddResult add_result =
             visited_containing_blocks.insert(cb);
         if (!add_result.is_new_entry)
           break;
         cb = cb->ContainingBlock();
       }
     }
 
     os = os->NextInPreOrder();
   }
 
   return PixelSnappedIntRect(sel_rect);
 }
 
 void LayoutSelection::InvalidatePaintForSelection() {
-  LayoutObject* end =
-      LayoutObjectAfterPosition(selection_end_, selection_end_pos_);
-  for (LayoutObject* o = selection_start_; o && o != end;
+  LayoutObject* end = LayoutObjectAfterPosition(paint_range_.EndLayoutObject(),
+                                                paint_range_.EndOffset());
+  for (LayoutObject* o = paint_range_.StartLayoutObject(); o && o != end;
        o = o->NextInPreOrder()) {
-    if (!o->CanBeSelectionLeaf() && o != selection_start_ &&
-        o != selection_end_)
+    if (!o->CanBeSelectionLeaf() && o != paint_range_.StartLayoutObject() &&
+        o != paint_range_.EndLayoutObject())
       continue;
     if (o->GetSelectionState() == SelectionNone)
       continue;
 
     o->SetShouldInvalidateSelection();
   }
 }
 
 DEFINE_TRACE(LayoutSelection) {
   visitor->Trace(frame_selection_);
 }
 
 }  // namespace blink