Revert of 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 92 matching lines @@
                 frame.page()->focusController().focusedFrame() == frame),
       m_frameCaret(new FrameCaret(frame, *m_selectionEditor)) {}
 
 FrameSelection::~FrameSelection() {}
 
 const DisplayItemClient& FrameSelection::caretDisplayItemClientForTesting()
     const {
   return m_frameCaret->displayItemClient();
 }
 
-Document& FrameSelection::document() const {
+const Document& FrameSelection::document() const {
   DCHECK(lifecycleContext());
   return *lifecycleContext();
 }
 
-bool FrameSelection::isHandleVisible() const {
-  return selectionInDOMTree().isHandleVisible();
+Document& FrameSelection::document() {
+  DCHECK(lifecycleContext());
+  return *lifecycleContext();
 }
 
-// TODO(yosin): We should replace |visibleSelection<EditingStrategy>()| to
-// |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>();
 }
 
-// TODO(yosin): We should replace
-// |visibleSelection<EditingInFlatTreeStrategy>()| with
-// |computeVisibleSelectionInFlatTree()|.
 template <>
 const VisibleSelectionInFlatTree&
 FrameSelection::visibleSelection<EditingInFlatTreeStrategy>() const {
   return m_selectionEditor->visibleSelection<EditingInFlatTreeStrategy>();
 }
 
-const VisibleSelection& FrameSelection::computeVisibleSelectionInDOMTree()
-    const {
-  return m_selectionEditor->computeVisibleSelectionInDOMTree();
-}
-
-const VisibleSelectionInFlatTree&
-FrameSelection::computeVisibleSelectionInFlatTree() const {
-  return m_selectionEditor->computeVisibleSelectionInFlatTree();
-}
-
-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 {
-  // TODO(yosin): We should hoist updateStyleAndLayoutIgnorePendingStylesheets
-  // to caller. See http://crbug.com/590369 for more details.
-  document().updateStyleAndLayoutIgnorePendingStylesheets();
-  return computeVisibleSelectionInDOMTree();
+  return visibleSelection<EditingStrategy>();
 }
 
 const VisibleSelectionInFlatTree& FrameSelection::selectionInFlatTree() const {
   return visibleSelection<EditingInFlatTreeStrategy>();
 }
 
 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());
   builder.setIsHandleVisible(true);
   if (position.isNotNull())
     builder.collapse(position.toPositionWithAffinity());
   setSelection(builder.build(), CloseTyping | ClearTypingStyle | UserTriggered);
 }
 
