DOM: Fix an issue of reversed MutationRecoards.

third_party/WebKit/Source/core/dom/ContainerNode.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All rights
  * reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 195 matching lines @@
         kNotFoundError,
         "The node before which the new node is to "
         "be inserted is not a child of this "
         "node.");
     return false;
   }
   return true;
 }
 
 template <typename Functor>
-void ContainerNode::InsertNodeVector(const NodeVector& targets,
-                                     Node* next,
-                                     const Functor& mutator) {
+void ContainerNode::InsertNodeVector(
+    const NodeVector& targets,
+    Node* next,
+    const Functor& mutator,
+    NodeVector* post_insertion_notification_targets) {
+  DCHECK(post_insertion_notification_targets);
   probe::willInsertDOMNode(this);
-  NodeVector post_insertion_notification_targets;
   {
     EventDispatchForbiddenScope assert_no_event_dispatch;
     ScriptForbiddenScope forbid_script;
     for (const auto& target_node : targets) {
       DCHECK(target_node);
       DCHECK(!target_node->parentNode());
       Node& child = *target_node;
       mutator(*this, child, next);
       ChildListMutationScope(*this).ChildAdded(child);
       if (GetDocument().ContainsV1ShadowTree())
         child.CheckSlotChangeAfterInserted();
       probe::didInsertDOMNode(&child);
-      NotifyNodeInsertedInternal(child, post_insertion_notification_targets);
+      NotifyNodeInsertedInternal(child, *post_insertion_notification_targets);
     }
   }
+}
+
+void ContainerNode::DidInsertNodeVector(
+    const NodeVector& targets,
+    Node* next,
+    const NodeVector& post_insertion_notification_targets) {
   Node* unchanged_previous =
       targets.size() > 0 ? targets[0]->previousSibling() : nullptr;
   for (const auto& target_node : targets) {
     ChildrenChanged(ChildrenChange::ForInsertion(
         *target_node, unchanged_previous, next, kChildrenChangeSourceAPI));
   }
   for (const auto& descendant : post_insertion_notification_targets) {
     if (descendant->isConnected())
       descendant->DidNotifySubtreeInsertionsToDocument();
   }
@@ skipping 53 matching lines @@
   // Make sure adding the new child is OK.
   if (!CheckAcceptChild(new_child, 0, exception_state))
     return new_child;
   DCHECK(new_child);
 
   NodeVector targets;
   if (!CollectChildrenAndRemoveFromOldParentWithCheck(
           ref_child, nullptr, *new_child, targets, exception_state))
     return new_child;
 
-  ChildListMutationScope mutation(*this);
-  InsertNodeVector(targets, ref_child, AdoptAndInsertBefore());
+  NodeVector post_insertion_notification_targets;
+  {
+    ChildListMutationScope mutation(*this);
+    InsertNodeVector(targets, ref_child, AdoptAndInsertBefore(),
+                     &post_insertion_notification_targets);
+  }
+  DidInsertNodeVector(targets, ref_child, post_insertion_notification_targets);
   return new_child;
 }
 
 void ContainerNode::InsertBeforeCommon(Node& next_child, Node& new_child) {
 #if DCHECK_IS_ON()
   DCHECK(EventDispatchForbiddenScope::IsEventDispatchForbidden());
 #endif
   DCHECK(ScriptForbiddenScope::IsScriptForbidden());
   // Use insertBefore if you need to handle reparenting (and want DOM mutation
   // events).
@@ skipping 122 matching lines @@
   // operation.
   // Though the following CollectChildrenAndRemoveFromOldParentWithCheck() also
   // calls RemoveChild(), we'd like to call RemoveChild() here to make a
   // separated MutationRecord.
   if (ContainerNode* new_child_parent = new_child->parentNode()) {
     new_child_parent->RemoveChild(new_child, exception_state);
     if (exception_state.HadException())
       return nullptr;
   }
 
-  // 9. Let previousSibling be child’s previous sibling.
-  // 11. Let removedNodes be the empty list.
-  // 15. Queue a mutation record of "childList" for target parent with
-  // addedNodes nodes, removedNodes removedNodes, nextSibling reference child,
-  // and previousSibling previousSibling.
-  ChildListMutationScope mutation(*this);
+  NodeVector targets;
+  NodeVector post_insertion_notification_targets;
+  {
+    // 9. Let previousSibling be child’s previous sibling.
+    // 11. Let removedNodes be the empty list.
+    // 15. Queue a mutation record of "childList" for target parent with
+    // addedNodes nodes, removedNodes removedNodes, nextSibling reference child,
+    // and previousSibling previousSibling.
+    ChildListMutationScope mutation(*this);
 
-  // 12. If child’s parent is not null, run these substeps:
-  //    1. Set removedNodes to a list solely containing child.
-  //    2. Remove child from its parent with the suppress observers flag set.
-  if (ContainerNode* old_child_parent = old_child->parentNode()) {
-    old_child_parent->RemoveChild(old_child, exception_state);
-    if (exception_state.HadException())
-      return nullptr;
+    // 12. If child’s parent is not null, run these substeps:
+    //    1. Set removedNodes to a list solely containing child.
+    //    2. Remove child from its parent with the suppress observers flag set.
+    if (ContainerNode* old_child_parent = old_child->parentNode()) {
+      old_child_parent->RemoveChild(old_child, exception_state);
+      if (exception_state.HadException())
+        return nullptr;
+    }
+
+    // Does this one more time because removeChild() fires a MutationEvent.
+    if (!CheckAcceptChild(new_child, old_child, exception_state))
+      return old_child;
+
+    // 13. Let nodes be node’s children if node is a DocumentFragment node, and
+    // a list containing solely node otherwise.
+    if (!CollectChildrenAndRemoveFromOldParentWithCheck(
+            next, old_child, *new_child, targets, exception_state))
+      return old_child;
+
+    // 10. Adopt node into parent’s node document.
+    // 14. Insert node into parent before reference child with the suppress
+    // observers flag set.
+    if (next) {
+      InsertNodeVector(targets, next, AdoptAndInsertBefore(),
+                       &post_insertion_notification_targets);
+    } else {
+      InsertNodeVector(targets, nullptr, AdoptAndAppendChild(),
+                       &post_insertion_notification_targets);
+    }
   }
-
-  // Does this one more time because removeChild() fires a MutationEvent.
-  if (!CheckAcceptChild(new_child, old_child, exception_state))
-    return old_child;
-
-  // 13. Let nodes be node’s children if node is a DocumentFragment node, and a
-  // list containing solely node otherwise.
-  NodeVector targets;
-  if (!CollectChildrenAndRemoveFromOldParentWithCheck(
-          next, old_child, *new_child, targets, exception_state))
-    return old_child;
-
-  // 10. Adopt node into parent’s node document.
-  // 14. Insert node into parent before reference child with the suppress
-  // observers flag set.
-  if (next)
-    InsertNodeVector(targets, next, AdoptAndInsertBefore());
-  else
-    InsertNodeVector(targets, nullptr, AdoptAndAppendChild());
+  DidInsertNodeVector(targets, next, post_insertion_notification_targets);
 
   // 16. Return child.
   return old_child;
 }
 
 void ContainerNode::WillRemoveChild(Node& child) {
   DCHECK_EQ(child.parentNode(), this);
   ChildListMutationScope(*this).WillRemoveChild(child);
   child.NotifyMutationObserversNodeWillDetach();
   DispatchChildRemovalEvents(child);
@@ skipping 202 matching lines @@
   // Make sure adding the new child is ok
   if (!CheckAcceptChild(new_child, 0, exception_state))
     return new_child;
   DCHECK(new_child);
 
   NodeVector targets;
   if (!CollectChildrenAndRemoveFromOldParentWithCheck(
           nullptr, nullptr, *new_child, targets, exception_state))
     return new_child;
 
-  ChildListMutationScope mutation(*this);
-  InsertNodeVector(targets, nullptr, AdoptAndAppendChild());
+  NodeVector post_insertion_notification_targets;
+  {
+    ChildListMutationScope mutation(*this);
+    InsertNodeVector(targets, nullptr, AdoptAndAppendChild(),
+                     &post_insertion_notification_targets);
+  }
+  DidInsertNodeVector(targets, nullptr, post_insertion_notification_targets);
   return new_child;
 }
 
 void ContainerNode::ParserAppendChild(Node* new_child) {
   DCHECK(new_child);
   DCHECK(!new_child->IsDocumentFragment());
   DCHECK(!isHTMLTemplateElement(this));
 
   if (!CheckParserAcceptChild(*new_child))
     return;
@@ skipping 849 matching lines @@
     return true;
 
   if (node->IsElementNode() && ToElement(node)->Shadow())
     return true;
 
   return false;
 }
 #endif
 
 }  // namespace blink