Call ContainerNode::checkForSiblingStyleChanges() for Element insertion / removal only

Source/core/dom/ContainerNode.h

 /*
  * 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, 2009, 2010, 2011, 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
  * version 2 of the License, or (at your option) any later version.
@@ skipping 127 matching lines @@
 
     bool childrenAffectedByForwardPositionalRules() const { return hasRestyleFlag(ChildrenAffectedByForwardPositionalRules); }
     void setChildrenAffectedByForwardPositionalRules() { setRestyleFlag(ChildrenAffectedByForwardPositionalRules); }
 
     bool childrenAffectedByBackwardPositionalRules() const { return hasRestyleFlag(ChildrenAffectedByBackwardPositionalRules); }
     void setChildrenAffectedByBackwardPositionalRules() { setRestyleFlag(ChildrenAffectedByBackwardPositionalRules); }
 
     // FIXME: These methods should all be renamed to something better than "check",
     // since it's not clear that they alter the style bits of siblings and children.
     void checkForChildrenAdjacentRuleChanges();
-    enum SiblingCheckType { FinishedParsingChildren, SiblingRemoved, Other };
+    enum SiblingCheckType { FinishedParsingChildren, SiblingElementInserted, SiblingElementRemoved };
     void checkForSiblingStyleChanges(SiblingCheckType, Node* nodeBeforeChange, Node* nodeAfterChange);
 
     bool childrenSupportStyleSharing() const { return !hasRestyleFlags(); }
 
     // -----------------------------------------------------------------------------
     // Notification of document structure changes (see core/dom/Node.h for more notification methods)
 
-    enum ChildrenChangeType { ChildInserted, ChildRemoved, AllChildrenRemoved, TextChanged };
+    enum ChildrenChangeType { ElementInserted, NonElementInserted, ElementRemoved, NonElementRemoved, AllChildrenRemoved, TextChanged };
     enum ChildrenChangeSource { ChildrenChangeSourceAPI, ChildrenChangeSourceParser };
     struct ChildrenChange {
         STACK_ALLOCATED();
     public:
+        static ChildrenChange forInsertion(Node& node, ChildrenChangeSource byParser)
+        {
+            ChildrenChange change = {
+                node.isElementNode() ? ElementInserted : NonElementInserted,
+                node.previousSibling(),
+                node.nextSibling(),
+                byParser
+            };
+            return change;
+        }
+
+        static ChildrenChange forRemoval(Node& node, Node* previousSibling, Node* nextSibling, ChildrenChangeSource byParser)
+        {
+            ChildrenChange change = {
+                node.isElementNode() ? ElementRemoved : NonElementRemoved,
+                previousSibling,
+                nextSibling,
+                byParser
+            };
+            return change;
+        }
+
+        bool isChildInsertion() const { return type == ElementInserted || type == NonElementInserted; }
+        bool isChildRemoval() const { return type == ElementRemoved || type == NonElementRemoved; }
+        bool isElementChange() const { return type == ElementInserted || type == ElementRemoved; }

[esprehn, 2014/07/28 22:02:30]

I don't think this is correct, if everything was removed then elements may have
been removed.

[Inactive, 2014/07/28 22:23:28]

You are right that in case all children were removed, some elements might have
been removed. However, the current call site of this does not need to handle the
removal of all children (there is no need to check for sibling style
invalidation since all siblings have been removed).

Basically, I want this to mean that exactly 1 element for added or removed
(similarly to the isChildInsertion / isChildRemoval above. Apparently the naming
is not clear enough. Would it be OK if I renamed this to something better? Maybe
isChildElementChange()? or isSingleElementChange()?
isElementInsertionOrDeletion()?

+
         ChildrenChangeType type;
         RawPtrWillBeMember<Node> siblingBeforeChange;
         RawPtrWillBeMember<Node> siblingAfterChange;
         ChildrenChangeSource byParser;
     };
 
     // Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child
     // node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.
     virtual void childrenChanged(const ChildrenChange&);
 
@@ skipping 148 matching lines @@
 inline void getChildNodes(Node& node, NodeVector& nodes)
 {
     ASSERT(!nodes.size());
     for (Node* child = node.firstChild(); child; child = child->nextSibling())
         nodes.append(child);
 }
 
 } // namespace WebCore
 
 #endif // ContainerNode_h