Commands preserve handles

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 899 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 SelectionInDOMTree CorrectedSelectionAfterCommand(

[yosin_UTC9, 2017/05/23 01:46:36]

Is it better to pass FrameSelection instead of Document and
bool/HandleVisibility to this function?

SelectionInDOMTree CorrectedSelectionAfterCommand(const VS& passed, const
FrameSelection& frameSelection) {
  if (!passed.IsValidFor(frameSeleciton.GetDocument())
    return SelectionInDOMTree();
  return
SelectionInDOMTree::Builder(passd.AsSelection()).SetIsHandleVisible(frameSeleciton.IsHandleVisible());
}

xiaochengh@, WDYT?

     const VisibleSelection& passed_selection,
-    Document* document) {
+    Document* document,
+    bool is_handle_visible) {

[yosin_UTC9, 2017/05/23 01:46:36]

We should use |HandleVisibility|.

   if (!passed_selection.Base().IsConnected() ||
       !passed_selection.Extent().IsConnected() ||
       passed_selection.Base().GetDocument() != document ||
       passed_selection.Base().GetDocument() !=
           passed_selection.Extent().GetDocument())
     return SelectionInDOMTree();
-  return passed_selection.AsSelection();
+  return passed_selection.AsSelection(is_handle_visible);

[yosin_UTC9, 2017/05/23 01:46:36]

Please use SelectionInDOMTree::Builder as

return SelectionInDOMTree::Builder(passed_selection.AsSelection())
  .SetIsHandleVisbile(is_handle_visible)
  .Build();

 }
 
 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));
 
   const SelectionInDOMTree& new_selection = CorrectedSelectionAfterCommand(
-      cmd->EndingSelection(), GetFrame().GetDocument());
+      cmd->EndingSelection(), GetFrame().GetDocument(),
+      GetFrame().Selection().IsHandleVisible());
 
   // Don't clear the typing style with this selection change. We do those things
   // elsewhere if necessary.
   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) {
@@ skipping 21 matching lines @@
   EventQueueScope scope;
 
   DispatchEditableContentChangedEvents(cmd->StartingRootEditableElement(),
                                        cmd->EndingRootEditableElement());
   DispatchInputEventEditableContentChanged(
       cmd->StartingRootEditableElement(), cmd->EndingRootEditableElement(),
       InputEvent::InputType::kHistoryUndo, g_null_atom,
       InputEvent::EventIsComposing::kNotComposing);
 
   const SelectionInDOMTree& new_selection = CorrectedSelectionAfterCommand(
-      cmd->StartingSelection(), GetFrame().GetDocument());
+      cmd->StartingSelection(), GetFrame().GetDocument(),
+      GetFrame().Selection().IsHandleVisible());
   ChangeSelectionAfterCommand(
       new_selection,
       FrameSelection::kCloseTyping | FrameSelection::kClearTypingStyle);
 
   last_edit_command_ = nullptr;
   undo_stack_->RegisterRedoStep(cmd);
   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);
 
   const SelectionInDOMTree& new_selection = CorrectedSelectionAfterCommand(
-      cmd->EndingSelection(), GetFrame().GetDocument());
+      cmd->EndingSelection(), GetFrame().GetDocument(),
+      GetFrame().Selection().IsHandleVisible());
   ChangeSelectionAfterCommand(
       new_selection,
       FrameSelection::kCloseTyping | FrameSelection::kClearTypingStyle);
 
   last_edit_command_ = nullptr;
   undo_stack_->RegisterUndoStep(cmd);
   RespondToChangedContents(new_selection.Base());
 }
 
 Editor* Editor::Create(LocalFrame& frame) {
@@ skipping 794 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