Prune layout update calls from Editor::*appliedEditing

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 898 matching lines @@
 static void DispatchEditableContentChangedEvents(Element* start_root,
                                                  Element* end_root) {
   if (start_root)
     start_root->DispatchEvent(
         Event::Create(EventTypeNames::webkitEditableContentChanged));
   if (end_root && end_root != start_root)
     end_root->DispatchEvent(
         Event::Create(EventTypeNames::webkitEditableContentChanged));
 }
 
-static VisibleSelection CorrectedVisibleSelection(
-    const VisibleSelection& passed_selection) {
+static SelectionInDOMTree CorrectedSelectionAfterCommand(
+    const VisibleSelection& passed_selection,
+    Document* document) {
   if (!passed_selection.Base().IsConnected() ||
-      !passed_selection.Extent().IsConnected())
-    return VisibleSelection();
-  DCHECK(!passed_selection.Base().GetDocument()->NeedsLayoutTreeUpdate());
-  return CreateVisibleSelection(passed_selection.AsSelection());
+      !passed_selection.Extent().IsConnected() ||
+      passed_selection.Base().GetDocument() != document ||
+      passed_selection.Base().GetDocument() !=
+          passed_selection.Extent().GetDocument())
+    return SelectionInDOMTree();
+  return passed_selection.AsSelection();
 }
 
 void Editor::AppliedEditing(CompositeEditCommand* cmd) {
   DCHECK(!cmd->IsCommandGroupWrapper());
   EventQueueScope scope;
 
   // Request spell checking before any further DOM change.
   GetSpellChecker().MarkMisspellingsAfterApplyingCommand(*cmd);
 
   UndoStep* undo_step = cmd->GetUndoStep();
   DCHECK(undo_step);
   DispatchEditableContentChangedEvents(undo_step->StartingRootEditableElement(),
                                        undo_step->EndingRootEditableElement());
   // TODO(chongz): Filter empty InputType after spec is finalized.
   DispatchInputEventEditableContentChanged(
       undo_step->StartingRootEditableElement(),
       undo_step->EndingRootEditableElement(), cmd->GetInputType(),
       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.
-  GetFrame().GetDocument()->UpdateStyleAndLayoutIgnorePendingStylesheets();
-
-  const VisibleSelection& new_selection =
-      CorrectedVisibleSelection(cmd->EndingSelection());
+  const SelectionInDOMTree& new_selection = CorrectedSelectionAfterCommand(
+      cmd->EndingSelection(), GetFrame().GetDocument());
 
   // Don't clear the typing style with this selection change. We do those things
   // elsewhere if necessary.
-  ChangeSelectionAfterCommand(new_selection.AsSelection(), 0);
+  ChangeSelectionAfterCommand(new_selection, 0);
 
   if (!cmd->PreservesTypingStyle())
     ClearTypingStyle();
 
   // Command will be equal to last edit command only in the case of typing
   if (last_edit_command_.Get() == cmd) {
     DCHECK(cmd->IsTypingCommand());
   } else if (last_edit_command_ && last_edit_command_->IsDragAndDropCommand() &&
              (cmd->GetInputType() == InputEvent::InputType::kDeleteByDrag ||
               cmd->GetInputType() == InputEvent::InputType::kInsertFromDrop)) {
     // Only register undo entry when combined with other commands.
     if (!last_edit_command_->GetUndoStep())
       undo_stack_->RegisterUndoStep(last_edit_command_->EnsureUndoStep());
     last_edit_command_->AppendCommandToUndoStep(cmd);
   } else {
     // Only register a new undo command if the command passed in is
     // different from the last command
     last_edit_command_ = cmd;
     undo_stack_->RegisterUndoStep(last_edit_command_->EnsureUndoStep());
   }
 
-  RespondToChangedContents(new_selection.Start());
+  RespondToChangedContents(new_selection.Base());
 }
 
 void Editor::UnappliedEditing(UndoStep* cmd) {
   EventQueueScope scope;
 
   DispatchEditableContentChangedEvents(cmd->StartingRootEditableElement(),
                                        cmd->EndingRootEditableElement());
   DispatchInputEventEditableContentChanged(
       cmd->StartingRootEditableElement(), cmd->EndingRootEditableElement(),
       InputEvent::InputType::kHistoryUndo, g_null_atom,
       InputEvent::EventIsComposing::kNotComposing);
 
-  // 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.
-  GetFrame().GetDocument()->UpdateStyleAndLayoutIgnorePendingStylesheets();
-
-  const VisibleSelection& new_selection =
-      CorrectedVisibleSelection(cmd->StartingSelection());
-  DCHECK(new_selection.IsValidFor(*GetFrame().GetDocument())) << new_selection;
+  const SelectionInDOMTree& new_selection = CorrectedSelectionAfterCommand(
+      cmd->StartingSelection(), GetFrame().GetDocument());
   ChangeSelectionAfterCommand(
-      new_selection.AsSelection(),
+      new_selection,
       FrameSelection::kCloseTyping | FrameSelection::kClearTypingStyle);
 
   last_edit_command_ = nullptr;
   undo_stack_->RegisterRedoStep(cmd);
-  RespondToChangedContents(new_selection.Start());
+  RespondToChangedContents(new_selection.Base());
 }
 
 void Editor::ReappliedEditing(UndoStep* cmd) {
   EventQueueScope scope;
 
   DispatchEditableContentChangedEvents(cmd->StartingRootEditableElement(),
                                        cmd->EndingRootEditableElement());
   DispatchInputEventEditableContentChanged(
       cmd->StartingRootEditableElement(), cmd->EndingRootEditableElement(),
       InputEvent::InputType::kHistoryRedo, g_null_atom,
       InputEvent::EventIsComposing::kNotComposing);
 
-  // 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.
-  GetFrame().GetDocument()->UpdateStyleAndLayoutIgnorePendingStylesheets();
-  const VisibleSelection& new_selection =
-      CorrectedVisibleSelection(cmd->EndingSelection());
-  DCHECK(new_selection.IsValidFor(*GetFrame().GetDocument())) << new_selection;
+  const SelectionInDOMTree& new_selection = CorrectedSelectionAfterCommand(
+      cmd->EndingSelection(), GetFrame().GetDocument());
   ChangeSelectionAfterCommand(
-      new_selection.AsSelection(),
+      new_selection,
       FrameSelection::kCloseTyping | FrameSelection::kClearTypingStyle);
 
   last_edit_command_ = nullptr;
   undo_stack_->RegisterUndoStep(cmd);
-  RespondToChangedContents(new_selection.Start());
+  RespondToChangedContents(new_selection.Base());
 }
 
 Editor* Editor::Create(LocalFrame& frame) {
   return new Editor(frame);
 }
 
 Editor::Editor(LocalFrame& frame)
     : frame_(&frame),
       undo_stack_(UndoStack::Create()),
       prevent_reveal_selection_(0),
@@ skipping 792 matching lines @@
 
 DEFINE_TRACE(Editor) {
   visitor->Trace(frame_);
   visitor->Trace(last_edit_command_);
   visitor->Trace(undo_stack_);
   visitor->Trace(mark_);
   visitor->Trace(typing_style_);
 }
 
 }  // namespace blink