-void FrameSelection::setSelection(const SelectionInDOMTree& passedSelection,
-                                  SetSelectionOptions options,
-                                  CursorAlignOnScroll align,
-                                  TextGranularity granularity) {
+template <typename Strategy>
+void FrameSelection::setSelectionAlgorithm(
+    const VisibleSelectionTemplate<Strategy>& newSelection,
+    HandleVisibility handleVisibility,
+    SetSelectionOptions options,
+    CursorAlignOnScroll align,
+    TextGranularity granularity) {
   DCHECK(isAvailable());
-  passedSelection.assertValidFor(document());
-
-  SelectionInDOMTree::Builder builder(passedSelection);
-  if (shouldAlwaysUseDirectionalSelection(m_frame))
-    builder.setIsDirectional(true);
-  SelectionInDOMTree newSelection = builder.build();
+  DCHECK(newSelection.isValidFor(document()));
+  const Document& currentDocument = document();
   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)
     m_frame->editor().clearTypingStyle();
 
-  const SelectionInDOMTree oldSelectionInDOMTree =
-      m_selectionEditor->selectionInDOMTree();
-  if (oldSelectionInDOMTree == newSelection)
+  if (m_selectionEditor->visibleSelection<Strategy>() == s &&
+      m_handleVisibility == handleVisibility) {
+    // Even if selection was not changed, selection offsets may have been
+    // changed.
+    notifyLayoutObjectOfSelectionChange(userTriggered);
     return;
-  m_selectionEditor->setSelection(newSelection);
+  }
+
+  const VisibleSelectionTemplate<Strategy> oldSelection =
+      visibleSelection<Strategy>();
+  const Position& oldSelectionStart = selection().start();
+
+  m_handleVisibility = handleVisibility;
+  m_selectionEditor->setVisibleSelection(s, options);
   scheduleVisualUpdateForPaintInvalidationIfNeeded();
 
-  // TODO(yosin): The use of updateStyleAndLayoutIgnorePendingStylesheets
-  // needs to be audited. see http://crbug.com/590369 for more details.
-  document().updateStyleAndLayoutIgnorePendingStylesheets();
-
-  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 (!computeVisibleSelectionInDOMTree().isNone() &&
-      !(options & DoNotSetFocus)) {
+  if (!s.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)) {
     m_frameCaret->stopCaretBlinkTimer();
     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>())
+    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(editing-dev): 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),
+               newSelection.isHandleVisible() ? HandleVisibility::Visible
+                                              : HandleVisibility::NotVisible,
+               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) {
-  newSelection.assertValidFor(document());
-  SelectionInDOMTree::Builder builder;
-  builder.setAffinity(newSelection.affinity())
-      .setBaseAndExtent(toPositionInDOMTree(newSelection.base()),
-                        toPositionInDOMTree(newSelection.extent()))
-      .setGranularity(newSelection.granularity())
-      .setIsDirectional(newSelection.isDirectional())
-      .setIsHandleVisible(newSelection.isHandleVisible())
-      .setHasTrailingWhitespace(newSelection.hasTrailingWhitespace());
-  return setSelection(builder.build(), options, align, 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),
+               newSelection.isHandleVisible() ? HandleVisibility::Visible
+                                              : HandleVisibility::NotVisible,
+               options, align, granularity);
 }
 
 void FrameSelection::setSelection(const VisibleSelection& newSelection,
                                   HandleVisibility handleVisibility,
                                   SetSelectionOptions options,
                                   CursorAlignOnScroll align,
                                   TextGranularity granularity) {
-  setSelection(
-      SelectionInDOMTree::Builder(newSelection.asSelection())
-          .setIsHandleVisible(handleVisibility == HandleVisibility::Visible)
-          .build(),
-      options, align, granularity);
+  setSelectionAlgorithm<EditingStrategy>(newSelection, handleVisibility,
+                                         options, align, granularity);
 }
 
 void FrameSelection::setSelection(const VisibleSelection& newSelection,
                                   SetSelectionOptions options) {
-  setSelection(newSelection.asSelection(), options);
+  setSelection(newSelection, HandleVisibility::NotVisible, options);
 }
 
 void FrameSelection::setSelection(
     const VisibleSelectionInFlatTree& newSelection,
     HandleVisibility handleVisibility,
     SetSelectionOptions options,
     CursorAlignOnScroll align,
     TextGranularity granularity) {
-  setSelection(
-      SelectionInFlatTree::Builder(newSelection.asSelection())
-          .setIsHandleVisible(handleVisibility == HandleVisibility::Visible)
-          .build(),
-      options, align, granularity);
+  setSelectionAlgorithm<EditingInFlatTreeStrategy>(
+      newSelection, handleVisibility, options, align, granularity);
 }
 
 void FrameSelection::setSelection(
     const VisibleSelectionInFlatTree& newSelection,
     SetSelectionOptions options) {
-  setSelection(newSelection.asSelection(), options);
+  setSelection(newSelection, HandleVisibility::NotVisible, options);
 }
 
-// TODO(yosin): We should move |computePositionForChildrenRemoval()| to
-// "SelectionEditor.cpp" since it used only in
-// |SelectionEditor::nodeChildrenWillBeRemoved()|.
+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;
 }
 
 void FrameSelection::nodeChildrenWillBeRemoved(ContainerNode& container) {
-  if (!container.inActiveDocument())
+  if (isNone() || !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);
+  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()));
+}
+
+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);
+
   // TODO(yosin): We should move to call |TypingCommand::closeTyping()| to
   // |Editor| class.
   if (!document().isRunningExecCommand())
     TypingCommand::closeTyping(m_frame);
 }
 
