CONTINUED Make FrameSelection to hold non-canonicalized positions

third_party/WebKit/Source/core/editing/FrameSelection.cpp

 /*
  * Copyright (C) 2004, 2008, 2009, 2010 Apple 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 74 matching lines @@
 #define EDIT_DEBUG 0
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static inline bool shouldAlwaysUseDirectionalSelection(LocalFrame* frame) {
   return frame->editor().behavior().shouldConsiderSelectionAsDirectional();
 }
 
+FrameSelection* FrameSelection::create(LocalFrame& frame) {
+  return new FrameSelection(frame);
+}
+
 FrameSelection::FrameSelection(LocalFrame& frame)
     : m_frame(frame),
       m_pendingSelection(PendingSelection::create(*this)),
       m_selectionEditor(SelectionEditor::create(frame)),
       m_granularity(CharacterGranularity),
       m_xPosForVerticalArrowNavigation(NoXPosForVerticalArrowNavigation()),
       m_focused(frame.page() &&
                 frame.page()->focusController().focusedFrame() == frame),
       m_frameCaret(new FrameCaret(frame, *m_selectionEditor)) {}
 
 FrameSelection::~FrameSelection() {}
 
 const DisplayItemClient& FrameSelection::caretDisplayItemClientForTesting()
     const {
-  return *m_frameCaret;
+  return m_frameCaret->displayItemClient();
 }
 
-const Document& FrameSelection::document() const {
-  DCHECK(m_document);
-  return *m_document;
+Document& FrameSelection::document() const {
+  DCHECK(lifecycleContext());
+  return *lifecycleContext();
 }
 
-Document& FrameSelection::document() {
-  DCHECK(m_document);
-  return *m_document;
+const VisibleSelection& FrameSelection::computeVisibleSelectionInDOMTree()
+    const {
+  return m_selectionEditor->computeVisibleSelectionInDOMTree();
 }
 
-// TODO(yosin): To avoid undefined symbols in clang, we explicitly
-// have specialized version of |FrameSelection::visibleSelection<Strategy>|
-// before |FrameSelection::selection()| which refers this.
-template <>
-const VisibleSelection& FrameSelection::visibleSelection<EditingStrategy>()
-    const {
-  return m_selectionEditor->visibleSelection<EditingStrategy>();
+const VisibleSelectionInFlatTree&
+FrameSelection::computeVisibleSelectionInFlatTree() const {
+  return m_selectionEditor->computeVisibleSelectionInFlatTree();
 }
 
-template <>
-const VisibleSelectionInFlatTree&
-FrameSelection::visibleSelection<EditingInFlatTreeStrategy>() const {
-  return m_selectionEditor->visibleSelection<EditingInFlatTreeStrategy>();
+const SelectionInDOMTree& FrameSelection::selectionInDOMTree() const {
+  return m_selectionEditor->selectionInDOMTree();
 }
 
 Element* FrameSelection::rootEditableElementOrDocumentElement() const {
   Element* selectionRoot = selection().rootEditableElement();
   return selectionRoot ? selectionRoot : document().documentElement();
 }
 
 ContainerNode* FrameSelection::rootEditableElementOrTreeScopeRootNode() const {
   Element* selectionRoot = selection().rootEditableElement();
   if (selectionRoot)
     return selectionRoot;
 
   Node* node = selection().base().computeContainerNode();
   return node ? &node->treeScope().rootNode() : 0;
 }
 
+// TODO(yosin): We should rename |FrameSelection::selection()| to
+// |selectionDeprecated()|.
 const VisibleSelection& FrameSelection::selection() const {
-  return visibleSelection<EditingStrategy>();
-}
-
-const VisibleSelectionInFlatTree& FrameSelection::selectionInFlatTree() const {
-  return visibleSelection<EditingInFlatTreeStrategy>();
+  // TODO(yosin): We should hoist updateStyleAndLayoutIgnorePendingStylesheets
+  // to caller. See http://crbug.com/590369 for more details.
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+  return computeVisibleSelectionInDOMTree();
 }
 
 void FrameSelection::moveCaretSelection(const IntPoint& point) {
   DCHECK(!document().needsLayoutTreeUpdate());
 
   Element* const editable = rootEditableElement();
   if (!editable)
     return;
 
   const VisiblePosition position =
       visiblePositionForContentsPoint(point, frame());
   SelectionInDOMTree::Builder builder;
   builder.setIsDirectional(selection().isDirectional());
   if (position.isNotNull())
     builder.collapse(position.toPositionWithAffinity());
   setSelection(builder.build(), CloseTyping | ClearTypingStyle | UserTriggered);
 }
 
-template <typename Strategy>
-void FrameSelection::setSelectionAlgorithm(
-    const VisibleSelectionTemplate<Strategy>& newSelection,
-    SetSelectionOptions options,
-    CursorAlignOnScroll align,
-    TextGranularity granularity) {
+void FrameSelection::setSelection(const SelectionInDOMTree& passedSelection,
+                                  SetSelectionOptions options,
+                                  CursorAlignOnScroll align,
+                                  TextGranularity granularity) {
   DCHECK(isAvailable());
-  DCHECK(newSelection.isValidFor(document()));
-  const Document& currentDocument = document();
+  passedSelection.assertValidFor(document());
+
+  SelectionInDOMTree::Builder builder(passedSelection);
+  if (shouldAlwaysUseDirectionalSelection(m_frame))
+    builder.setIsDirectional(true);
+  SelectionInDOMTree newSelection = builder.build();
   if (m_granularityStrategy &&
       (options & FrameSelection::DoNotClearStrategy) == 0)
     m_granularityStrategy->Clear();
   bool closeTyping = options & CloseTyping;
   bool shouldClearTypingStyle = options & ClearTypingStyle;
-  EUserTriggered userTriggered = selectionOptionsToUserTriggered(options);
-
-  // TODO(editing-dev): We should rename variable |s| to another name to avoid
-  // using one letter variable name.
-  VisibleSelectionTemplate<Strategy> s = newSelection;
-  if (shouldAlwaysUseDirectionalSelection(m_frame))
-    s.setIsDirectional(true);
 
   m_granularity = granularity;
 
   // TODO(yosin): We should move to call |TypingCommand::closeTyping()| to
   // |Editor| class.
   if (closeTyping)
     TypingCommand::closeTyping(m_frame);
 
   if (shouldClearTypingStyle)
     clearTypingStyle();
 
-  if (m_selectionEditor->visibleSelection<Strategy>() == s) {
-    // Even if selection was not changed, selection offsets may have been
-    // changed.
-    m_frame->inputMethodController().cancelCompositionIfSelectionIsInvalid();
-    notifyLayoutObjectOfSelectionChange(userTriggered);
+  const SelectionInDOMTree oldSelectionInDOMTree =
+      m_selectionEditor->selectionInDOMTree();
+  if (oldSelectionInDOMTree == newSelection)
     return;
-  }
+  m_selectionEditor->setSelection(newSelection);
 
-  const VisibleSelectionTemplate<Strategy> oldSelection =
-      visibleSelection<Strategy>();
-  const Position& oldSelectionStart = selection().start();
+  // TODO(yosin): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited. see http://crbug.com/590369 for more details.
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
 
-  m_selectionEditor->setVisibleSelection(s, options);
-  m_frameCaret->setCaretRectNeedsUpdate();
+  const Document& currentDocument = document();
+  // TODO(yosin): We should get rid of unsued |options| for
+  // |Editor::respondToChangedSelection()|.
+  // Note: Since, setting focus can modify DOM tree, we should use
+  // |oldSelection| before setting focus
+  m_frame->editor().respondToChangedSelection(
+      createVisibleSelection(oldSelectionInDOMTree).start(), options);
+  DCHECK_EQ(currentDocument, document());
 
-  if (!s.isNone() && !(options & DoNotSetFocus)) {
+  if (!selection().isNone() && !(options & DoNotSetFocus)) {
     setFocusedNodeIfNeeded();
     // |setFocusedNodeIfNeeded()| dispatches sync events "FocusOut" and
     // "FocusIn", |m_frame| may associate to another document.
     if (!isAvailable() || document() != currentDocument) {
       // Once we get test case to reach here, we should change this
       // if-statement to |DCHECK()|.
       NOTREACHED();
       return;
     }
   }
-
-  if (!(options & DoNotUpdateAppearance)) {
-    // Hits in
-    // compositing/overflow/do-not-paint-outline-into-composited-scrolling-contents.html
-    DisableCompositingQueryAsserts disabler;
-    m_frameCaret->stopCaretBlinkTimer();
-    updateAppearance();
-  }
+  updateAppearance();
 
   // Always clear the x position used for vertical arrow navigation.
   // It will be restored by the vertical arrow navigation code if necessary.
   m_xPosForVerticalArrowNavigation = NoXPosForVerticalArrowNavigation();
+  // TODO(yosin): Can we move this to at end of this function?
   // This may dispatch a synchronous focus-related events.
   selectFrameElementInParentIfFullySelected();
   if (!isAvailable() || document() != currentDocument) {
     // editing/selection/selectallchildren-crash.html and
     // editing/selection/longpress-selection-in-iframe-removed-crash.html
     // reach here.
     return;
   }
+  EUserTriggered userTriggered = selectionOptionsToUserTriggered(options);
   notifyLayoutObjectOfSelectionChange(userTriggered);
-  // If the selections are same in the DOM tree but not in the flat tree,
-  // don't fire events. For example, if the selection crosses shadow tree
-  // boundary, selection for the DOM tree is shrunk while that for the
-  // flat tree is not. Additionally, this case occurs in some edge cases.
-  // See also: editing/pasteboard/4076267-3.html
-  if (oldSelection == m_selectionEditor->visibleSelection<Strategy>()) {
-    m_frame->inputMethodController().cancelCompositionIfSelectionIsInvalid();
-    return;
-  }
-  m_frame->editor().respondToChangedSelection(oldSelectionStart, options);
   if (userTriggered == UserTriggered) {
     ScrollAlignment alignment;
 
     if (m_frame->editor().behavior().shouldCenterAlignWhenSelectionIsRevealed())
       alignment = (align == CursorAlignOnScroll::Always)
                       ? ScrollAlignment::alignCenterAlways
                       : ScrollAlignment::alignCenterIfNeeded;
     else
       alignment = (align == CursorAlignOnScroll::Always)
                       ? ScrollAlignment::alignTopAlways
                       : ScrollAlignment::alignToEdgeIfNeeded;
 
+    // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+    // needs to be audited.  See http://crbug.com/590369 for more details.
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+
     revealSelection(alignment, RevealExtent);
   }
 
   notifyAccessibilityForSelectionChange();
   notifyCompositorForSelectionChange();
   notifyEventHandlerForSelectionChange();
   m_frame->domWindow()->enqueueDocumentEvent(
       Event::create(EventTypeNames::selectionchange));
 }
 
-// TODO(yosin): We will make |selectionInDOMTree| version of |SetSelection()|
-// as primary function instead of wrapper.
-void FrameSelection::setSelection(const SelectionInDOMTree& newSelection,
-                                  SetSelectionOptions options,
-                                  CursorAlignOnScroll align,
-                                  TextGranularity granularity) {
-  if (!newSelection.isNone()) {
-    // TODO(editing-dev): The use of
-    // updateStyleAndLayoutIgnorePendingStylesheets
-    // needs to be audited.  See http://crbug.com/590369 for more details.
-    newSelection.base()
-        .document()
-        ->updateStyleAndLayoutIgnorePendingStylesheets();
-  }
-  setSelection(createVisibleSelection(newSelection), options, align,
-               granularity);
-}
-
-// TODO(yosin): We will make |selectionInFlatTree| version of |SetSelection()|
-// as primary function instead of wrapper.
 void FrameSelection::setSelection(const SelectionInFlatTree& newSelection,
                                   SetSelectionOptions options,
                                   CursorAlignOnScroll align,
                                   TextGranularity granularity) {
-  if (!newSelection.isNone()) {
-    // TODO(editing-dev): The use of
-    // updateStyleAndLayoutIgnorePendingStylesheets
-    // needs to be audited.  See http://crbug.com/590369 for more details.
-    newSelection.base()
-        .document()
-        ->updateStyleAndLayoutIgnorePendingStylesheets();
-  }
-  setSelection(createVisibleSelection(newSelection), options, align,
-               granularity);
+  newSelection.assertValidFor(document());
+  SelectionInDOMTree::Builder builder;
+  builder.setAffinity(newSelection.affinity())
+      .setBaseAndExtent(toPositionInDOMTree(newSelection.base()),
+                        toPositionInDOMTree(newSelection.extent()))
+      .setGranularity(newSelection.granularity())
+      .setIsDirectional(newSelection.isDirectional())
+      .setHasTrailingWhitespace(newSelection.hasTrailingWhitespace());
+  return setSelection(builder.build(), options, align, granularity);
 }
 
 void FrameSelection::setSelection(const VisibleSelection& newSelection,
                                   SetSelectionOptions options,
                                   CursorAlignOnScroll align,
                                   TextGranularity granularity) {
-  setSelectionAlgorithm<EditingStrategy>(newSelection, options, align,
-                                         granularity);
+  setSelection(newSelection.asSelection(), options, align, granularity);
 }
 
 void FrameSelection::setSelection(
     const VisibleSelectionInFlatTree& newSelection,
     SetSelectionOptions options,
     CursorAlignOnScroll align,
     TextGranularity granularity) {
-  setSelectionAlgorithm<EditingInFlatTreeStrategy>(newSelection, options, align,
-                                                   granularity);
-}
-
-static bool removingNodeRemovesPosition(Node& node, const Position& position) {
-  if (!position.anchorNode())
-    return false;
-
-  if (position.anchorNode() == node)
-    return true;
-
-  if (!node.isElementNode())
-    return false;
-
-  Element& element = toElement(node);
-  return element.isShadowIncludingInclusiveAncestorOf(position.anchorNode());
-}
-
-static Position computePositionForChildrenRemoval(const Position& position,
-                                                  ContainerNode& container) {
-  Node* node = position.computeContainerNode();
-  if (container.containsIncludingHostElements(*node))
-    return Position::firstPositionInNode(&container);
-  return position;
+  setSelection(newSelection.asSelection(), options, align, granularity);
 }
 
 void FrameSelection::nodeChildrenWillBeRemoved(ContainerNode& container) {
-  if (isNone() || !container.inActiveDocument())
+  if (!container.inActiveDocument())
     return;
-  const Position& oldStart = selection().start();
-  const Position& newStart =
-      computePositionForChildrenRemoval(oldStart, container);
-  const Position& oldEnd = selection().end();
-  const Position& newEnd = computePositionForChildrenRemoval(oldEnd, container);
-  const Position& oldBase = selection().base();
-  const Position& newBase =
-      computePositionForChildrenRemoval(oldBase, container);
-  const Position& oldExtent = selection().extent();
-  const Position& newExtent =
-      computePositionForChildrenRemoval(oldExtent, container);
-  if (newStart == oldStart && newEnd == oldEnd && newBase == oldBase &&
-      newExtent == oldExtent)
-    return;
-  if (selection().isBaseFirst())
-    m_selectionEditor->setWithoutValidation(newStart, newEnd);
-  else
-    m_selectionEditor->setWithoutValidation(newEnd, newStart);
-  m_frameCaret->setCaretRectNeedsUpdate();
-  if (document().isRunningExecCommand())
-    return;
-  TypingCommand::closeTyping(m_frame);
-}
-
-void FrameSelection::nodeWillBeRemoved(Node& node) {
-  // There can't be a selection inside a fragment, so if a fragment's node is
-  // being removed, the selection in the document that created the fragment
-  // needs no adjustment.
-  if (isNone() || !node.inActiveDocument())
-    return;
-
-  respondToNodeModification(
-      node, removingNodeRemovesPosition(node, selection().base()),
-      removingNodeRemovesPosition(node, selection().extent()),
-      removingNodeRemovesPosition(node, selection().start()),
-      removingNodeRemovesPosition(node, selection().end()));
-
-  m_frameCaret->nodeWillBeRemoved(node);
-}
-
-static SelectionState selectionStateOf(const Node& node) {
-  const LayoutObject* layoutObject = node.layoutObject();
-  if (!layoutObject)
-    return SelectionNone;
-  return layoutObject->getSelectionState();
-}
-
-void FrameSelection::respondToNodeModification(Node& node,
-                                               bool baseRemoved,
-                                               bool extentRemoved,
-                                               bool startRemoved,
-                                               bool endRemoved) {
-  DCHECK(node.document().isActive()) << node;
-
-  bool clearLayoutTreeSelection = false;
-  bool clearDOMTreeSelection = false;
-
-  if (startRemoved || endRemoved) {
-    Position start = selection().start();
-    Position end = selection().end();
-    if (startRemoved)
-      updatePositionForNodeRemoval(start, node);
-    if (endRemoved)
-      updatePositionForNodeRemoval(end, node);
-
-    if (Position::commonAncestorTreeScope(start, end) && start.isNotNull() &&
-        end.isNotNull()) {
-      if (selection().isBaseFirst())
-        m_selectionEditor->setWithoutValidation(start, end);
-      else
-        m_selectionEditor->setWithoutValidation(end, start);
-    } else {
-      clearDOMTreeSelection = true;
-    }
-
-    clearLayoutTreeSelection = true;
-  } else if (baseRemoved || extentRemoved) {
-    // The base and/or extent are about to be removed, but the start and end
-    // aren't. Change the base and extent to the start and end, but don't
-    // re-validate the selection, since doing so could move the start and end
-    // into the node that is about to be removed.
-    if (selection().isBaseFirst())
-      m_selectionEditor->setWithoutValidation(selection().start(),
-                                              selection().end());
-    else
-      m_selectionEditor->setWithoutValidation(selection().end(),
-                                              selection().start());
-  } else if (selectionStateOf(node) != SelectionNone) {
-    // When node to be removed is part of selection, we invalidate
-    // selection to paint again.
-    // TODO(yosin): We should paint changed area only rather than whole
-    // selected range.
-    clearLayoutTreeSelection = true;
-  }
-
-  if (clearLayoutTreeSelection)
-    selection().start().document()->layoutViewItem().clearSelection();
-
-  if (clearDOMTreeSelection)
-    setSelection(SelectionInDOMTree(), DoNotSetFocus);
-  m_frameCaret->setCaretRectNeedsUpdate();
-
   // TODO(yosin): We should move to call |TypingCommand::closeTyping()| to
   // |Editor| class.
   if (!document().isRunningExecCommand())
     TypingCommand::closeTyping(m_frame);
 }
 
-static Position updatePositionAfterAdoptingTextReplacement(
-    const Position& position,
-    CharacterData* node,
-    unsigned offset,
-    unsigned oldLength,
-    unsigned newLength) {
-  if (!position.anchorNode() || position.anchorNode() != node ||
-      !position.isOffsetInAnchor())
-    return position;
-
-  // See:
-  // http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Mutation
-  DCHECK_GE(position.offsetInContainerNode(), 0);
-  unsigned positionOffset =
-      static_cast<unsigned>(position.offsetInContainerNode());
-  // Replacing text can be viewed as a deletion followed by insertion.
-  if (positionOffset >= offset && positionOffset <= offset + oldLength)
-    positionOffset = offset;
-
-  // Adjust the offset if the position is after the end of the deleted contents
-  // (positionOffset > offset + oldLength) to avoid having a stale offset.
-  if (positionOffset > offset + oldLength)
-    positionOffset = positionOffset - oldLength + newLength;
-
-  // Due to case folding
-  // (http://unicode.org/Public/UCD/latest/ucd/CaseFolding.txt), LayoutText
-  // length may be different from Text length.  A correct implementation would
-  // translate the LayoutText offset to a Text offset; this is just a safety
-  // precaution to avoid offset values that run off the end of the Text.
-  if (positionOffset > node->length())
-    positionOffset = node->length();
-
-  // CharacterNode in VisibleSelection must be Text node, because Comment
-  // and ProcessingInstruction node aren't visible.
-  return Position(toText(node), positionOffset);
-}
-
-void FrameSelection::didUpdateCharacterData(CharacterData* node,
-                                            unsigned offset,
-                                            unsigned oldLength,
-                                            unsigned newLength) {
-  // The fragment check is a performance optimization. See
-  // http://trac.webkit.org/changeset/30062.
-  if (isNone() || !node || !node->isConnected())
-    return;
-
-  Position base = updatePositionAfterAdoptingTextReplacement(
-      selection().base(), node, offset, oldLength, newLength);
-  Position extent = updatePositionAfterAdoptingTextReplacement(
-      selection().extent(), node, offset, oldLength, newLength);
-  Position start = updatePositionAfterAdoptingTextReplacement(
-      selection().start(), node, offset, oldLength, newLength);
-  Position end = updatePositionAfterAdoptingTextReplacement(
-      selection().end(), node, offset, oldLength, newLength);
-  updateSelectionIfNeeded(base, extent, start, end);
-}
-
-static Position updatePostionAfterAdoptingTextNodesMerged(
-    const Position& position,
-    const Text& oldNode,
-    unsigned offset) {
-  if (!position.anchorNode() || !position.isOffsetInAnchor())
-    return position;
-
-  DCHECK_GE(position.offsetInContainerNode(), 0);
-  unsigned positionOffset =
-      static_cast<unsigned>(position.offsetInContainerNode());
-
-  if (position.anchorNode() == &oldNode)
-    return Position(toText(oldNode.previousSibling()), positionOffset + offset);
-
-  if (position.anchorNode() == oldNode.parentNode() && positionOffset == offset)
-    return Position(toText(oldNode.previousSibling()), offset);
-
-  return position;
-}
-
-void FrameSelection::didMergeTextNodes(const Text& oldNode, unsigned offset) {
-  if (isNone() || !oldNode.isConnected())
-    return;
-  Position base = updatePostionAfterAdoptingTextNodesMerged(selection().base(),
-                                                            oldNode, offset);
-  Position extent = updatePostionAfterAdoptingTextNodesMerged(
-      selection().extent(), oldNode, offset);
-  Position start = updatePostionAfterAdoptingTextNodesMerged(
-      selection().start(), oldNode, offset);
-  Position end = updatePostionAfterAdoptingTextNodesMerged(selection().end(),
-                                                           oldNode, offset);
-  updateSelectionIfNeeded(base, extent, start, end);
-}
-
-static Position updatePostionAfterAdoptingTextNodeSplit(
-    const Position& position,
-    const Text& oldNode) {
-  if (!position.anchorNode() || position.anchorNode() != &oldNode ||
-      !position.isOffsetInAnchor())
-    return position;
-  // See:
-  // http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Mutation
-  DCHECK_GE(position.offsetInContainerNode(), 0);
-  unsigned positionOffset =
-      static_cast<unsigned>(position.offsetInContainerNode());
-  unsigned oldLength = oldNode.length();
-  if (positionOffset <= oldLength)
-    return position;
-  return Position(toText(oldNode.nextSibling()), positionOffset - oldLength);
-}
-
-void FrameSelection::didSplitTextNode(const Text& oldNode) {
-  if (isNone() || !oldNode.isConnected())
-    return;
-  Position base =
-      updatePostionAfterAdoptingTextNodeSplit(selection().base(), oldNode);
-  Position extent =
-      updatePostionAfterAdoptingTextNodeSplit(selection().extent(), oldNode);
-  Position start =
-      updatePostionAfterAdoptingTextNodeSplit(selection().start(), oldNode);
-  Position end =
-      updatePostionAfterAdoptingTextNodeSplit(selection().end(), oldNode);
-  updateSelectionIfNeeded(base, extent, start, end);
-}
-
-void FrameSelection::updateSelectionIfNeeded(const Position& base,
-                                             const Position& extent,
-                                             const Position& start,
-                                             const Position& end) {
-  if (base == selection().base() && extent == selection().extent() &&
-      start == selection().start() && end == selection().end())
+void FrameSelection::nodeWillBeRemoved(Node& node) {
+  // There can't be a selection inside a fragment, so if a fragment's node is
+  // being removed,
+  // the selection in the document that created the fragment needs no
+  // adjustment.
+  if (!node.inActiveDocument())
     return;
   // TODO(yosin): We should move to call |TypingCommand::closeTyping()| to
   // |Editor| class.
   if (!document().isRunningExecCommand())
     TypingCommand::closeTyping(m_frame);
-  VisibleSelection newSelection;
-  if (selection().isBaseFirst())
-    newSelection.setWithoutValidation(start, end);
-  else
-    newSelection.setWithoutValidation(end, start);
-  setSelection(newSelection, DoNotSetFocus);
 }
 
 void FrameSelection::didChangeFocus() {
   // Hits in
   // virtual/gpu/compositedscrolling/scrollbars/scrollbar-miss-mousemove-disabled.html
   DisableCompositingQueryAsserts disabler;
   updateAppearance();
 }
 
 static DispatchEventResult dispatchSelectStart(
@@ skipping 68 matching lines @@
 
   m_granularity = CharacterGranularity;
 
   return true;
 }
 
 void FrameSelection::clear() {
   m_granularity = CharacterGranularity;
   if (m_granularityStrategy)
     m_granularityStrategy->Clear();
-  setSelection(SelectionInDOMTree());
+  setSelection(VisibleSelection());
 }
 
 void FrameSelection::documentAttached(Document* document) {
   DCHECK(document);
-  DCHECK(!m_document) << "FrameSelection is already attached to " << m_document;
-  m_document = document;
-  m_useSecureKeyboardEntryWhenActive = false;
+  m_frameCaret->documentAttached(document);
   m_selectionEditor->documentAttached(document);
+  setContext(document);
 }
 
-void FrameSelection::documentDetached(const Document& document) {
-  DCHECK_EQ(m_document, document);
-  m_document = nullptr;
+void FrameSelection::contextDestroyed(Document*) {
   m_granularity = CharacterGranularity;
 
   LayoutViewItem view = m_frame->contentLayoutItem();
   if (!view.isNull())
     view.clearSelection();
 
   clearTypingStyle();
-  m_selectionEditor->documentDetached(document);
-  m_frameCaret->documentDetached();
 }
 
 LayoutBlock* FrameSelection::caretLayoutObject() const {
-  DCHECK(selection().isValidFor(document()));
-  if (!isCaret())
+  DCHECK(isAvailable());
+  const VisibleSelection& selection = computeVisibleSelectionInDOMTree();
+  if (!selection.isCaret())
     return nullptr;
-  return CaretBase::caretLayoutObject(selection().start().anchorNode());
+  return CaretBase::caretLayoutObject(selection.start().anchorNode());
 }
 
 IntRect FrameSelection::absoluteCaretBounds() {
-  DCHECK(selection().isValidFor(*m_frame->document()));
+  DCHECK(isAvailable());
   return m_frameCaret->absoluteCaretBounds();
 }
 
 void FrameSelection::invalidateCaretRect(bool forceInvalidation) {
   m_frameCaret->invalidateCaretRect(forceInvalidation);
 }
 
-void FrameSelection::dataWillChange(const CharacterData& node) {
-  m_frameCaret->dataWillChange(node);
-}
-
 void FrameSelection::paintCaret(GraphicsContext& context,
                                 const LayoutPoint& paintOffset) {
   m_frameCaret->paintCaret(context, paintOffset);
 }
 
 bool FrameSelection::contains(const LayoutPoint& point) {
-  if (document().layoutViewItem().isNull())
+  if (!isAvailable())
     return false;
 
   // Treat a collapsed selection like no selection.
   const VisibleSelectionInFlatTree& visibleSelection =
-      this->visibleSelection<EditingInFlatTreeStrategy>();
+      computeVisibleSelectionInFlatTree();
   if (!visibleSelection.isRange())
     return false;
 
   HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
   HitTestResult result(request, point);
   document().layoutViewItem().hitTest(result);
   Node* innerNode = result.innerNode();
   if (!innerNode || !innerNode->layoutObject())
     return false;
 
@@ skipping 10 matching lines @@
     return false;
 
   const PositionInFlatTree& start = visibleStart.deepEquivalent();
   const PositionInFlatTree& end = visibleEnd.deepEquivalent();
   const PositionInFlatTree& pos = visiblePos.deepEquivalent();
   return start.compareTo(pos) <= 0 && pos.compareTo(end) <= 0;
 }
 
 // Workaround for the fact that it's hard to delete a frame.
 // Call this after doing user-triggered selections to make it easy to delete the
-// frame you entirely selected. Can't do this implicitly as part of every
-// setSelection call because in some contexts it might not be good for the focus
-// to move to another frame. So instead we call it from places where we are
-// selecting with the mouse or the keyboard after setting the selection.
+// frame you entirely selected.
+// Can't do this implicitly as part of every setSelection call because in some
+// contexts it might not be good
+// for the focus to move to another frame. So instead we call it from places
+// where we are selecting with the
+// mouse or the keyboard after setting the selection.
 void FrameSelection::selectFrameElementInParentIfFullySelected() {
   // Find the parent frame; if there is none, then we have nothing to do.
   Frame* parent = m_frame->tree().parent();
   if (!parent)
     return;
   Page* page = m_frame->page();
   if (!page)
     return;
 
   // Check if the selection contains the entire frame contents; if not, then
@@ skipping 105 matching lines @@
     // |root| may be detached due to selectstart event.
     if (!root->isConnected() || expectedDocument != root->document())
       return;
   }
 
   setSelection(SelectionInDOMTree::Builder().selectAllChildren(*root).build());
   selectFrameElementInParentIfFullySelected();
   notifyLayoutObjectOfSelectionChange(UserTriggered);
 }
 
+bool FrameSelection::setSelectedRange(Range* range,
+                                      TextAffinity affinity,
+                                      SelectionDirectionalMode directional,
+                                      SetSelectionOptions options) {
+  if (!range || !range->isConnected())
+    return false;
+  DCHECK_EQ(range->startContainer()->document(),
+            range->endContainer()->document());
+  return setSelectedRange(EphemeralRange(range), affinity, directional,
+                          options);
+}
+
 bool FrameSelection::setSelectedRange(const EphemeralRange& range,
                                       TextAffinity affinity,
                                       SelectionDirectionalMode directional,
                                       SetSelectionOptions options) {
   if (range.isNull())
     return false;
   m_selectionEditor->resetLogicalRange();
   // Since |FrameSeleciton::setSelection()| dispatches events and DOM tree
   // can be modified by event handlers, we should create |Range| object before
   // calling it.
@@ skipping 69 matching lines @@
   // Secure keyboard entry is set by the active frame.
   if (m_useSecureKeyboardEntryWhenActive)
     setUseSecureKeyboardEntry(activeAndFocused);
 }
 
 void FrameSelection::pageActivationChanged() {
   focusedOrActiveStateChanged();
 }
 
 void FrameSelection::updateSecureKeyboardEntryIfActive() {
-  if (!isFocusedAndActive())
-    return;
-  setUseSecureKeyboardEntry(m_useSecureKeyboardEntryWhenActive);
+  if (isFocusedAndActive())
+    setUseSecureKeyboardEntry(m_useSecureKeyboardEntryWhenActive);
 }
 
 void FrameSelection::setUseSecureKeyboardEntryWhenActive(
     bool usesSecureKeyboard) {
   if (m_useSecureKeyboardEntryWhenActive == usesSecureKeyboard)
     return;
   m_useSecureKeyboardEntryWhenActive = usesSecureKeyboard;
   updateSecureKeyboardEntryIfActive();
 }
 
@@ skipping 18 matching lines @@
 }
 
 bool FrameSelection::isAppearanceDirty() const {
   return m_pendingSelection->hasPendingSelection();
 }
 
 void FrameSelection::commitAppearanceIfNeeded(LayoutView& layoutView) {
   return m_pendingSelection->commit(layoutView);
 }
 
+void FrameSelection::didLayout() {
+  DCHECK_GE(document().lifecycle().state(),
+            DocumentLifecycle::AfterPerformLayout);
+  updateAppearance();
+}
+
 void FrameSelection::updateAppearance() {
-  m_frameCaret->updateAppearance();
-
-  if (m_frame->contentLayoutItem().isNull())
-    return;
+  DCHECK(!m_frame->contentLayoutItem().isNull());
+  m_frameCaret->setCaretRectNeedsUpdate();
   m_pendingSelection->setHasPendingSelection();
 }
 
 void FrameSelection::notifyLayoutObjectOfSelectionChange(
     EUserTriggered userTriggered) {
   if (TextControlElement* textControl = enclosingTextControl(start()))
     textControl->selectionChanged(userTriggered == UserTriggered);
 }
 
 // Helper function that tells whether a particular node is an element that has
@@ skipping 26 matching lines @@
       }
       target = target->parentOrShadowHostElement();
     }
     document().clearFocusedElement();
   }
 }
 
 static String extractSelectedText(const FrameSelection& selection,
                                   TextIteratorBehavior behavior) {
   const VisibleSelectionInFlatTree& visibleSelection =
-      selection.visibleSelection<EditingInFlatTreeStrategy>();
+      selection.computeVisibleSelectionInFlatTree();
   const EphemeralRangeInFlatTree& range =
       visibleSelection.toNormalizedEphemeralRange();
   // We remove '\0' characters because they are not visibly rendered to the
   // user.
   return plainText(range, behavior).replace(0, "");
 }
 
 String FrameSelection::selectedHTMLForClipboard() const {
   const VisibleSelectionInFlatTree& visibleSelection =
-      this->visibleSelection<EditingInFlatTreeStrategy>();
+      computeVisibleSelectionInFlatTree();
   const EphemeralRangeInFlatTree& range =
       visibleSelection.toNormalizedEphemeralRange();
   return createMarkup(range.startPosition(), range.endPosition(),
                       AnnotateForInterchange,
                       ConvertBlocksToInlines::NotConvert, ResolveNonLocalURLs);
 }
 
 String FrameSelection::selectedText(TextIteratorBehavior behavior) const {
   return extractSelectedText(*this, behavior);
 }
@@ skipping 118 matching lines @@
 
   Document* document = m_frame->document();
   if (!isNone() || !(blink::hasEditableStyle(*document)))
     return;
 
   Element* documentElement = document->documentElement();
   if (!documentElement)
     return;
   if (HTMLBodyElement* body =
           Traversal<HTMLBodyElement>::firstChild(*documentElement)) {
-    // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
-    // needs to be audited.  See http://crbug.com/590369 for more details.
-    document->updateStyleAndLayoutIgnorePendingStylesheets();
-
     setSelection(SelectionInDOMTree::Builder()
                      .collapse(firstPositionInOrBeforeNode(body))
                      .build());
   }
 }
 
 // TODO(yoichio): We should have LocalFrame having FrameCaret,
 // Editor and PendingSelection using FrameCaret directly
 // and get rid of this.
 bool FrameSelection::shouldShowBlockCursor() const {
   return m_frameCaret->shouldShowBlockCursor();
 }
 
 // TODO(yoichio): We should have LocalFrame having FrameCaret,
 // Editor and PendingSelection using FrameCaret directly
 // and get rid of this.
 // TODO(yoichio): We should use "caret-shape" in "CSS Basic User Interface
 // Module Level 4" https://drafts.csswg.org/css-ui-4/
 // To use "caret-shape", we need to expose inserting mode information to CSS;
 // https://github.com/w3c/csswg-drafts/issues/133
 void FrameSelection::setShouldShowBlockCursor(bool shouldShowBlockCursor) {
   m_frameCaret->setShouldShowBlockCursor(shouldShowBlockCursor);
 }
 
+template <typename Strategy>
+VisibleSelectionTemplate<Strategy> FrameSelection::validateSelection(
+    const VisibleSelectionTemplate<Strategy>& selection) {
+  if (selection.isNone())
+    return selection;
+
+  const PositionTemplate<Strategy> base = selection.base();
+  const PositionTemplate<Strategy> extent = selection.extent();
+  bool isBaseValid = base.document() == document();
+  bool isExtentValid = extent.document() == document();
+
+  if (isBaseValid && isExtentValid)
+    return selection;
+
+  VisibleSelectionTemplate<Strategy> newSelection;
+  if (isBaseValid) {
+    newSelection.setWithoutValidation(base, base);
+  } else if (isExtentValid) {
+    newSelection.setWithoutValidation(extent, extent);
+  }
+  return newSelection;
+}
+
 #ifndef NDEBUG
 
 void FrameSelection::showTreeForThis() const {
   selection().showTreeForThis();
 }
 
 #endif
 
 DEFINE_TRACE(FrameSelection) {
-  visitor->trace(m_document);
   visitor->trace(m_frame);
   visitor->trace(m_pendingSelection);
   visitor->trace(m_selectionEditor);
   visitor->trace(m_typingStyle);
   visitor->trace(m_frameCaret);
+  SynchronousMutationObserver::trace(visitor);
 }
 
 void FrameSelection::scheduleVisualUpdate() const {
   if (Page* page = m_frame->page())
     page->animator().scheduleVisualUpdate(m_frame->localFrameRoot());
 }
 
 bool FrameSelection::selectWordAroundPosition(const VisiblePosition& position) {
   static const EWordSide wordSideList[2] = {RightWordIfOnBoundary,
                                             LeftWordIfOnBoundary};
   for (EWordSide wordSide : wordSideList) {
     VisiblePosition start = startOfWord(position, wordSide);
     VisiblePosition end = endOfWord(position, wordSide);
     String text =
         plainText(EphemeralRange(start.deepEquivalent(), end.deepEquivalent()));
     if (!text.isEmpty() && !isSeparator(text.characterStartingAt(0))) {
       setSelection(SelectionInDOMTree::Builder()
                        .collapse(start.toPositionWithAffinity())
                        .extend(end.deepEquivalent())
                        .build(),
-                   CloseTyping | ClearTypingStyle,
-                   CursorAlignOnScroll::IfNeeded, WordGranularity);
+                   WordGranularity);
       return true;
     }
   }
 
   return false;
 }
 
 GranularityStrategy* FrameSelection::granularityStrategy() {
   // We do lazy initalization for m_granularityStrategy, because if we
   // initialize it right in the constructor - the correct settings may not be
@@ skipping 36 matching lines @@
       SelectionInDOMTree::Builder()
           .setBaseAndExtentDeprecated(basePosition.deepEquivalent(),
                                       extentPosition.deepEquivalent())
           .setAffinity(basePosition.affinity())
           .setGranularity(granularity)
           .build());
 
   if (newSelection.isNone())
     return;
 
-  setSelection(newSelection, CloseTyping | ClearTypingStyle,
-               CursorAlignOnScroll::IfNeeded, granularity);
+  setSelection(newSelection, granularity);
 }
 
 void FrameSelection::updateIfNeeded() {
   DCHECK(!m_frame->document()->needsLayoutTreeUpdate());
   m_selectionEditor->updateIfNeeded();
 }
 
 void FrameSelection::setCaretVisible(bool caretIsVisible) {
   m_frameCaret->setCaretVisibility(caretIsVisible ? CaretVisibility::Visible
                                                   : CaretVisibility::Hidden);
@@ skipping 32 matching lines @@
 }
 
 void showTree(const blink::FrameSelection* sel) {
   if (sel)
     sel->showTreeForThis();
   else
     LOG(INFO) << "Cannot showTree for <null> FrameSelection.";
 }
 
 #endif