Make Editor::changeSelectionAfterCommand take SelectionInDOMTree

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
@@ skipping 848 matching lines @@
 static void dispatchEditableContentChangedEvents(Element* startRoot,
                                                  Element* endRoot) {
   if (startRoot)
     startRoot->dispatchEvent(
         Event::create(EventTypeNames::webkitEditableContentChanged));
   if (endRoot && endRoot != startRoot)
     endRoot->dispatchEvent(
         Event::create(EventTypeNames::webkitEditableContentChanged));
 }
 
+static VisibleSelection correctedVisibleSelection(

[yosin_UTC9, 2017/03/01 01:20:39]

It seems you need to rebase. Patch[1] did this change.

[1] http://crrev.co/2709973005: Get rid of useless function
VisibleSelection::updateIfNeeded()

[Xiaocheng, 2017/03/01 01:41:23]

No need to rebase.

This patch removes this function before Editor::appliedEditing so that it can
also be called there.

[yosin_UTC9, 2017/03/01 01:44:01]

Oops. I see.

+    const VisibleSelection& passedSelection) {
+  if (!passedSelection.base().isConnected() ||
+      !passedSelection.extent().isConnected())
+    return VisibleSelection();
+  DCHECK(!passedSelection.base().document()->needsLayoutTreeUpdate());
+  return createVisibleSelection(passedSelection.asSelection());
+}
+
 void Editor::appliedEditing(CompositeEditCommand* cmd) {
   DCHECK(!cmd->isCommandGroupWrapper());
   EventQueueScope scope;
 
   // Request spell checking before any further DOM change.
   spellChecker().markMisspellingsAfterApplyingCommand(*cmd);
 
   UndoStep* undoStep = cmd->undoStep();
   DCHECK(undoStep);
   dispatchEditableContentChangedEvents(undoStep->startingRootEditableElement(),
                                        undoStep->endingRootEditableElement());
   // TODO(chongz): Filter empty InputType after spec is finalized.
   dispatchInputEventEditableContentChanged(
       undoStep->startingRootEditableElement(),
       undoStep->endingRootEditableElement(), cmd->inputType(),
       cmd->textDataForInputEvent(), isComposingFromCommand(cmd));
 
   // TODO(editing-dev): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   // The clean layout is consumed by |mostBackwardCaretPosition|, called through
   // |changeSelectionAfterCommand|. In the long term, we should postpone visible
   // selection canonicalization so that selection update does not need layout.
   frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
-  VisibleSelection newSelection(cmd->endingSelection());
+  const VisibleSelection& newSelection =
+      correctedVisibleSelection(cmd->endingSelection());
 
   // Don't clear the typing style with this selection change. We do those things
   // elsewhere if necessary.
-  changeSelectionAfterCommand(newSelection, 0);
+  changeSelectionAfterCommand(newSelection.asSelection(), 0);
 
   if (!cmd->preservesTypingStyle())
     clearTypingStyle();
 
   // Command will be equal to last edit command only in the case of typing
   if (m_lastEditCommand.get() == cmd) {
     DCHECK(cmd->isTypingCommand());
   } else if (m_lastEditCommand && m_lastEditCommand->isDragAndDropCommand() &&
              (cmd->inputType() == InputEvent::InputType::DeleteByDrag ||
               cmd->inputType() == InputEvent::InputType::InsertFromDrop)) {
     // Only register undo entry when combined with other commands.
     if (!m_lastEditCommand->undoStep())
       m_undoStack->registerUndoStep(m_lastEditCommand->ensureUndoStep());
     m_lastEditCommand->appendCommandToUndoStep(cmd);
   } else {
     // Only register a new undo command if the command passed in is
     // different from the last command
     m_lastEditCommand = cmd;
     m_undoStack->registerUndoStep(m_lastEditCommand->ensureUndoStep());
   }
 
   respondToChangedContents(newSelection.start());
 }
 