-// TODO(yosin): We should move |SelectionEditor::nodeChildrenWillBeRemoved()|
-// to "SelectionEditor.cpp".
-void SelectionEditor::nodeChildrenWillBeRemoved(ContainerNode& container) {
-  if (m_selection.isNone())
-    return;
-  const Position oldBase = m_selection.m_base;
-  const Position oldExtent = m_selection.m_extent;
-  const Position& newBase =
-      computePositionForChildrenRemoval(oldBase, container);
-  const Position& newExtent =
-      computePositionForChildrenRemoval(oldExtent, container);
-  if (newBase == oldBase && newExtent == oldExtent)
-    return;
-  m_selection = SelectionInDOMTree::Builder()
-                    .setBaseAndExtent(newBase, newExtent)
-                    .build();
-  markCacheDirty();
-}
-
-// TODO(yosin): We should move |computePositionForChildrenRemoval()| with
-// |nodeWillBeRemoved()| to "SelectionEditor.cpp".
-static Position computePositionForNodeRemoval(const Position& position,
-                                              Node& nodeToBeRemoved) {
-  Position result = position;
-  // TODO(yosin): We should rename |updatePositionForNodeRemoval()|
-  // to |computePositionForNodeRemoval()| to avoid using output parameter.
-  updatePositionForNodeRemoval(result, nodeToBeRemoved);
-  return result;
-}
-
-// TODO(yosin): We should move |nodeWillBeRemoved()| to
-// "SelectionEditor.cpp".
-void SelectionEditor::nodeWillBeRemoved(Node& nodeToBeRemoved) {
-  if (m_selection.isNone())
-    return;
-  const Position oldBase = m_selection.m_base;
-  const Position oldExtent = m_selection.m_extent;
-  const Position& newBase =
-      computePositionForNodeRemoval(oldBase, nodeToBeRemoved);
-  const Position& newExtent =
-      computePositionForNodeRemoval(oldExtent, nodeToBeRemoved);
-  if (newBase == oldBase && newExtent == oldExtent)
-    return;
-  m_selection = SelectionInDOMTree::Builder()
-                    .setBaseAndExtent(newBase, newExtent)
-                    .build();
-  markCacheDirty();
-}
-
-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);
-}
-
-// TODO(yosin): We should move |updatePositionAfterAdoptingTextReplacement()|
-// to "SelectionEditor.cpp" since it used only in
-// |SelectionEditor::didUpdateCharacterData()|.
 static Position updatePositionAfterAdoptingTextReplacement(
     const Position& position,
     CharacterData* node,
     unsigned offset,
     unsigned oldLength,
     unsigned newLength) {
-  if (position.anchorNode() != node)
+  if (!position.anchorNode() || position.anchorNode() != node ||
+      !position.isOffsetInAnchor())
     return position;
 
-  if (position.isBeforeAnchor()) {
-    return updatePositionAfterAdoptingTextReplacement(
-        Position(node, 0), node, offset, oldLength, newLength);
-  }
-  if (position.isAfterAnchor()) {
-    return updatePositionAfterAdoptingTextReplacement(
-        Position(node, oldLength), node, offset, oldLength, newLength);
-  }
-
   // 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();
 
-  return Position(node, positionOffset);
+  // CharacterNode in VisibleSelection must be Text node, because Comment
+  // and ProcessingInstruction node aren't visible.
+  return Position(toText(node), positionOffset);
 }
 
-// TODO(yosin): We should move |didUpdateCharacterData()| to
-// "SelectionEditor.cpp".
-void SelectionEditor::didUpdateCharacterData(CharacterData* node,
-                                             unsigned offset,
-                                             unsigned oldLength,
-                                             unsigned newLength) {
+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 (m_selection.isNone() || !node || !node->isConnected()) {
-    didFinishDOMMutation();
+  if (isNone() || !node || !node->isConnected())
     return;
-  }
-  const Position& newBase = updatePositionAfterAdoptingTextReplacement(
-      m_selection.m_base, node, offset, oldLength, newLength);
-  const Position& newExtent = updatePositionAfterAdoptingTextReplacement(
-      m_selection.m_extent, node, offset, oldLength, newLength);
-  didFinishTextChange(newBase, newExtent);
+
+  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);
 }
 
