Improving direction-based selection strategy.

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 "config.h"
 #include "core/editing/GranularityStrategy.h"
 
+#include "core/editing/FrameSelection.h"
 #include "core/editing/htmlediting.h"
+#include "core/layout/HitTestRequest.h"
+#include "core/layout/HitTestResult.h"
+#include "core/layout/LayoutView.h"
+#include "core/paint/DeprecatedPaintLayer.h"
+
 
 namespace blink {
+namespace {
+
+VisiblePosition visiblePositionForFramePoint(const IntPoint& framePoint, LocalFrame* frame)
+{
+    HitTestRequest request = HitTestRequest::Move | HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::IgnoreClipping;
+    HitTestResult result(request, framePoint);
+    frame->document()->layoutView()->layer()->hitTest(result);
+
+    if (Node* node = result.innerNode())
+        return frame->selection().selection().visiblePositionRespectingEditingBoundary(result.localPoint(), node);
+    return VisiblePosition();
+}
+}
 
 GranularityStrategy::GranularityStrategy() { }
 
 GranularityStrategy::~GranularityStrategy() { }
 
 CharacterGranularityStrategy::CharacterGranularityStrategy() { }
 
 CharacterGranularityStrategy::~CharacterGranularityStrategy() { }
 
 SelectionStrategy CharacterGranularityStrategy::GetType() const
 {
     return SelectionStrategy::Character;
 }
 
 void CharacterGranularityStrategy::Clear() { };
 
-VisibleSelection CharacterGranularityStrategy::updateExtent(const VisiblePosition& extentPosition, const VisibleSelection& selection)
+VisibleSelection CharacterGranularityStrategy::updateExtent(const IntPoint& framePoint, LocalFrame* frame)
 {
+    const VisiblePosition& extentPosition = visiblePositionForFramePoint(framePoint, frame);
+    const VisibleSelection& selection = frame->selection().selection();
+    if (selection.visibleBase() == extentPosition)
+        return selection;
     return VisibleSelection(selection.visibleBase(), extentPosition);
 }
 
 DirectionGranularityStrategy::DirectionGranularityStrategy()
     : m_granularity(CharacterGranularity)
-    , m_lastMoveShrunkSelection(false) { }
+    , m_lastMoveShrunkSelection(false)
+    , m_offset(0) { }
 
 DirectionGranularityStrategy::~DirectionGranularityStrategy() { }
 
 SelectionStrategy DirectionGranularityStrategy::GetType() const
 {
     return SelectionStrategy::Direction;
 }
 
 void DirectionGranularityStrategy::Clear()
 {
     m_granularity = CharacterGranularity;
     m_lastMoveShrunkSelection = false;
+    m_offset = 0;
 }
 
 VisiblePosition DirectionGranularityStrategy::nextWordBound(
     const VisiblePosition& pos,
     SearchDirection direction,
     BoundAdjust wordBoundAdjust)
 {
     bool nextBoundIfOnBound = wordBoundAdjust ==  BoundAdjust::NextBoundIfOnBound;
     if (direction == SearchDirection::SearchForward) {
         EWordSide wordSide = nextBoundIfOnBound ? RightWordIfOnBoundary : LeftWordIfOnBoundary;
         return endOfWord(pos, wordSide);
     }
     EWordSide wordSide = nextBoundIfOnBound ? LeftWordIfOnBoundary : RightWordIfOnBoundary;
     return startOfWord(pos, wordSide);
 }
 
-VisibleSelection DirectionGranularityStrategy::updateExtent(const VisiblePosition& extentPosition, const VisibleSelection& selection)
+VisibleSelection DirectionGranularityStrategy::updateExtent(const IntPoint& extentPoint, LocalFrame* frame)
 {
-    if (extentPosition == selection.visibleExtent())
+    // Apply the offset if needed
+    IntPoint offsetExtentPoint = extentPoint;
+    if (m_offset != 0) {
+        int dx = extentPoint.x() - m_extentPoint.x();
+        if (m_offset > 0 && dx > 0)
+            m_offset = std::max(0, m_offset - dx);
+        else if (m_offset < 0 && dx < 0)
+            m_offset = std::min(0, m_offset - dx);
+        offsetExtentPoint.move(m_offset, 0);
+    }
+    m_extentPoint = extentPoint;
+
+    VisiblePosition extentPosition = visiblePositionForFramePoint(offsetExtentPoint, frame);
+    const VisibleSelection& selection = frame->selection().selection();
+
+    if (selection.visibleBase() == extentPosition || extentPosition == selection.visibleExtent())
         return selection;
 
     const VisiblePosition base = selection.visibleBase();
     const VisiblePosition oldExtentWithGranularity = selection.isBaseFirst() ? selection.visibleEnd() : selection.visibleStart();
 
     int extentBaseOrder = comparePositions(extentPosition, base);
     int oldExtentBaseOrder = comparePositions(oldExtentWithGranularity, base);
 
     bool extentBaseOrderSwitched = (extentBaseOrder > 0 && oldExtentBaseOrder < 0)
         || (extentBaseOrder < 0 && oldExtentBaseOrder > 0);
@@ skipping 25 matching lines @@
     }
 
     bool expandedBeyondWordBoundary;
     if (extentBaseOrder > 0)
         expandedBeyondWordBoundary = comparePositions(extentPosition, currentWordBoundary) > 0;
     else
         expandedBeyondWordBoundary = comparePositions(extentPosition, currentWordBoundary) < 0;
     if (expandedBeyondWordBoundary) {
         m_granularity = WordGranularity;
     } else if (thisMoveShrunkSelection) {
+        // If the offset is 0, we may need to update it and apply the offset to the extent.
+        if (m_offset == 0) {
+            if (extentBaseOrder > 0) {
+                if (selection.end() != selection.extent())
+                    m_offset = selection.visibleEnd().absoluteCaretBounds().x() - selection.visibleExtent().absoluteCaretBounds().x();
+            } else {
+                if (selection.start() != selection.extent())
+                    m_offset = selection.visibleStart().absoluteCaretBounds().x() - selection.visibleExtent().absoluteCaretBounds().x();
+            }
+            if (m_offset != 0) {
+                offsetExtentPoint.move(m_offset, 0);
+                extentPosition = visiblePositionForFramePoint(offsetExtentPoint, frame);
+            }
+        }
         m_granularity = CharacterGranularity;
         m_lastMoveShrunkSelection = true;
     }
 
     m_lastMoveShrunkSelection = thisMoveShrunkSelection;
     VisibleSelection newSelection = selection;
-    newSelection.setExtent(extentPosition);
-    if (m_granularity == WordGranularity) {
-        if (extentBaseOrder > 0)
+
+    if (m_granularity == CharacterGranularity) {
+        newSelection.setExtent(extentPosition);
+    } else {
+        // Need to adjust extent by one position for the purposes of setting the
+        // selection if the length of the current word is greater than 3.
+        // This is so that the selection only expands to the end of the word when
+        // the extent moves beyond the first character for words that are more
+        // than 3 characters long.
+        bool adjustExtent = false;
+        Position boundBeforeExtent = nextWordBound(extentPosition, SearchDirection::SearchBackwards, BoundAdjust::CurrentPosIfOnBound).deepEquivalent();
+        if (boundBeforeExtent != extentPosition.deepEquivalent()) {
+            Position boundAfterExtent = nextWordBound(extentPosition, SearchDirection::SearchForward, BoundAdjust::CurrentPosIfOnBound).deepEquivalent();
+            int wordLength = boundAfterExtent.offsetInContainerNode() - boundBeforeExtent.offsetInContainerNode();
+            adjustExtent = wordLength > 3;
+        }
+
+        if (extentBaseOrder > 0) {
+            newSelection.setExtent(adjustExtent ? extentPosition.previous() : extentPosition);
             newSelection.setEndRespectingGranularity(m_granularity, LeftWordIfOnBoundary);
-        else
+        } else {
+            newSelection.setExtent(adjustExtent ? extentPosition.next() : extentPosition);
             newSelection.setStartRespectingGranularity(m_granularity, RightWordIfOnBoundary);
+        }
+        newSelection.setWithoutValidation(newSelection.base(), extentPosition.deepEquivalent(), newSelection.start(), newSelection.end());

[mfomitchev, 2015/05/01 23:31:51]

Note we actually only need to set the extent without changing start/end/base, so
a less general method to do that directly would also work if that's preferable.

     }
 
     return newSelection;
 }
 
 } // namespace blink