Implementing directional selection strategy in Blink.

Source/core/editing/FrameSelection.cpp

 /*
  * Copyright (C) 2004, 2008, 2009, 2010 Apple 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 75 matching lines @@
 static inline LayoutUnit NoXPosForVerticalArrowNavigation()
 {
     return LayoutUnit::min();
 }
 
 static inline bool shouldAlwaysUseDirectionalSelection(LocalFrame* frame)
 {
     return !frame || frame->editor().behavior().shouldConsiderSelectionAsDirectional();
 }
 
+class GranularityStrategy {

[yosin_UTC9, 2015/04/17 04:24:50]

Is it better to move XXXStrategy to another file? FrameSelection.cpp is big
2100+.

[mfomitchev, 2015/04/17 14:41:49]

It's your call. The upside is reducing the file size making it easier to
navigate inside FrameSelection.cpp. The downside is that we'd need to create
extra files, making it harder to navigate through the editing file set. We'd
also be opening up GranularityStrategy to be used from elsewhere which we don't
necessarily want. If we put it in separate files - would we put all the three
strategy classes in the same .h? Or create three separate .h and three separate
.cpp? Let me know what you prefer.

[yosin_UTC9, 2015/04/20 01:25:55]

We've moved classes to their own files for TextIterator,
http://crrev.com/824913005
In this case, one class, FullyClippedStateStack, isn't used out side of
TextIterator,
but it was also moved. In my experience, this change helps us re-factoring of
TextIterator.
One .cpp and .h are enough at this time.

+public:
+    virtual ~GranularityStrategy() { };
+    virtual SelectionStrategy GetType() const;

[yosin_UTC9, 2015/04/17 04:24:50]

As of link error, we want to put "= 0".

[mfomitchev, 2015/04/17 14:41:49]

Done.

+    virtual void Clear();

[yosin_UTC9, 2015/04/17 04:24:50]

ditto

[mfomitchev, 2015/04/17 14:41:49]

Done.

+
+    // Calculates and returns the new selection based on the updated user selection extent |extentPosition| and the granularity strategy.
+    virtual VisibleSelection updateExtent(const VisiblePosition& extentPosition, const VisibleSelection&);

[yosin_UTC9, 2015/04/17 04:24:50]

ditto

[mfomitchev, 2015/04/17 14:41:49]

Done.

+protected:
+    GranularityStrategy() { };
+};
+
+// Always uses character granularity.
+class CharacterGranularityStrategy : public GranularityStrategy {

[yosin_UTC9, 2015/04/17 04:24:50]

nit: "final"

[mfomitchev, 2015/04/17 14:41:49]

Done.

+public:
+    CharacterGranularityStrategy() { };
+    ~CharacterGranularityStrategy() override { };
+
+    SelectionStrategy GetType() const override { return StrategyCharacter; }
+    void Clear() override { };
+    VisibleSelection updateExtent(const VisiblePosition& extentPosition, const VisibleSelection& selection) override
+    {
+        return VisibleSelection(selection.visibleBase(), extentPosition);
+    };
+};
+
+// "Expand by word, shrink by character" selection strategy.
+// Uses character granularity when selection is shrinking. If the selection is expanding,
+// granularity doesn't change until a word boundary is passed, after which the granularity
+// switches to "word".
+class DirectionGranularityStrategy : public GranularityStrategy {

[yosin_UTC9, 2015/04/17 04:24:50]

nit: final

[mfomitchev, 2015/04/17 14:41:49]

Done.

+public:
+    DirectionGranularityStrategy();
+    ~DirectionGranularityStrategy() override { };
+
+    SelectionStrategy GetType() const override { return StrategyDirection; }
+    void Clear() override;
+    VisibleSelection updateExtent(const VisiblePosition&, const VisibleSelection&) override;
+private:
+    enum EWordBoundAdjust {CurrentPosIfOnBound = false, NextBoundIfOnBound = true};

[yosin_UTC9, 2015/04/17 04:24:51]

nit: we don't need to assign value for enum fields in this case.

[yosin_UTC9, 2015/04/17 04:24:51]

nit: better to use |enum class|.

[mfomitchev, 2015/04/17 14:41:49]

Done.

[mfomitchev, 2015/04/17 14:41:49]

Neat! Thanks for the tip!

+    enum ESearchDirection {SearchBackwards = 0, SearchForward = 1};

[yosin_UTC9, 2015/04/17 04:24:50]

nit: we don't need to assign value for enum fields in this case.

[yosin_UTC9, 2015/04/17 04:24:50]

nit: better to use |enum class|.

[mfomitchev, 2015/04/17 14:41:49]

Done.

[mfomitchev, 2015/04/17 14:41:49]

Done.

+
+    // Returns the next word boundary starting from |pos|. |direction| specifies the direction
+    // in which to search for the next bound. nextIfOnBound controls whether |pos| or the next boundary
+    // is returned when |pos| is located exactly on word boundary.
+    VisiblePosition nextWordBound(const VisiblePosition& /*pos*/, ESearchDirection /*direction*/, EWordBoundAdjust /*nextIfOnBound*/);
+
+    // Current selection granularity being used
+    TextGranularity m_granularity;
+    // Set to true if the selection was shrunk (without changing relative base/extent order)
+    // as a result of the most recent updateExtent call.
+    bool m_lastMoveShrunkSelection;
+};
+
+DirectionGranularityStrategy::DirectionGranularityStrategy()
+    : m_granularity(CharacterGranularity)
+    , m_lastMoveShrunkSelection(false) { }
+
+void DirectionGranularityStrategy::Clear()
+{
+    m_granularity = CharacterGranularity;
+    m_lastMoveShrunkSelection = false;
+}
+
+VisiblePosition DirectionGranularityStrategy::nextWordBound(
+    const VisiblePosition& pos,
+    ESearchDirection direction,
+    EWordBoundAdjust wordBoundAdjust)
+{
+    if (direction == SearchForward)
+        return endOfWord(pos, wordBoundAdjust ==  CurrentPosIfOnBound ? LeftWordIfOnBoundary : RightWordIfOnBoundary);
+    return startOfWord(pos, wordBoundAdjust ==  CurrentPosIfOnBound ? RightWordIfOnBoundary : LeftWordIfOnBoundary);
+}
+
+VisibleSelection DirectionGranularityStrategy::updateExtent(const VisiblePosition& extentPosition, const VisibleSelection& selection)
+{
+    if (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);
+
+    // Determine the boundary of the 'current word', i.e. the boundary extending beyond which
+    // should change the granularity to WordGranularity.
+    // If the last move has shrunk the selection and is now exactly on the word boundary -
+    // we need to take the next bound as the bound of the "current word".
+    VisiblePosition currentWordBoundary = nextWordBound(
+        oldExtentWithGranularity,
+        oldExtentBaseOrder > 0 ? SearchForward : SearchBackwards,
+        m_lastMoveShrunkSelection ? NextBoundIfOnBound : CurrentPosIfOnBound);
+
+    bool thisMoveShrunkSelection = (extentBaseOrder > 0 && comparePositions(extentPosition, selection.visibleExtent()) < 0)
+        || (extentBaseOrder < 0 && comparePositions(extentPosition, selection.visibleExtent()) > 0);
+    // If the extent-base order was switched, then the selection is now expanding in a different
+    // direction than before. Therefore we need to calculate the boundary of the 'current word'
+    // in this new direction in order to be able to tell if the selection expanded beyond it.
+    if (extentBaseOrderSwitched) {
+        currentWordBoundary = nextWordBound(base, extentBaseOrder > 0 ? SearchForward : SearchBackwards, NextBoundIfOnBound);
+        m_granularity = CharacterGranularity;
+        // When the base/extent order switches it doesn't count as shrinking selection.
+        thisMoveShrunkSelection = false;
+    }
+
+    bool expandedBeyondWordBoundary;
+    if (extentBaseOrder > 0)
+        expandedBeyondWordBoundary = comparePositions(extentPosition, currentWordBoundary) > 0;
+    else
+        expandedBeyondWordBoundary = comparePositions(extentPosition, currentWordBoundary) < 0;
+    if (expandedBeyondWordBoundary) {
+        m_granularity = WordGranularity;
+    } else if (thisMoveShrunkSelection) {
+        m_granularity = CharacterGranularity;
+        m_lastMoveShrunkSelection = true;
+    }
+
+    m_lastMoveShrunkSelection = thisMoveShrunkSelection;
+    VisibleSelection newSelection = selection;
+    newSelection.setExtent(extentPosition);
+    if (m_granularity == WordGranularity) {
+        if (extentBaseOrder > 0)
+            newSelection.setEndRespectingGranularity(m_granularity, LeftWordIfOnBoundary);
+        else
+            newSelection.setStartRespectingGranularity(m_granularity, RightWordIfOnBoundary);
+    }
+
+    return newSelection;
+}
+
 FrameSelection::FrameSelection(LocalFrame* frame)
     : m_frame(frame)
     , m_xPosForVerticalArrowNavigation(NoXPosForVerticalArrowNavigation())
     , m_observingVisibleSelection(false)
     , m_granularity(CharacterGranularity)
     , m_caretBlinkTimer(this, &FrameSelection::caretBlinkTimerFired)
     , m_caretRectDirty(true)
     , m_shouldPaintCaret(true)
     , m_isCaretBlinkingSuspended(false)
     , m_focused(frame && frame->page() && frame->page()->focusController().focusedFrame() == frame)
