Enable selection for the composed tree

Source/core/editing/VisibleSelection.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 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 141 matching lines @@
     didChange();
 }
 #endif
 
 VisibleSelection VisibleSelection::selectionFromContentsOfNode(Node* node)
 {
     ASSERT(!editingIgnoresContent(node));
     return VisibleSelection(firstPositionInNode(node), lastPositionInNode(node), DOWNSTREAM);
 }
 
+SelectionType VisibleSelection::selectionTypeInComposedTree() const
+{
+    return selectionType(m_startInComposedTree, m_endInComposedTree);
+}
+
 void VisibleSelection::setBase(const Position& position)
 {
     Position oldBase = m_base;
     m_base = position;
     validate();
     if (m_base != oldBase)
         didChange();
 }
 
 void VisibleSelection::setBase(const PositionInComposedTree& position)
@@ skipping 170 matching lines @@
     Position oldBase = m_base;
     Position oldExtent = m_extent;
     Position oldStart = m_start;
     Position oldEnd = m_end;
     validate(granularity);
     if (m_base != oldBase || m_extent != oldExtent || m_start != oldStart || m_end != oldEnd)
         didChange();
     return true;
 }
 
+bool VisibleSelection::expandUsingGranularityInComposedTree(TextGranularity granularity)
+{
+    m_base = toPositionInDOMTree(baseInComposedTree());
+    m_extent = toPositionInDOMTree(extentInComposedTree());
+    return expandUsingGranularity(granularity);
+}
+
 static PassRefPtrWillBeRawPtr<Range> makeSearchRange(const Position& pos)
 {
     Node* node = pos.deprecatedNode();
     if (!node)
         return nullptr;
     Document& document = node->document();
     if (!document.documentElement())
         return nullptr;
     Element* boundary = enclosingBlockFlowElement(*node);
     if (!boundary)
@@ skipping 230 matching lines @@
 {
     if (start.isNull()) {
         ASSERT(end.isNull());
         return NoSelection;
     }
     if (start == end || start.upstream() == end.upstream())
         return CaretSelection;
     return RangeSelection;
 }
 
+SelectionType VisibleSelection::selectionType(const PositionInComposedTree& start, const PositionInComposedTree& end)
+{
+    if (start.isNull()) {
+        ASSERT(end.isNull());
+        return NoSelection;
+    }
+    if (start == end || start.upstream() == end.upstream())
+        return CaretSelection;
+    return RangeSelection;
+}
+
 void VisibleSelection::updateSelectionType()
 {
     m_selectionType = selectionType(m_start, m_end);
 
     // Affinity only makes sense for a caret
     if (m_selectionType != CaretSelection)
         m_affinity = DOWNSTREAM;
 }
 
 static Node* enclosingShadowHost(Node* node)
@@ skipping 154 matching lines @@
     } else {
         m_start = extent;
         m_end = base;
     }
     m_selectionType = base == extent ? CaretSelection : RangeSelection;
     m_startInComposedTree = toPositionInComposedTree(m_start);
     m_endInComposedTree = toPositionInComposedTree(m_end);
     didChange();
 }
 
+void VisibleSelection::setWithoutValidation(const PositionInComposedTree& base, const PositionInComposedTree& extent)
+{
+    setWithoutValidation(toPositionInDOMTree(base), toPositionInDOMTree(extent));
+}
+
 static PositionInComposedTree adjustPositionInComposedTreeForStart(const PositionInComposedTree& position, Node* shadowHost)
 {
     if (isEnclosedBy(position, *shadowHost)) {
         if (position.anchorType() == PositionInComposedTree::PositionIsBeforeChildren)
             return PositionInComposedTree::beforeNode(shadowHost);
         return PositionInComposedTree::afterNode(shadowHost);
     }
 
     // We use |firstChild|'s after instead of beforeAllChildren for backward
     // compatibility. The positions are same but the anchors would be different,
@@ skipping 246 matching lines @@
             return PositionWithAffinity();
 
         FloatPoint absolutePoint = targetNode->layoutObject()->localToAbsolute(FloatPoint(selectionEndPoint));
         selectionEndPoint = roundedLayoutPoint(editableElement->layoutObject()->absoluteToLocal(absolutePoint));
         targetNode = editableElement;
     }
 
     return targetNode->layoutObject()->positionForPoint(selectionEndPoint);
 }
 
-
 bool VisibleSelection::isContentEditable() const
 {
     return isEditablePosition(start());
 }
 
 bool VisibleSelection::hasEditableStyle() const
 {
     return isEditablePosition(start(), ContentIsEditable, DoNotUpdateStyle);
 }
 
@@ skipping 71 matching lines @@
 {
     if (!isValidPosition(m_base) || !isValidPosition(m_extent) || !isValidPosition(m_start) || !isValidPosition(m_end))
         validate();
 }
 
 bool VisibleSelection::InDOMTree::equalSelections(const VisibleSelection& selection1, const VisibleSelection& selection2)
 {
     return selection1 == selection2;
 }
 
+bool VisibleSelection::InComposedTree::equalSelections(const VisibleSelection& a, const VisibleSelection& b)
+{
+    return a.startInComposedTree() == b.startInComposedTree() && a.endInComposedTree() == b.endInComposedTree() && a.affinity() == b.affinity() && a.isBaseFirst() == b.isBaseFirst() && a.isDirectional() == b.isDirectional();
+}
+
 #ifndef NDEBUG
 
 void VisibleSelection::debugPosition(const char* message) const
 {
     fprintf(stderr, "VisibleSelection (%s) ===============\n", message);
 
     if (m_baseIsFirst) {
         m_start.debugPosition("start: ");
         m_base.debugPosition("base: ");
         m_end.debugPosition("end: ");
@@ skipping 64 matching lines @@
     sel.showTreeForThis();
 }
 
 void showTree(const blink::VisibleSelection* sel)
 {
     if (sel)
         sel->showTreeForThis();
 }
 
 #endif