-// TODO(yosin): We should move |updatePostionAfterAdoptingTextNodesMerged()|
-// to "SelectionEditor.cpp" since it used only in
-// |SelectionEditor::didMergeTextNodes()|.
-// TODO(yosin): We should introduce |Position(const Text&, int)| to avoid
-// |const_cast<Text*>|.
 static Position updatePostionAfterAdoptingTextNodesMerged(
     const Position& position,
-    const Text& mergedNode,
-    const NodeWithIndex& nodeToBeRemovedWithIndex,
-    unsigned oldLength) {
-  Node* const anchorNode = position.anchorNode();
-  const Node& nodeToBeRemoved = nodeToBeRemovedWithIndex.node();
-  switch (position.anchorType()) {
-    case PositionAnchorType::BeforeChildren:
-    case PositionAnchorType::AfterChildren:
-      return position;
-    case PositionAnchorType::BeforeAnchor:
-      if (anchorNode == nodeToBeRemoved)
-        return Position(const_cast<Text*>(&mergedNode), mergedNode.length());
-      return position;
-    case PositionAnchorType::AfterAnchor:
-      if (anchorNode == nodeToBeRemoved)
-        return Position(const_cast<Text*>(&mergedNode), mergedNode.length());
-      if (anchorNode == mergedNode)
-        return Position(const_cast<Text*>(&mergedNode), oldLength);
-      return position;
-    case PositionAnchorType::OffsetInAnchor: {
-      const int offset = position.offsetInContainerNode();
-      if (anchorNode == nodeToBeRemoved)
-        return Position(const_cast<Text*>(&mergedNode), oldLength + offset);
-      if (anchorNode == nodeToBeRemoved.parentNode() &&
-          offset == nodeToBeRemovedWithIndex.index()) {
-        return Position(const_cast<Text*>(&mergedNode), oldLength);
-      }
-      return position;
-    }
-  }
-  NOTREACHED() << 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;
 }
 
-// TODO(yosin): We should move |SelectionEditor::didMergeTextNodes()| to
-// "SelectionEditor.cpp".
-void SelectionEditor::didMergeTextNodes(
+void FrameSelection::didMergeTextNodes(
     const Text& mergedNode,
     const NodeWithIndex& nodeToBeRemovedWithIndex,
-    unsigned oldLength) {
-  if (m_selection.isNone()) {
-    didFinishDOMMutation();
+    unsigned offset) {
+  const Text& oldNode = toText(nodeToBeRemovedWithIndex.node());
+  if (isNone() || !oldNode.isConnected())
     return;
-  }
-  const Position& newBase = updatePostionAfterAdoptingTextNodesMerged(
-      m_selection.m_base, mergedNode, nodeToBeRemovedWithIndex, oldLength);
-  const Position& newExtent = updatePostionAfterAdoptingTextNodesMerged(
-      m_selection.m_extent, mergedNode, nodeToBeRemovedWithIndex, oldLength);
-  didFinishTextChange(newBase, newExtent);
+  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);
 }
 
-// TODO(yosin): We should move |updatePostionAfterAdoptingTextNodeSplit()|
-// to "SelectionEditor.cpp" since it used only in
-// |SelectionEditor::didSplitTextNode()|.
 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);
 }
 
