ShadowRoot's getSelection().getRangeAt(0) returns an incorrect Range object

Source/core/editing/DOMSelection.cpp

 /*
  * Copyright (C) 2007, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2012 Google 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.
@@ skipping 30 matching lines @@
 #include "core/dom/TreeScope.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/TextIterator.h"
 #include "core/editing/htmlediting.h"
 #include "core/frame/LocalFrame.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
-static Node* selectionShadowAncestor(LocalFrame* frame)
-{
-    Node* node = frame->selection().selection().base().anchorNode();
-    if (!node)
-        return 0;
-
-    if (!node->isInShadowTree())
-        return 0;
-
-    return frame->document()->ancestorInThisScope(node);
-}
-
 DOMSelection::DOMSelection(const TreeScope* treeScope)
     : DOMWindowProperty(treeScope->rootNode().document().frame())
     , m_treeScope(treeScope)
 {
 }
 
 void DOMSelection::clearTreeScope()
 {
     m_treeScope = nullptr;
 }
 
 const VisibleSelection& DOMSelection::visibleSelection() const
 {
     ASSERT(m_frame);
     return m_frame->selection().selection();
 }
 
+bool DOMSelection::isInShadowTree() const
+{
+    ASSERT(m_frame);
+    const VisibleSelection& selection = visibleSelection();
+    if (selection.start().anchorNode() && selection.start().anchorNode()->isInShadowTree()) {
+        ASSERT(selection.end().anchorNode() && selection.end().anchorNode()->isInShadowTree());
+        return true;
+    }
+    return false;
+}
+
 static Position anchorPosition(const VisibleSelection& selection)
 {
     Position anchor = selection.isBaseFirst() ? selection.start() : selection.end();
     return anchor.parentAnchoredEquivalent();
 }
 
 static Position focusPosition(const VisibleSelection& selection)
 {
     Position focus = selection.isBaseFirst() ? selection.end() : selection.start();
     return focus.parentAnchoredEquivalent();
@@ skipping 68 matching lines @@
 int DOMSelection::extentOffset() const
 {
     if (!m_frame)
         return 0;
 
     return shadowAdjustedOffset(extentPosition(visibleSelection()));
 }
 
 bool DOMSelection::isCollapsed() const
 {
-    if (!m_frame || selectionShadowAncestor(m_frame))
+    if (!m_frame)
+        return false;
+
+    FrameSelection& selection = m_frame->selection();

[yosin_UTC9, 2015/01/06 08:39:37]

I think |isCollapsed()| should be |return anchorNode() != focusNode() ||
  anchorOffset() != focusOffset();|

If above condition doesn't match to current behavior, let's file another bug and
fix to this.

[kojii, 2015/01/07 06:53:52]

Done.

+    if (selection.isNone())
         return true;
-    return !m_frame->selection().isRange();
+
+    if (isInShadowTree()) {
+        Position anchor = anchorPosition(selection.selection());
+        ASSERT(anchor.anchorNode() && anchor.anchorNode()->isInShadowTree());
+        Position focus = focusPosition(selection.selection());
+        ASSERT(focus.anchorNode() && focus.anchorNode()->isInShadowTree());
+        return shadowAdjustedPosition(anchor) == shadowAdjustedPosition(focus);
+    }
+
+    return !selection.isRange();
 }
 
 String DOMSelection::type() const
 {
     if (!m_frame)
         return String();
 
     FrameSelection& selection = m_frame->selection();
 
     // This is a WebKit DOM extension, incompatible with an IE extension
@@ skipping 181 matching lines @@
         return nullptr;
 
     if (index < 0 || index >= rangeCount()) {
         exceptionState.throwDOMException(IndexSizeError, String::number(index) + " is not a valid index.");
         return nullptr;
     }
 
     // If you're hitting this, you've added broken multi-range selection support
     ASSERT(rangeCount() == 1);
 
-    if (Node* shadowAncestor = selectionShadowAncestor(m_frame)) {
-        ASSERT(!shadowAncestor->isShadowRoot());
-        ContainerNode* container = shadowAncestor->parentOrShadowHostNode();
-        int offset = shadowAncestor->nodeIndex();
-        return Range::create(shadowAncestor->document(), container, offset, container, offset);
+    Position anchor = anchorPosition(visibleSelection());

[yosin_UTC9, 2015/01/06 08:39:37]

I think we can implement as below:
if (!isShadowRoot(m_treeScope.rootNode())
  return m_frame->selection().firstRange();
auto const anchorNode = anchorNode();
auto const anchorOffset = anchorOffset();
auto const focusNode = focusNode();
auto const focusOffset = focusOffset();
return Range::create(anchorNode->document(), ....);

[kojii, 2015/01/07 06:53:52]

Done.

+    ASSERT(anchor.anchorNode());
+    if (anchor.anchorNode()->isInShadowTree()) {
+        Position focus = focusPosition(visibleSelection());
+        ASSERT(focus.anchorNode() && focus.anchorNode()->isInShadowTree());
+        return Range::create(*anchor.document(), shadowAdjustedPosition(anchor), shadowAdjustedPosition(focus));
     }
 
     return m_frame->selection().firstRange();
 }
 
 void DOMSelection::removeAllRanges()
 {
     if (!m_frame)
         return;
     m_frame->selection().clear();
@@ skipping 116 matching lines @@
 {
     if (!m_frame)
         return String();
 
     Position start, end;
     if (m_frame->selection().selection().toNormalizedPositions(start, end))
         return plainText(start, end);
     return emptyString();
 }
 
+Position DOMSelection::shadowAdjustedPosition(const Position& position) const
+{
+    if (position.isNull())
+        return position;
+
+    Node* containerNode = position.containerNode();
+    Node* adjustedNode = m_treeScope->ancestorInThisScope(containerNode);
+
+    if (!adjustedNode)
+        return Position();
+
+    if (containerNode == adjustedNode)
+        return Position(containerNode, position.computeOffsetInContainerNode(), Position::PositionIsOffsetInAnchor);
+
+    ASSERT(!adjustedNode->isShadowRoot());
+    return Position(adjustedNode->parentOrShadowHostNode(), adjustedNode->nodeIndex(), Position::PositionIsOffsetInAnchor);
+}
+
 Node* DOMSelection::shadowAdjustedNode(const Position& position) const
 {
     if (position.isNull())
         return 0;
 
     Node* containerNode = position.containerNode();
     Node* adjustedNode = m_treeScope->ancestorInThisScope(containerNode);
 
     if (!adjustedNode)
         return 0;
@@ skipping 36 matching lines @@
         m_treeScope->document().addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
 }
 
 void DOMSelection::trace(Visitor* visitor)
 {
     visitor->trace(m_treeScope);
     DOMWindowProperty::trace(visitor);
 }
 
 } // namespace blink