Make GranularityStrategy::updateExtent() to return SelectionInDOM instead of VisibleSelection

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/editing/GranularityStrategy.h"
 
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/FrameSelection.h"
 
 namespace blink {
@@ skipping 44 matching lines @@
 CharacterGranularityStrategy::CharacterGranularityStrategy() {}
 
 CharacterGranularityStrategy::~CharacterGranularityStrategy() {}
 
 SelectionStrategy CharacterGranularityStrategy::GetType() const {
   return SelectionStrategy::Character;
 }
 
 void CharacterGranularityStrategy::Clear() {}
 
-VisibleSelection CharacterGranularityStrategy::updateExtent(
+SelectionInDOMTree CharacterGranularityStrategy::updateExtent(
     const IntPoint& extentPoint,
     LocalFrame* frame) {
   const VisiblePosition& extentPosition =
       visiblePositionForContentsPoint(extentPoint, frame);
   const VisibleSelection& selection =
       frame->selection().computeVisibleSelectionInDOMTreeDeprecated();
   if (selection.visibleBase().deepEquivalent() ==
       extentPosition.deepEquivalent())
-    return selection;
-  return createVisibleSelection(SelectionInDOMTree::Builder()
-                                    .collapse(selection.base())
-                                    .extend(extentPosition.deepEquivalent())
-                                    .setAffinity(selection.affinity())
-                                    .build());
+    return selection.asSelection();
+  return SelectionInDOMTree::Builder()
+      .collapse(selection.base())
+      .extend(extentPosition.deepEquivalent())
+      .setAffinity(selection.affinity())
+      .build();
 }
 
 DirectionGranularityStrategy::DirectionGranularityStrategy()
     : m_state(StrategyState::Cleared),
       m_granularity(CharacterGranularity),
       m_offset(0) {}
 
 DirectionGranularityStrategy::~DirectionGranularityStrategy() {}
 
 SelectionStrategy DirectionGranularityStrategy::GetType() const {
   return SelectionStrategy::Direction;
 }
 
 void DirectionGranularityStrategy::Clear() {
   m_state = StrategyState::Cleared;
   m_granularity = CharacterGranularity;
   m_offset = 0;
   m_diffExtentPointFromExtentPosition = IntSize();
 }
 
-VisibleSelection DirectionGranularityStrategy::updateExtent(
+SelectionInDOMTree DirectionGranularityStrategy::updateExtent(
     const IntPoint& extentPoint,
     LocalFrame* frame) {
   const VisibleSelection& selection =
       frame->selection().computeVisibleSelectionInDOMTreeDeprecated();
 
   if (m_state == StrategyState::Cleared)
     m_state = StrategyState::Expanding;
 
   VisiblePosition oldOffsetExtentPosition = selection.visibleExtent();
   IntPoint oldExtentLocation = positionLocation(oldOffsetExtentPosition);
@@ skipping 26 matching lines @@
     m_granularity = CharacterGranularity;
     newOffsetExtentPoint = extentPoint;
     newOffsetExtentPosition =
         visiblePositionForContentsPoint(extentPoint, frame);
   }
 
   const VisiblePosition base = selection.visibleBase();
 
   // Do not allow empty selection.
   if (newOffsetExtentPosition.deepEquivalent() == base.deepEquivalent())
-    return selection;
+    return selection.asSelection();
 
   // The direction granularity strategy, particularly the "offset" feature
   // doesn't work with non-horizontal text (e.g. when the text is rotated).
   // So revert to the behavior equivalent to the character granularity
   // strategy if we detect that the text's baseline coordinate changed
   // without a line change.
   if (verticalChange &&
       inSameLine(newOffsetExtentPosition, oldOffsetExtentPosition)) {
-    return createVisibleSelection(
-        SelectionInDOMTree::Builder()
-            .collapse(selection.base())
-            .extend(newOffsetExtentPosition.deepEquivalent())
-            .setAffinity(selection.affinity())
-            .build());
+    return SelectionInDOMTree::Builder()
+        .collapse(selection.base())
+        .extend(newOffsetExtentPosition.deepEquivalent())
+        .setAffinity(selection.affinity())
+        .build();
   }
 
   int oldExtentBaseOrder = selection.isBaseFirst() ? 1 : -1;
 
   int newExtentBaseOrder;
   bool thisMoveShrunkSelection;
   if (newOffsetExtentPosition.deepEquivalent() ==
       oldOffsetExtentPosition.deepEquivalent()) {
     if (m_granularity == CharacterGranularity)
-      return selection;
+      return selection.asSelection();
 
     // If we are in Word granularity, we cannot exit here, since we may pass
     // the middle of the word without changing the position (in which case
     // the selection needs to expand).
     thisMoveShrunkSelection = false;
     newExtentBaseOrder = oldExtentBaseOrder;
   } else {
     bool selectionExpanded = arePositionsInSpecifiedOrder(
         newOffsetExtentPosition, oldOffsetExtentPosition, oldExtentBaseOrder);
     bool extentBaseOrderSwitched =
@@ skipping 81 matching lines @@
 
   // Only update the state if the selection actually changed as a result of
   // this move.
   if (newSelectionExtent.deepEquivalent() !=
       selection.visibleExtent().deepEquivalent())
     m_state = thisMoveShrunkSelection ? StrategyState::Shrinking
                                       : StrategyState::Expanding;
 
   m_diffExtentPointFromExtentPosition =
       extentPoint + IntSize(m_offset, 0) - positionLocation(newSelectionExtent);
-  return createVisibleSelection(
-      SelectionInDOMTree::Builder(selection.asSelection())
-          .collapse(selection.base())
-          .extend(newSelectionExtent.deepEquivalent())
-          .build());
+  return SelectionInDOMTree::Builder(selection.asSelection())
+      .collapse(selection.base())
+      .extend(newSelectionExtent.deepEquivalent())
+      .build();
 }
 
 }  // namespace blink