@@ skipping 109 matching lines @@
 
     newSelection.setIsDirectional(isDirectional); // Adjusting base and extent will make newSelection always directional
     if (m_selection == newSelection)
         return;
 
     setSelection(newSelection, granularity);
 }
 
 void FrameSelection::setSelection(const VisibleSelection& newSelection, SetSelectionOptions options, CursorAlignOnScroll align, TextGranularity granularity)
 {
+    if (m_granularityStrategy && (options & FrameSelection::DoNotClearStrategy) == 0) {
+        m_granularityStrategy->Clear();
+    }
     bool closeTyping = options & CloseTyping;
     bool shouldClearTypingStyle = options & ClearTypingStyle;
     EUserTriggered userTriggered = selectionOptionsToUserTriggered(options);
 
     VisibleSelection s = validateSelection(newSelection);
+
     if (shouldAlwaysUseDirectionalSelection(m_frame))
         s.setIsDirectional(true);
 
     if (!m_frame) {
         m_selection = s;
         return;
     }
 
     // <http://bugs.webkit.org/show_bug.cgi?id=23464>: Infinite recursion at FrameSelection::setSelection
     // if document->frame() == m_frame we can get into an infinite loop
@@ skipping 926 matching lines @@
         m_xPosForVerticalArrowNavigation = x;
     } else
         x = m_xPosForVerticalArrowNavigation;
 
     return x;
 }
 
 void FrameSelection::clear()
 {
     m_granularity = CharacterGranularity;
+    if (m_granularityStrategy)
+        m_granularityStrategy->Clear();
     setSelection(VisibleSelection());
 }
 
 void FrameSelection::prepareForDestruction()
 {
     m_granularity = CharacterGranularity;
 
     m_caretBlinkTimer.stop();
 
     LayoutView* view = m_frame->contentRenderer();
@@ skipping 720 matching lines @@
         String text = plainText(start.deepEquivalent(), end.deepEquivalent());
         if (!text.isEmpty() && !isSeparator(text.characterStartingAt(0))) {
             setSelection(VisibleSelection(start, end), WordGranularity);
             return true;
         }
     }
 
     return false;
 }
 
