Selection API: Mutating a Range object after adding it to Selection should update Selection attribu…

third_party/WebKit/Source/core/dom/Range.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Gunnstein Lye (gunnstein@netcom.no)
  * (C) 2000 Frederik Holljen (frederik.holljen@hig.no)
  * (C) 2001 Peter Kelly (pmk@post.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2011 Motorola Mobility. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 18 matching lines @@
 #include "core/dom/ClientRect.h"
 #include "core/dom/ClientRectList.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/Node.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/NodeWithIndex.h"
 #include "core/dom/ProcessingInstruction.h"
 #include "core/dom/Text.h"
 #include "core/editing/EditingUtilities.h"
+#include "core/editing/EphemeralRange.h"
+#include "core/editing/FrameSelection.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/editing/serializers/Serialization.h"
 #include "core/events/ScopedEventQueue.h"
 #include "core/html/HTMLBodyElement.h"
 #include "core/html/HTMLElement.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutText.h"
 #include "core/svg/SVGSVGElement.h"
@@ skipping 114 matching lines @@
 void Range::setStart(Node* refNode,
                      int offset,
                      ExceptionState& exceptionState) {
   if (!refNode) {
     // FIXME: Generated bindings code never calls with null, and neither should
     // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
   }
 
+  Document& oldDocument = ownerDocument();
   bool didMoveDocument = false;
   if (refNode->document() != m_ownerDocument) {
     setDocument(refNode->document());
     didMoveDocument = true;
   }
 
   Node* childNode = checkNodeWOffset(refNode, offset, exceptionState);
   if (exceptionState.hadException())
     return;
 
   m_start.set(refNode, offset, childNode);
 
-  if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end))
+  if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end)) {
+    removeFromSelectionIfInDifferentRoot(oldDocument);
     collapse(true);
+    return;
+  }
+  updateSelectionIfAddedToSelection();
 }
 
 void Range::setEnd(Node* refNode, int offset, ExceptionState& exceptionState) {
   if (!refNode) {
     // FIXME: Generated bindings code never calls with null, and neither should
     // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
   }
 
   bool didMoveDocument = false;
+  Document& oldDocument = ownerDocument();
   if (refNode->document() != m_ownerDocument) {
     setDocument(refNode->document());
     didMoveDocument = true;
   }
 
   Node* childNode = checkNodeWOffset(refNode, offset, exceptionState);
   if (exceptionState.hadException())
     return;
 
   m_end.set(refNode, offset, childNode);
 
-  if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end))
+  if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end)) {
+    removeFromSelectionIfInDifferentRoot(oldDocument);
     collapse(false);
+    return;
+  }
+  updateSelectionIfAddedToSelection();
 }
 
 void Range::setStart(const Position& start, ExceptionState& exceptionState) {
   Position parentAnchored = start.parentAnchoredEquivalent();
   setStart(parentAnchored.computeContainerNode(),
            parentAnchored.offsetInContainerNode(), exceptionState);
 }
 
 void Range::setEnd(const Position& end, ExceptionState& exceptionState) {
   Position parentAnchored = end.parentAnchoredEquivalent();
   setEnd(parentAnchored.computeContainerNode(),
          parentAnchored.offsetInContainerNode(), exceptionState);
 }
 
 void Range::collapse(bool toStart) {
   if (toStart)
     m_end = m_start;
   else
     m_start = m_end;
+  updateSelectionIfAddedToSelection();
 }
 
 bool Range::isNodeFullyContained(Node& node) const {
   ContainerNode* parentNode = node.parentNode();
   int nodeIndex = node.nodeIndex();
   return isPointInRange(
              parentNode, nodeIndex,
              IGNORE_EXCEPTION_FOR_TESTING)  // starts in the middle of this
                                             // range, or on the boundary points.
          && isPointInRange(
@@ skipping 929 matching lines @@
       break;
     case Node::kAttributeNode:
     case Node::kDocumentFragmentNode:
     case Node::kDocumentNode:
       exceptionState.throwDOMException(
           InvalidNodeTypeError,
           "The node provided is of type '" + refNode->nodeName() + "'.");
       return;
   }
 
-  if (m_ownerDocument != refNode->document())
-    setDocument(refNode->document());
-
   setStartBefore(refNode);
   setEndAfter(refNode);
 }
 
 void Range::selectNodeContents(Node* refNode, ExceptionState& exceptionState) {
   if (!refNode) {
     // FIXME: Generated bindings code never calls with null, and neither should
     // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
@@ skipping 14 matching lines @@
       case Node::kTextNode:
         break;
       case Node::kDocumentTypeNode:
         exceptionState.throwDOMException(
             InvalidNodeTypeError,
             "The node provided is of type '" + refNode->nodeName() + "'.");
         return;
     }
   }
 
+  Document& oldDocument = ownerDocument();
   if (m_ownerDocument != refNode->document())
     setDocument(refNode->document());
 
   m_start.setToStartOfNode(*refNode);
   m_end.setToEndOfNode(*refNode);
+  removeFromSelectionIfInDifferentRoot(oldDocument);
+  updateSelectionIfAddedToSelection();
 }
 
 bool Range::selectNodeContents(Node* refNode, Position& start, Position& end) {
   if (!refNode) {
     return false;
   }
 
   for (Node* n = refNode; n; n = n->parentNode()) {
     switch (n->getNodeType()) {
       case Node::kAttributeNode:
@@ skipping 462 matching lines @@
   for (const FloatQuad& quad : quads)
     result.unite(quad.boundingBox());  // Skips empty rects.
 
   // If all rects are empty, return the first rect.
   if (result.isEmpty() && !quads.isEmpty())
     return quads.front().boundingBox();
 
   return result;
 }
 
+void Range::updateSelectionIfAddedToSelection() {
+  if (!ownerDocument().frame())
+    return;
+  FrameSelection& selection = ownerDocument().frame()->selection();
+  if (this != selection.documentCachedRange())
+    return;
+  DCHECK(startContainer()->isConnected());
+  DCHECK(startContainer()->document() == ownerDocument());
+  DCHECK(endContainer()->isConnected());
+  DCHECK(endContainer()->document() == ownerDocument());
+  selection.setSelectedRange(EphemeralRange(this), VP_DEFAULT_AFFINITY);
+  selection.cacheRangeOfDocument(this);
+}
+
+void Range::removeFromSelectionIfInDifferentRoot(Document& oldDocument) {
+  if (!oldDocument.frame())
+    return;
+  FrameSelection& selection = oldDocument.frame()->selection();
+  if (this != selection.documentCachedRange())
+    return;
+  if (ownerDocument() == oldDocument && startContainer()->isConnected() &&
+      endContainer()->isConnected())
+    return;
+  selection.clear();
+  selection.clearDocumentCachedRange();
+}
+
 DEFINE_TRACE(Range) {
   visitor->trace(m_ownerDocument);
   visitor->trace(m_start);
   visitor->trace(m_end);
 }
 
 }  // namespace blink
 
 #ifndef NDEBUG
 
 void showTree(const blink::Range* range) {
   if (range && range->boundaryPointsValid()) {
     LOG(INFO) << "\n"
               << range->startContainer()
                      ->toMarkedTreeString(range->startContainer(), "S",
                                           range->endContainer(), "E")
                      .utf8()
                      .data()
               << "start offset: " << range->startOffset()
               << ", end offset: " << range->endOffset();
   } else {
     LOG(INFO) << "Cannot show tree if range is null, or if boundary points are "
                  "invalid.";
   }
 }
 
 #endif