Improving direction-based selection strategy.

Source/core/editing/GranularityStrategy.h

 // 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.
 
 #ifndef GranularityStrategy_h
 #define GranularityStrategy_h
 
 #include "core/editing/SelectionStrategy.h"
 #include "core/editing/VisibleSelection.h"
 
 namespace blink {
 
 class GranularityStrategy {
 public:
     virtual ~GranularityStrategy();
     virtual SelectionStrategy GetType() const = 0;
     virtual void Clear() = 0;
 
-    // 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&) = 0;
+    // Calculates and returns the new selection based on the updated extent
+    // location in contents-space coordinates.
+    virtual VisibleSelection updateExtent(const IntPoint&, LocalFrame*) = 0;
 
 protected:
     GranularityStrategy();
 };
 
 // Always uses character granularity.
 class CharacterGranularityStrategy final : public GranularityStrategy {
 public:
     CharacterGranularityStrategy();
     ~CharacterGranularityStrategy() final;
 
     // GranularityStrategy:
     SelectionStrategy GetType() const final;
     void Clear() final;
-    VisibleSelection updateExtent(const VisiblePosition& extentPosition, const VisibleSelection&) final;
+    VisibleSelection updateExtent(const IntPoint&, LocalFrame*) final;
 };
 
 // "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".
+// In word granularity, the word is not selected until the extent passes the
+// middle of the word. If the selection is shrunk when there is a distance
+// between the extent and the selection end on extent's side of the base, then
+// this distance is applied to the extent as an offset for the purpose of
+// determining the selection bound. This prevents the selection edge from
+// "jumping" back to extent position when it is shrunk after extending. This
+// offset can be reduced or set to 0 if the extent is moved in the opposite
+// direction.
+//
+// Example:
+// ^ marks base, | marks extent passed in updateExtent, > marks selection end:
+// Lorem ip^sum|> dolor sit amet, consectetur
+//
+// Move extent over the middle of "dolor", granularity should change to word
+// granularity and the selection end should jump to the end of the word.
+// Lorem ip^sum dolo|r> sit amet, consectetur
+//
+// Move extent back one character. Granularity changes to "character". The
+// selection end should move back one character as well. Note an offset between
+// the extent and the selection end.
+// Lorem ip^sum dol|o>r sit amet, consectetur
+//
+// Move extent forward one character. The offset is reduced to 0. Selection end
+// doesn't change.
+// Lorem ip^sum dolo|>r sit amet, consectetur
+//
+// Move forward one character. End moves with extent in character granularity.
+// Lorem ip^sum dolor|> sit amet, consectetur
 class DirectionGranularityStrategy final : public GranularityStrategy {
 public:
     DirectionGranularityStrategy();
     ~DirectionGranularityStrategy() final;
 
     // GranularityStrategy:
     SelectionStrategy GetType() const final;
     void Clear() final;
-    VisibleSelection updateExtent(const VisiblePosition&, const VisibleSelection&) final;
+    VisibleSelection updateExtent(const IntPoint&, LocalFrame*) final;
 
 private:
+    enum class StrategyState {
+        // Starting state.
+        // Selection was cleared and there were no extent updates since then.
+        // One an update is performed, the strategy goes into the Expanding
+        // state unless the upate shrinks the selection without changing
+        // relative base/extent order, in which case the strategy goes into the
+        // Shrinking state.
+        Cleared,
+        // Last time the selection was changed by updateExtent - it was expanded
+        // or the relative base/extent order was changed.
+        Expanding,
+        // Last time the selection was changed by updateExtent - it was shrunk
+        // (without changing relative base/extent order).
+        Shrinking
+    };
     enum class BoundAdjust {CurrentPosIfOnBound, NextBoundIfOnBound};
     enum class SearchDirection {SearchBackwards, SearchForward};
 
+    // Returns true if the two supplied positions are in the order defined by
+    // the int parameter:

[leviw_travelin_and_unemployed, 2015/05/20 22:01:01]

This isn't exactly what I meant.

I'd probably go with something like this:
// Order is specified using the same contract as comparePositions.
bool arePositionsInSpecifiedOrder(const vp&, const vp&, int specifiedOrder)

[mfomitchev, 2015/05/25 23:05:51]

Done.

+    // - For int > 0 returns true if the first position is after the second one.
+    // - For int < 0 returns true if the first position is before the second one.
+    // - For int == 0 returns true if the first position is equal to the second one.
+    bool arePositionsInOrder(const VisiblePosition&, const VisiblePosition&, int);
+
     // 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*/, SearchDirection /*direction*/, BoundAdjust /*nextIfOnBound*/);
 
+    StrategyState m_state;
     // 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;
+    // Coordinates of the previous extent in contents-space.
+    IntPoint m_extentPoint;
+    // Offset applied to the extent.
+    int m_offset;
 };
 
 } // namespace blink
 
 #endif // GranularityStrategy_h