Introduce SelectionAdjuster to adjust selections between DOM tree version and composed tree version

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

 /*
  * Copyright (C) 2004, 2005, 2006 Apple Computer, 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 93 matching lines @@
     // |mostBackwardCaretPosition()|. However, we are here during
     // |Node::removeChild()|.
     start.anchorNode()->updateDistribution();
     end.anchorNode()->updateDistribution();
     if (mostBackwardCaretPosition(start) == mostBackwardCaretPosition(end))
         return CaretSelection;
     return RangeSelection;
 }
 
 template <typename Strategy>
-VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate(
-    const PositionTemplate<Strategy>& base,
-    const PositionTemplate<Strategy>& extent,
-    const PositionTemplate<Strategy>& start,
-    const PositionTemplate<Strategy>& end,
-    TextAffinity affinity,
-    bool isDirectional)
-    : m_base(base)
-    , m_extent(extent)
-    , m_start(start)
-    , m_end(end)
-    , m_affinity(affinity)
-    , m_changeObserver(nullptr) // Observer is associated with only one VisibleSelection, so this should not be copied.
-    , m_selectionType(computeSelectionType(start, end))
-    , m_baseIsFirst(base.isNull() || base.compareTo(extent) <= 0)
-    , m_isDirectional(isDirectional)
-{
-    ASSERT(base.isNull() == extent.isNull());
-    ASSERT(base.isNull() == start.isNull());
-    ASSERT(base.isNull() == end.isNull());
-    ASSERT(start.isNull() || start.compareTo(end) <= 0);
-}
-
-template <typename Strategy>
 VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate(const VisibleSelectionTemplate<Strategy>& other)
     : m_base(other.m_base)
     , m_extent(other.m_extent)
     , m_start(other.m_start)
     , m_end(other.m_end)
     , m_affinity(other.m_affinity)
     , m_changeObserver(nullptr) // Observer is associated with only one VisibleSelection, so this should not be copied.
     , m_selectionType(other.m_selectionType)
     , m_baseIsFirst(other.m_baseIsFirst)
     , m_isDirectional(other.m_isDirectional)
@@ skipping 10 matching lines @@
     m_start = other.m_start;
     m_end = other.m_end;
     m_affinity = other.m_affinity;
     m_changeObserver = nullptr;
     m_selectionType = other.m_selectionType;
     m_baseIsFirst = other.m_baseIsFirst;
     m_isDirectional = other.m_isDirectional;
     return *this;
 }
 
-template <typename Strategy>
-VisibleSelectionTemplate<Strategy> VisibleSelectionTemplate<Strategy>::createWithoutValidation(const PositionTemplate<Strategy>& base, const PositionTemplate<Strategy>& extent, const PositionTemplate<Strategy>& start, const PositionTemplate<Strategy>& end, TextAffinity affinity, bool isDirectional)
-{
-    return VisibleSelectionTemplate<Strategy>(base, extent, start, end, affinity, isDirectional);
-}
-
 #if !ENABLE(OILPAN)
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy>::~VisibleSelectionTemplate()
 {
     didChange();
 }
 #endif
 
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy> VisibleSelectionTemplate<Strategy>::selectionFromContentsOfNode(Node* node)
@@ skipping 552 matching lines @@
             return positionBeforeNode(ancestor);
         return positionAfterNode(ancestor);
     }
 
     if (Node* firstChild = treeScope.rootNode().firstChild())
         return positionBeforeNode(firstChild);
 
     return Position();
 }
 
-static VisibleSelection computeSelectionToAvoidCrossingShadowBoundaries(const VisibleSelection& selection)
+// TODO(yosin): We should move
+// |SelectionAdjuster::adjustSelectionToAvoidCrossingShadowBoundaries()| to
+// "SelectionAdjuster.cpp"
+void SelectionAdjuster::adjustSelectionToAvoidCrossingShadowBoundaries(VisibleSelection* selection)
 {
     // Note: |m_selectionType| isn't computed yet.
-    ASSERT(selection.base().isNotNull());
-    ASSERT(selection.extent().isNotNull());
-    ASSERT(selection.start().isNotNull());
-    ASSERT(selection.end().isNotNull());
+    ASSERT(selection->base().isNotNull());
+    ASSERT(selection->extent().isNotNull());
+    ASSERT(selection->start().isNotNull());
+    ASSERT(selection->end().isNotNull());
 
     // TODO(hajimehoshi): Checking treeScope is wrong when a node is
     // distributed, but we leave it as it is for backward compatibility.
-    if (selection.start().anchorNode()->treeScope() == selection.end().anchorNode()->treeScope())
-        return selection;
+    if (selection->start().anchorNode()->treeScope() == selection->end().anchorNode()->treeScope())
+        return;
 
-    if (selection.isBaseFirst()) {
-        const Position newEnd = adjustPositionForEnd(selection.end(), selection.start().computeContainerNode());
-        return VisibleSelection::createWithoutValidation(selection.base(), newEnd, selection.start(), newEnd, selection.affinity(), selection.isDirectional());
+    if (selection->isBaseFirst()) {
+        const Position& newEnd = adjustPositionForEnd(selection->end(), selection->start().computeContainerNode());
+        selection->m_extent = newEnd;
+        selection->m_end = newEnd;
+        return;
     }
 
-    const Position newStart = adjustPositionForStart(selection.start(), selection.end().computeContainerNode());
-    return VisibleSelection::createWithoutValidation(selection.base(), newStart, newStart, selection.end(), selection.affinity(), selection.isDirectional());
+    const Position& newStart = adjustPositionForStart(selection->start(), selection->end().computeContainerNode());
+    selection->m_extent = newStart;
+    selection->m_start = newStart;
 }
 
+// TODO(yosin): We should move
+// |SelectionAdjuster::adjustSelectionToAvoidCrossingShadowBoundaries()| to
+// "SelectionAdjuster.cpp"
 // This function is called twice. The first is called when |m_start| and |m_end|
 // or |m_extent| are same, and the second when |m_start| and |m_end| are changed
 // after downstream/upstream.
-static VisibleSelectionInComposedTree computeSelectionToAvoidCrossingShadowBoundaries(const VisibleSelectionInComposedTree& selection)
+void SelectionAdjuster::adjustSelectionToAvoidCrossingShadowBoundaries(VisibleSelectionInComposedTree* selection)
 {
-    Node* shadowHostStart = enclosingShadowHostForStart(selection.start());
-    Node* shadowHostEnd = enclosingShadowHostForEnd(selection.end());
+    Node* const shadowHostStart = enclosingShadowHostForStart(selection->start());
+    Node* const shadowHostEnd = enclosingShadowHostForEnd(selection->end());
     if (shadowHostStart == shadowHostEnd)
-        return selection;
+        return;
 
-    if (selection.isBaseFirst()) {
-        Node* shadowHost = shadowHostStart ? shadowHostStart : shadowHostEnd;
-        const PositionInComposedTree newEnd = adjustPositionInComposedTreeForEnd(selection.end(), shadowHost);
-        return VisibleSelectionInComposedTree::createWithoutValidation(selection.base(), newEnd, selection.start(), newEnd, selection.affinity(), selection.isDirectional());
+    if (selection->isBaseFirst()) {
+        Node* const shadowHost = shadowHostStart ? shadowHostStart : shadowHostEnd;
+        const PositionInComposedTree& newEnd = adjustPositionInComposedTreeForEnd(selection->end(), shadowHost);
+        selection->m_extent = newEnd;
+        selection->m_end = newEnd;
+        return;
     }
-    Node* shadowHost = shadowHostEnd ? shadowHostEnd : shadowHostStart;
-    const PositionInComposedTree newStart = adjustPositionInComposedTreeForStart(selection.start(), shadowHost);
-    return VisibleSelectionInComposedTree::createWithoutValidation(selection.base(), newStart, newStart, selection.end(), selection.affinity(), selection.isDirectional());
+    Node* const shadowHost = shadowHostEnd ? shadowHostEnd : shadowHostStart;
+    const PositionInComposedTree& newStart = adjustPositionInComposedTreeForStart(selection->start(), shadowHost);
+    selection->m_extent = newStart;
+    selection->m_start = newStart;
 }
 
 template <typename Strategy>
 void VisibleSelectionTemplate<Strategy>::adjustSelectionToAvoidCrossingShadowBoundaries()
 {
     if (m_base.isNull() || m_start.isNull() || m_base.isNull())
         return;
-    *this = computeSelectionToAvoidCrossingShadowBoundaries(*this);
+    SelectionAdjuster::adjustSelectionToAvoidCrossingShadowBoundaries(this);
 }
 
 static Element* lowestEditableAncestor(Node* node)
 {
     while (node) {
         if (node->hasEditableStyle())
             return node->rootEditableElement();
         if (isHTMLBodyElement(*node))
             break;
         node = node->parentNode();
@@ skipping 343 matching lines @@
 {
     sel.showTreeForThis();
 }
 
 void showTree(const blink::VisibleSelectionInComposedTree* sel)
 {
     if (sel)
         sel->showTreeForThis();
 }
 #endif