Enable selection for the composed tree

Source/core/editing/VisibleSelection.h

 /*
  * Copyright (C) 2004 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 35 matching lines @@
 public:
     class InDOMTree {
     public:
         using PositionType = Position;
 
         static bool equalSelections(const VisibleSelection&, const VisibleSelection&);
         static PositionType selectionBase(const VisibleSelection& selection) { return selection.base(); }
         static PositionType selectionExtent(const VisibleSelection& selection) { return selection.extent(); }
         static PositionType selectionStart(const VisibleSelection& selection) { return selection.start(); }
         static PositionType selectionEnd(const VisibleSelection& selection) { return selection.end(); }
+        static SelectionType selectionType(const VisibleSelection& selection) { return selection.selectionType(); }
         static VisiblePosition selectionVisibleStart(const VisibleSelection& selection) { return selection.visibleStart(); }
         static VisiblePosition selectionVisibleEnd(const VisibleSelection& selection) { return selection.visibleEnd(); }
         static PositionType toPositionType(const Position& position) { return position; }
     };
 
     class InComposedTree {
     public:
         using PositionType = PositionInComposedTree;
 
+        static bool equalSelections(const VisibleSelection&, const VisibleSelection&);
+        static bool isRange(const VisibleSelection& selection) { return selectionType(selection) == RangeSelection; }
         static PositionType selectionBase(const VisibleSelection& selection) { return selection.baseInComposedTree(); }
         static PositionType selectionExtent(const VisibleSelection& selection) { return selection.extentInComposedTree(); }
         static PositionType selectionStart(const VisibleSelection& selection) { return selection.startInComposedTree(); }
         static PositionType selectionEnd(const VisibleSelection& selection) { return selection.endInComposedTree(); }
+        static SelectionType selectionType(const VisibleSelection& selection) { return selection.selectionTypeInComposedTree(); }
+        static VisiblePosition selectionVisibleStart(const VisibleSelection& selection)
+        {
+            return VisiblePosition(selectionStart(selection), isRange(selection) ? DOWNSTREAM : selection.affinity());
+        }
+        static VisiblePosition selectionVisibleEnd(const VisibleSelection& selection)
+        {
+            return VisiblePosition(selectionEnd(selection), isRange(selection) ? UPSTREAM : selection.affinity());
+        }
+        static PositionType toPositionType(const Position& position) { return toPositionInComposedTree(position); }
     };
 
     VisibleSelection();
 
     VisibleSelection(const Position&, EAffinity, bool isDirectional = false);
     VisibleSelection(const Position& base, const Position& extent, EAffinity = SEL_DEFAULT_AFFINITY, bool isDirectional = false);
     VisibleSelection(const PositionInComposedTree& base, const PositionInComposedTree& extent, EAffinity = SEL_DEFAULT_AFFINITY, bool isDirectional = false);
 
     explicit VisibleSelection(const Range*, EAffinity = SEL_DEFAULT_AFFINITY, bool isDirectional = false);
 
     explicit VisibleSelection(const VisiblePosition&, bool isDirectional = false);
     VisibleSelection(const VisiblePosition&, const VisiblePosition&, bool isDirectional = false);
 
     VisibleSelection(const VisibleSelection&);
     VisibleSelection& operator=(const VisibleSelection&);
 
     static VisibleSelection selectionFromContentsOfNode(Node*);
 
     SelectionType selectionType() const { return m_selectionType; }
+    SelectionType selectionTypeInComposedTree() const;
 
     void setAffinity(EAffinity affinity) { m_affinity = affinity; }
     EAffinity affinity() const { return m_affinity; }
 
     void setBase(const Position&);
     void setBase(const PositionInComposedTree&);
     void setBase(const VisiblePosition&);
     void setExtent(const Position&);
     void setExtent(const PositionInComposedTree&);
     void setExtent(const VisiblePosition&);
@@ skipping 12 matching lines @@
     VisiblePosition visibleBase() const { return VisiblePosition(m_base, isRange() ? (isBaseFirst() ? UPSTREAM : DOWNSTREAM) : affinity()); }
     VisiblePosition visibleExtent() const { return VisiblePosition(m_extent, isRange() ? (isBaseFirst() ? DOWNSTREAM : UPSTREAM) : affinity()); }
 
     bool isNone() const { return selectionType() == NoSelection; }
     bool isCaret() const { return selectionType() == CaretSelection; }
     bool isRange() const { return selectionType() == RangeSelection; }
     bool isCaretOrRange() const { return selectionType() != NoSelection; }
     bool isNonOrphanedRange() const { return isRange() && !start().isOrphan() && !end().isOrphan(); }
     bool isNonOrphanedCaretOrRange() const { return isCaretOrRange() && !start().isOrphan() && !end().isOrphan(); }
     static SelectionType selectionType(const Position& start, const Position& end);
+    static SelectionType selectionType(const PositionInComposedTree& start, const PositionInComposedTree& end);
 
     bool isBaseFirst() const { return m_baseIsFirst; }
     bool isDirectional() const { return m_isDirectional; }
     void setIsDirectional(bool isDirectional) { m_isDirectional = isDirectional; }
 
     void appendTrailingWhitespace();
 
     bool expandUsingGranularity(TextGranularity granularity);
+    bool expandUsingGranularityInComposedTree(TextGranularity);
 
     // We don't yet support multi-range selections, so we only ever have one range to return.
     PassRefPtrWillBeRawPtr<Range> firstRange() const;
 
     bool intersectsNode(Node*) const;
 
     // FIXME: Most callers probably don't want these functions, but
     // are using them for historical reasons. toNormalizedRange and
     // toNormalizedPositions contracts the range around text, and
     // moves the caret upstream before returning the range/positions.
     PassRefPtrWillBeRawPtr<Range> toNormalizedRange() const;
     bool toNormalizedPositions(Position& start, Position& end) const;
     static void normalizePositions(const Position& start, const Position& end, Position* normalizedStart, Position* normalizedEnd);
     static void normalizePositions(const PositionInComposedTree& start, const PositionInComposedTree& end, PositionInComposedTree* outStart, PositionInComposedTree* outEnd);
 
     Element* rootEditableElement() const;
     bool isContentEditable() const;
     bool hasEditableStyle() const;
     bool isContentRichlyEditable() const;
     // Returns a shadow tree node for legacy shadow trees, a child of the
     // ShadowRoot node for new shadow trees, or 0 for non-shadow trees.
     Node* nonBoundaryShadowTreeRootNode() const;
 
     VisiblePosition visiblePositionRespectingEditingBoundary(const LayoutPoint& localPoint, Node* targetNode) const;
     PositionWithAffinity positionRespectingEditingBoundary(const LayoutPoint& localPoint, Node* targetNode) const;
 
     void setWithoutValidation(const Position&, const Position&);
+    void setWithoutValidation(const PositionInComposedTree&, const PositionInComposedTree&);
 
     // Listener of VisibleSelection modification. didChangeVisibleSelection() will be invoked when base, extent, start
     // or end is moved to a different position.
     //
     // Objects implementing |ChangeObserver| interface must outlive the VisibleSelection object.
     class CORE_EXPORT ChangeObserver : public WillBeGarbageCollectedMixin {
         WTF_MAKE_NONCOPYABLE(ChangeObserver);
     public:
         ChangeObserver();
         virtual ~ChangeObserver();
@@ skipping 83 matching lines @@
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showTree(const blink::VisibleSelection&);
 void showTree(const blink::VisibleSelection*);
 #endif
 
 #endif // VisibleSelection_h