-static VisibleSelection correctedVisibleSelection(
-    const VisibleSelection& passedSelection) {
-  if (!passedSelection.base().isConnected() ||
-      !passedSelection.extent().isConnected())
-    return VisibleSelection();
-  DCHECK(!passedSelection.base().document()->needsLayoutTreeUpdate());
-  return createVisibleSelection(passedSelection.asSelection());
-}
-
 void Editor::unappliedEditing(UndoStep* cmd) {
   EventQueueScope scope;
 
   dispatchEditableContentChangedEvents(cmd->startingRootEditableElement(),
                                        cmd->endingRootEditableElement());
   dispatchInputEventEditableContentChanged(
       cmd->startingRootEditableElement(), cmd->endingRootEditableElement(),
       InputEvent::InputType::HistoryUndo, nullAtom,
       InputEvent::EventIsComposing::NotComposing);
 
   // TODO(editing-dev): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   // In the long term, we should stop editing commands from storing
   // VisibleSelections as starting and ending selections.
   frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   const VisibleSelection& newSelection =
       correctedVisibleSelection(cmd->startingSelection());
   DCHECK(newSelection.isValidFor(*frame().document())) << newSelection;
-  if (!newSelection.isNone()) {
-    changeSelectionAfterCommand(
-        newSelection,
-        FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle);
-  }
+  changeSelectionAfterCommand(
+      newSelection.asSelection(),
+      FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle);
 
   m_lastEditCommand = nullptr;
   m_undoStack->registerRedoStep(cmd);
   respondToChangedContents(newSelection.start());
 }
 
 void Editor::reappliedEditing(UndoStep* cmd) {
   EventQueueScope scope;
 
   dispatchEditableContentChangedEvents(cmd->startingRootEditableElement(),
                                        cmd->endingRootEditableElement());
   dispatchInputEventEditableContentChanged(
       cmd->startingRootEditableElement(), cmd->endingRootEditableElement(),
       InputEvent::InputType::HistoryRedo, nullAtom,
       InputEvent::EventIsComposing::NotComposing);
 
   // TODO(editing-dev): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   // In the long term, we should stop editing commands from storing
   // VisibleSelections as starting and ending selections.
   frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
   const VisibleSelection& newSelection =
       correctedVisibleSelection(cmd->endingSelection());
   DCHECK(newSelection.isValidFor(*frame().document())) << newSelection;
-  if (!newSelection.isNone()) {
-    changeSelectionAfterCommand(
-        newSelection,
-        FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle);
-  }
+  changeSelectionAfterCommand(
+      newSelection.asSelection(),
+      FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle);
 
   m_lastEditCommand = nullptr;
   m_undoStack->registerUndoStep(cmd);
   respondToChangedContents(newSelection.start());
 }
 
 Editor* Editor::create(LocalFrame& frame) {
   return new Editor(frame);
 }
 
@@ skipping 411 matching lines @@
   if (m_shouldStartNewKillRingSequence)
     killRing().startNewSequence();
 
   DCHECK(!frame().document()->needsLayoutTreeUpdate());
   String text = plainText(range);
   killRing().append(text);
   m_shouldStartNewKillRingSequence = false;
 }
 
 void Editor::changeSelectionAfterCommand(
-    const VisibleSelection& newSelection,
+    const SelectionInDOMTree& newSelection,
     FrameSelection::SetSelectionOptions options) {
-  // If the new selection is orphaned, then don't update the selection.
-  if (newSelection.start().isOrphan() || newSelection.end().isOrphan())
+  if (newSelection.isNone())
     return;
 
   // See <rdar://problem/5729315> Some shouldChangeSelectedDOMRange contain
   // Ranges for selections that are no longer valid
   bool selectionDidNotChangeDOMPosition =
-      newSelection ==
-      frame().selection().computeVisibleSelectionInDOMTreeDeprecated();
+      newSelection == frame().selection().selectionInDOMTree();
   frame().selection().setSelection(newSelection, options);
 
   // Some editing operations change the selection visually without affecting its
   // position within the DOM. For example when you press return in the following
   // (the caret is marked by ^):
   // <div contentEditable="true"><div>^Hello</div></div>
   // WebCore inserts <div><br></div> *before* the current block, which correctly
   // moves the paragraph down but which doesn't change the caret's DOM position
   // (["hello", 0]). In these situations the above FrameSelection::setSelection
   // call does not call EditorClient::respondToChangedSelection(), which, on the
@@ skipping 327 matching lines @@
 
 DEFINE_TRACE(Editor) {
   visitor->trace(m_frame);
   visitor->trace(m_lastEditCommand);
   visitor->trace(m_undoStack);
   visitor->trace(m_mark);
   visitor->trace(m_typingStyle);
 }
 
 }  // namespace blink