Handle some failing DocumentOrderedMap ID lookups across tree removals.

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

 /*
  * Copyright (C) 2011 Google Inc. All Rights Reserved.
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  *
  * 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 168 matching lines @@
 
 void TreeScope::addElementById(const AtomicString& elementId, Element* element)
 {
     if (!m_elementsById)
         m_elementsById = DocumentOrderedMap::create();
     m_elementsById->add(elementId, element);
     m_idTargetObserverRegistry->notifyObservers(elementId);
 }
 
 
-#if ENABLE(ASSERT)
-namespace {
-
-class RemovingElementIdScope {
-    STACK_ALLOCATED();
-public:
-    RemovingElementIdScope(DocumentOrderedMap& elementsById, const AtomicString& id)
-        : m_elementsById(&elementsById)
-    {
-        m_elementsById->willRemoveId(id);
-    }
-    ~RemovingElementIdScope()
-    {
-        m_elementsById->willRemoveId(nullAtom);
-    }
-
-private:
-    RawPtrWillBeMember<DocumentOrderedMap> m_elementsById;
-};
-
-}
-#endif
-
 void TreeScope::removeElementById(const AtomicString& elementId, Element* element)
 {
     if (!m_elementsById)
         return;
     m_elementsById->remove(elementId, element);
-#if ENABLE(ASSERT)
-    // Register 'elementId' as being removed. This is done should observers
-    // attempt to also look it up, something that the underlying DocumentOrderedMap
-    // is incapable of answering precisely while an element (and its
-    // children) are being removed from the tree. This is _only_ done to avoid
-    // an assert in DocumentOrderedMap::get() from falsely triggering for such
-    // unusual and unexpected lookups.
-    RemovingElementIdScope removalScope(*m_elementsById, elementId);
-#endif
     m_idTargetObserverRegistry->notifyObservers(elementId);
 }
 
 Node* TreeScope::ancestorInThisScope(Node* node) const
 {
     while (node) {
         if (node->treeScope() == this)
             return node;
         if (!node->isInShadowTree())
             return 0;
@@ skipping 369 matching lines @@
     visitor->trace(m_document);
     visitor->trace(m_parentTreeScope);
     visitor->trace(m_idTargetObserverRegistry);
     visitor->trace(m_selection);
     visitor->trace(m_elementsById);
     visitor->trace(m_imageMapsByName);
     visitor->trace(m_labelsByForAttribute);
     visitor->trace(m_scopedStyleResolver);
 }
 
+#if ENABLE(ASSERT)
+TreeScope::RemoveScope::RemoveScope(ContainerNode* containerNode)
+    : m_idMap(containerNode->treeScope().m_elementsById.get())
+{
+    // While removing a ContainerNode, lookups in the underlying id map will

[esprehn, 2016/01/05 07:48:33]

this comment should be with the RemoveScope class in the DocumentOrderedMap
header

[sof, 2016/01/05 12:37:18]

Done, moved to DocumentOrderedMap::RemoveScope declaration.

+    // not be precise should the tree have elements with duplicate IDs
+    // contained in the node being removed. Rare trees, but ID lookups may legitimately
+    // fail across such removals; inform the DocumentOrderedMap about the transitory
+    // state of the underlying tree.
+    if (m_idMap)
+        m_idMap->enterTreeRemoveScope();
+}
+
+TreeScope::RemoveScope::~RemoveScope()
+{
+    if (m_idMap)
+        m_idMap->leaveTreeRemoveScope();
+}
+#endif
+
 } // namespace blink