-// TODO(yosin): We should move |SelectionEditor::didSplitTextNode()| to
-// "SelectionEditor.cpp".
-void SelectionEditor::didSplitTextNode(const Text& oldNode) {
-  if (m_selection.isNone() || !oldNode.isConnected()) {
-    didFinishDOMMutation();
+void FrameSelection::didSplitTextNode(const Text& oldNode) {
+  if (isNone() || !oldNode.isConnected())
     return;
-  }
-  const Position& newBase =
-      updatePostionAfterAdoptingTextNodeSplit(m_selection.m_base, oldNode);
-  const Position& newExtent =
-      updatePostionAfterAdoptingTextNodeSplit(m_selection.m_extent, oldNode);
-  didFinishTextChange(newBase, newExtent);
+  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())
+    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 86 matching lines @@
 }
 
 void FrameSelection::contextDestroyed(Document* document) {
   m_granularity = CharacterGranularity;
 
   LayoutViewItem view = m_frame->contentLayoutItem();
   if (!view.isNull())
     view.clearSelection();
 
   m_frame->editor().clearTypingStyle();
+  m_selectionEditor->documentDetached(*document);
 }
 
 void FrameSelection::clearPreviousCaretVisualRect(const LayoutBlock& block) {
   m_frameCaret->clearPreviousVisualRect(block);
 }
 
 void FrameSelection::layoutBlockWillBeDestroyed(const LayoutBlock& block) {
   m_frameCaret->layoutBlockWillBeDestroyed(block);
 }
 
 void FrameSelection::updateStyleAndLayoutIfNeeded() {
   m_frameCaret->updateStyleAndLayoutIfNeeded();
 }
 
 void FrameSelection::invalidatePaintIfNeeded(
     const LayoutBlock& block,
     const PaintInvalidatorContext& context,
     PaintInvalidationReason reason) {
   m_frameCaret->invalidatePaintIfNeeded(block, context, reason);
 }
 
 bool FrameSelection::shouldPaintCaret(const LayoutBlock& block) const {
-  DCHECK_GE(document().lifecycle().state(), DocumentLifecycle::LayoutClean);
+  DCHECK(selection().isValidFor(document()));
+
   bool result = m_frameCaret->shouldPaintCaret(block);
   DCHECK(!result || (isCaret() && hasEditableStyle()));
   return result;
 }
 
 IntRect FrameSelection::absoluteCaretBounds() {
   DCHECK(selection().isValidFor(*m_frame->document()));
   return m_frameCaret->absoluteCaretBounds();
 }
 
@@ skipping 299 matching lines @@
 
 void FrameSelection::commitAppearanceIfNeeded(LayoutView& layoutView) {
   return m_pendingSelection->commit(layoutView);
 }
 
 void FrameSelection::didLayout() {
   updateAppearance();
 }
 
 void FrameSelection::updateAppearance() {
-  DCHECK(!m_frame->contentLayoutItem().isNull());
-  m_frameCaret->scheduleVisualUpdateForPaintInvalidationIfNeeded();
+  m_frameCaret->updateAppearance();
+
+  if (m_frame->contentLayoutItem().isNull())
+    return;
   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 182 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 {
@@ skipping 90 matching lines @@
                    FrameSelection::DoNotClearStrategy | UserTriggered,
                CursorAlignOnScroll::IfNeeded, CharacterGranularity);
 }
 
 // TODO(yosin): We should make |FrameSelection::moveRangeSelection()| to take
 // two |IntPoint| instead of two |VisiblePosition| like
 // |moveRangeSelectionExtent()|.
 void FrameSelection::moveRangeSelection(const VisiblePosition& basePosition,
                                         const VisiblePosition& extentPosition,
                                         TextGranularity granularity) {
-  SelectionInDOMTree newSelection =
+  VisibleSelection newSelection = createVisibleSelection(
       SelectionInDOMTree::Builder()
           .setBaseAndExtentDeprecated(basePosition.deepEquivalent(),
                                       extentPosition.deepEquivalent())
           .setAffinity(basePosition.affinity())
           .setGranularity(granularity)
-          .setIsHandleVisible(isHandleVisible())
-          .build();
+          .build());
 
   if (newSelection.isNone())
     return;
 
-  setSelection(newSelection, CloseTyping | ClearTypingStyle,
+  setSelection(newSelection, m_handleVisibility, CloseTyping | ClearTypingStyle,
                CursorAlignOnScroll::IfNeeded, granularity);
 }
 
 void FrameSelection::updateIfNeeded() {
   DCHECK(!m_frame->document()->needsLayoutTreeUpdate());
   m_selectionEditor->updateIfNeeded();
 }
 
 void FrameSelection::setCaretVisible(bool caretIsVisible) {
   m_frameCaret->setCaretVisibility(caretIsVisible ? CaretVisibility::Visible
@@ skipping 29 matching lines @@
 }
 
 void showTree(const blink::FrameSelection* sel) {
   if (sel)
     sel->showTreeForThis();
   else
     LOG(INFO) << "Cannot showTree for <null> FrameSelection.";
 }
 
 #endif