-void FrameSelection::moveRangeSelectionExtent(const VisiblePosition& extentPosition, TextGranularity granularity)
+GranularityStrategy* FrameSelection::granularityStrategy()
 {
-    if (isNone())
+    // We do lazy initalization for m_granularityStrategy, because if we initialize it
+    // right in the constructor - the correct settings may not be set yet.
+    SelectionStrategy strategyType = StrategyCharacter;
+    Settings* settings = m_frame ? m_frame->settings() : 0;
+    if (settings && settings->selectionStrategy() == StrategyDirection)
+        strategyType = StrategyDirection;
+
+    if (m_granularityStrategy && m_granularityStrategy->GetType() == strategyType)
+        return m_granularityStrategy.get();
+
+    if (strategyType == StrategyDirection)
+        m_granularityStrategy = adoptPtr(new DirectionGranularityStrategy());
+    else
+        m_granularityStrategy = adoptPtr(new CharacterGranularityStrategy());
+    return m_granularityStrategy.get();
+}
+
+void FrameSelection::moveRangeSelectionExtent(const VisiblePosition& extentPosition)
+{
+    const VisiblePosition base = m_selection.visibleBase();
+
+    if (isNone() || base == extentPosition)
         return;
 
-    const VisiblePosition basePosition = m_selection.isBaseFirst() ? m_selection.visibleStart() : m_selection.visibleEnd();
-    VisibleSelection newSelection(basePosition, extentPosition);
-    if (newSelection.isBaseFirst())
-        newSelection.setEndRespectingGranularity(granularity);
-    else
-        newSelection.setStartRespectingGranularity(granularity);
-    if (!newSelection.isRange())
-        return;
-
-    setSelection(newSelection, FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle | UserTriggered, FrameSelection::AlignCursorOnScrollIfNeeded, granularity);
+    VisibleSelection newSelection = granularityStrategy()->updateExtent(extentPosition, selection());
+    setSelection(
+        newSelection,
+        FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle | FrameSelection::DoNotClearStrategy | UserTriggered,
+        FrameSelection::AlignCursorOnScrollIfNeeded,
+        CharacterGranularity);
 }
 
 void FrameSelection::moveRangeSelection(const VisiblePosition& basePosition, const VisiblePosition& extentPosition, TextGranularity granularity)
 {
     VisibleSelection newSelection(basePosition, extentPosition);
     newSelection.expandUsingGranularity(granularity);
 
     if (newSelection.isNone())
         return;
 
     setSelection(newSelection, granularity);
 }
 
 }
 
 #ifndef NDEBUG
 
 void showTree(const blink::FrameSelection& sel)
 {
     sel.showTreeForThis();
 }
 
 void showTree(const blink::FrameSelection* sel)
 {
     if (sel)
         sel->showTreeForThis();
 }
 
 #endif