feat: remove DeprecatedPtrList code

Signed-off-by: zhangjipeng <zhangjipeng@xiaomi.com>

Author: zhangjipeng

src/webcore/dom/Document.cpp

@@ -258,7 +258,7 @@ static bool acceptsEditingFocus(Node *node)
     return frame->editor()->shouldBeginEditing(rangeOfContents(root).get());
 }
 
-DeprecatedPtrList<Document>*  Document::changedDocuments = 0;
+Vector<Document*>* Document::changedDocuments = 0;
 
 // FrameView might be 0
 Document::Document(DOMImplementation* impl, Frame* frame, bool isXHTML)
@@ -418,8 +418,14 @@ Document::~Document()
     }
 #endif
 
-    if (m_docChanged && changedDocuments)
-        changedDocuments->remove(this);
+    if (m_docChanged && changedDocuments) {
+        for (unsigned i = 0; i < changedDocuments->size(); ++i) {
+            if (changedDocuments->at(i) == this) {
+                changedDocuments->remove(i);
+                break;
+            }
+        }
+    }
     delete m_tokenizer;
     m_document.resetSkippingRef(0);
     delete m_styleSelector;
@@ -993,16 +999,22 @@ void Document::setDocumentChanged(bool b)
     if (b) {
         if (!m_docChanged) {
             if (!changedDocuments)
-                changedDocuments = new DeprecatedPtrList<Document>;
+                changedDocuments = new Vector<Document*>;
             changedDocuments->append(this);
         }
         if (m_accessKeyMapValid) {
             m_accessKeyMapValid = false;
             m_elementsByAccessKey.clear();
         }
     } else {
-        if (m_docChanged && changedDocuments)
-            changedDocuments->remove(this);
+        if (m_docChanged && changedDocuments) {
+            for (unsigned i = 0; i < changedDocuments->size(); ++i) {
+                if (changedDocuments->at(i) == this) {
+                    changedDocuments->remove(i);
+                    break;
+                }
+            }
+        }
     }
 
     m_docChanged = b;
@@ -1102,7 +1114,10 @@ void Document::updateDocumentsRendering()
     if (!changedDocuments)
         return;
 
-    while (Document* doc = changedDocuments->take()) {
+    // Process and clear in FIFO order.
+    while (!changedDocuments->isEmpty()) {
+        Document* doc = changedDocuments->at(0);
+        changedDocuments->remove(0);
         doc->m_docChanged = false;
         doc->updateRendering();
     }
@@ -2497,8 +2512,18 @@ void Document::removeImage(HTMLImageLoader* image)
 {
     // Remove instances of this image from both lists.
     // Use loops because we allow multiple instances to get into the lists.
-    while (m_imageLoadEventDispatchSoonList.removeRef(image)) { }
-    while (m_imageLoadEventDispatchingList.removeRef(image)) { }
+    for (unsigned i = 0; i < m_imageLoadEventDispatchSoonList.size();) {
+        if (m_imageLoadEventDispatchSoonList[i] == image)
+            m_imageLoadEventDispatchSoonList.remove(i);
+        else
+            ++i;
+    }
+    for (unsigned i = 0; i < m_imageLoadEventDispatchingList.size();) {
+        if (m_imageLoadEventDispatchingList[i] == image)
+            m_imageLoadEventDispatchingList.remove(i);
+        else
+            ++i;
+    }
     if (m_imageLoadEventDispatchSoonList.isEmpty())
         m_imageLoadEventTimer.stop();
 }
@@ -2516,15 +2541,13 @@ void Document::dispatchImageLoadEventsNow()
 
     m_imageLoadEventDispatchingList = m_imageLoadEventDispatchSoonList;
     m_imageLoadEventDispatchSoonList.clear();
-    for (DeprecatedPtrListIterator<HTMLImageLoader> it(m_imageLoadEventDispatchingList); it.current();) {
-        HTMLImageLoader* image = it.current();
-        // Must advance iterator *before* dispatching call.
-        // Otherwise, it might be advanced automatically if dispatching the call had a side effect
-        // of destroying the current HTMLImageLoader, and then we would advance past the *next* item,
-        // missing one altogether.
-        ++it;
-        image->dispatchLoadEvent();
-    }
+
+    // Iterate over a snapshot so that side effects during dispatch (including calling removeImage)
+    // do not cause us to skip items.
+    Vector<HTMLImageLoader*> toDispatch = m_imageLoadEventDispatchingList;
+    for (unsigned i = 0; i < toDispatch.size(); ++i)
+        toDispatch[i]->dispatchLoadEvent();
+
     m_imageLoadEventDispatchingList.clear();
 }
 

src/webcore/dom/Document.h

@@ -27,7 +27,6 @@
 
 #include "Attr.h"
 #include "Color.h"
-#include "DeprecatedPtrList.h"
 #include "DocumentMarker.h"
 #include "HTMLCollection.h"
 #include "HTMLFormElement.h"
@@ -37,6 +36,7 @@
 #include <wtf/Deque.h>
 #include <wtf/HashCountedSet.h>
 #include <wtf/ListHashSet.h>
+#include <wtf/Vector.h>
 
 namespace WebCore {
 
@@ -333,7 +333,7 @@ class Document : public ContainerNode {
     PassRefPtr<EditingText> createEditingTextNode(const String&);
 
     virtual void recalcStyle( StyleChange = NoChange );
-    static DeprecatedPtrList<Document>* changedDocuments;
+    static Vector<Document*>* changedDocuments;
     virtual void updateRendering();
     void updateLayout();
     void updateLayoutIgnorePendingStylesheets();
@@ -779,8 +779,8 @@ class Document : public ContainerNode {
     typedef HashMap<RefPtr<Node>, MarkerMapVectorPair*> MarkerMap;
     MarkerMap m_markers;
 
-    DeprecatedPtrList<HTMLImageLoader> m_imageLoadEventDispatchSoonList;
-    DeprecatedPtrList<HTMLImageLoader> m_imageLoadEventDispatchingList;
+    Vector<HTMLImageLoader*> m_imageLoadEventDispatchSoonList;
+    Vector<HTMLImageLoader*> m_imageLoadEventDispatchingList;
     Timer<Document> m_imageLoadEventTimer;
 
     Timer<Document> m_updateFocusAppearanceTimer;

src/webcore/dom/EventTargetNode.cpp

@@ -183,52 +183,56 @@ bool EventTargetNode::dispatchGenericEvent(PassRefPtr<Event> e, ExceptionCode&,
     ASSERT(!evt->type().isNull()); // JavaScript code could create an event with an empty name
 
     // work out what nodes to send event to
-    DeprecatedPtrList<Node> nodeChain;
+    Vector<Node*> nodeChain;
 
     if (inDocument()) {
         for (Node* n = this; n; n = n->eventParentNode()) {
             n->ref();
-            nodeChain.prepend(n);
+            nodeChain.insert(0, n);
         } 
     } else {
         // if node is not in the document just send event to itself 
         ref();
-        nodeChain.prepend(this);
+        nodeChain.append(this);
     }
-    
-    DeprecatedPtrListIterator<Node> it(nodeChain);
+
+    unsigned chainSize = nodeChain.size();
+    unsigned index = 0;
 
     // Before we begin dispatching events, give the target node a chance to do some work prior
     // to the DOM event handlers getting a crack.
     void* data = preDispatchEventHandler(evt.get());
 
     // trigger any capturing event handlers on our way down
     evt->setEventPhase(Event::CAPTURING_PHASE);
-    
-    it.toFirst();
+
+    index = 0;
     // Handle window events for capture phase, except load events, this quirk is needed
     // because Mozilla used to never propagate load events to the window object
-    if (evt->type() != loadEvent && it.current()->isDocumentNode() && !evt->propagationStopped())
-        static_cast<Document*>(it.current())->handleWindowEvent(evt.get(), true);
+    if (evt->type() != loadEvent && chainSize && nodeChain[0]->isDocumentNode() && !evt->propagationStopped())
+        static_cast<Document*>(nodeChain[0])->handleWindowEvent(evt.get(), true);
 
-    for (; it.current() && it.current() != this && !evt->propagationStopped(); ++it) {
-        evt->setCurrentTarget(EventTargetNodeCast(it.current()));
-        EventTargetNodeCast(it.current())->handleLocalEvents(evt.get(), true);
+    for (; index < chainSize && nodeChain[index] != this && !evt->propagationStopped(); ++index) {
+        evt->setCurrentTarget(EventTargetNodeCast(nodeChain[index]));
+        EventTargetNodeCast(nodeChain[index])->handleLocalEvents(evt.get(), true);
     }
 
     // dispatch to the actual target node
-    it.toLast();
+    if (chainSize)
+        index = chainSize - 1;
     if (!evt->propagationStopped()) {
         evt->setEventPhase(Event::AT_TARGET);
-        evt->setCurrentTarget(EventTargetNodeCast(it.current()));
+        evt->setCurrentTarget(EventTargetNodeCast(nodeChain[index]));
 
         // We do want capturing event listeners to be invoked here, even though
         // that violates the specification since Mozilla does it.
-        EventTargetNodeCast(it.current())->handleLocalEvents(evt.get(), true);
+        EventTargetNodeCast(nodeChain[index])->handleLocalEvents(evt.get(), true);
 
-        EventTargetNodeCast(it.current())->handleLocalEvents(evt.get(), false);
+        EventTargetNodeCast(nodeChain[index])->handleLocalEvents(evt.get(), false);
     }
-    --it;
+
+    if (index)
+        --index;
 
     // ok, now bubble up again (only non-capturing event handlers will be called)
     // ### recalculate the node chain here? (e.g. if target node moved in document by previous event handlers)
@@ -244,17 +248,21 @@ bool EventTargetNode::dispatchGenericEvent(PassRefPtr<Event> e, ExceptionCode&,
 
     if (evt->bubbles()) {
         evt->setEventPhase(Event::BUBBLING_PHASE);
-        for (; it.current() && !evt->propagationStopped() && !evt->cancelBubble(); --it) {
-            evt->setCurrentTarget(EventTargetNodeCast(it.current()));
-            EventTargetNodeCast(it.current())->handleLocalEvents(evt.get(), false);
+        for (;; ) {
+            if (!chainSize || evt->propagationStopped() || evt->cancelBubble())
+                break;
+            evt->setCurrentTarget(EventTargetNodeCast(nodeChain[index]));
+            EventTargetNodeCast(nodeChain[index])->handleLocalEvents(evt.get(), false);
+            if (!index)
+                break;
+            --index;
         }
         // Handle window events for bubbling phase, except load events, this quirk is needed
         // because Mozilla used to never propagate load events at all
 
-        it.toFirst();
-        if (evt->type() != loadEvent && it.current()->isDocumentNode() && !evt->propagationStopped() && !evt->cancelBubble()) {
-            evt->setCurrentTarget(EventTargetNodeCast(it.current()));
-            static_cast<Document*>(it.current())->handleWindowEvent(evt.get(), false);
+        if (evt->type() != loadEvent && chainSize && nodeChain[0]->isDocumentNode() && !evt->propagationStopped() && !evt->cancelBubble()) {
+            evt->setCurrentTarget(EventTargetNodeCast(nodeChain[0]));
+            static_cast<Document*>(nodeChain[0])->handleWindowEvent(evt.get(), false);
         } 
     } 
 
@@ -268,17 +276,24 @@ bool EventTargetNode::dispatchGenericEvent(PassRefPtr<Event> e, ExceptionCode&,
 
     // now we call all default event handlers (this is not part of DOM - it is internal to khtml)
 
-    it.toLast();
-    if (evt->bubbles())
-        for (; it.current() && !evt->defaultPrevented() && !evt->defaultHandled(); --it)
-            EventTargetNodeCast(it.current())->defaultEventHandler(evt.get());
-    else if (!evt->defaultPrevented() && !evt->defaultHandled())
-        EventTargetNodeCast(it.current())->defaultEventHandler(evt.get());
+    if (chainSize) {
+        unsigned defaultIndex = chainSize - 1;
+        if (evt->bubbles()) {
+            for (;; ) {
+                if (evt->defaultPrevented() || evt->defaultHandled())
+                    break;
+                EventTargetNodeCast(nodeChain[defaultIndex])->defaultEventHandler(evt.get());
+                if (!defaultIndex)
+                    break;
+                --defaultIndex;
+            }
+        } else if (!evt->defaultPrevented() && !evt->defaultHandled())
+            EventTargetNodeCast(nodeChain[defaultIndex])->defaultEventHandler(evt.get());
+    }
 
     // deref all nodes in chain
-    it.toFirst();
-    for (; it.current(); ++it)
-        it.current()->deref(); // this may delete us
+    for (unsigned i = 0; i < chainSize; ++i)
+        nodeChain[i]->deref(); // this may delete us
 
     Document::updateDocumentsRendering();
 

src/webcore/dom/XMLTokenizer.cpp

@@ -53,6 +53,7 @@
 #include <libxml/parserInternals.h>
 #include <wtf/Platform.h>
 #include <wtf/StringExtras.h>
+#include <wtf/Deque.h>
 #include <wtf/Vector.h>
 
 #if ENABLE(XSLT)
@@ -78,7 +79,11 @@ class PendingCallbacks {
 public:
     PendingCallbacks()
     {
-        m_callbacks.setAutoDelete(true);
+    }
+
+    ~PendingCallbacks()
+    {
+        deleteAllValues(m_callbacks);
     }
 
     void appendStartElementNSCallback(const xmlChar* xmlLocalName, const xmlChar* xmlPrefix, const xmlChar* xmlURI, int nb_namespaces,
@@ -183,7 +188,7 @@ class PendingCallbacks {
 
     void callAndRemoveFirstCallback(XMLTokenizer* tokenizer)
     {
-        PendingCallback* cb = m_callbacks.getFirst();
+        PendingCallback* cb = m_callbacks.first();
 
         cb->call(tokenizer);
         m_callbacks.removeFirst();
@@ -332,7 +337,7 @@ class PendingCallbacks {
     };
 
 public:
-    DeprecatedPtrList<PendingCallback> m_callbacks;
+    Deque<PendingCallback*> m_callbacks;
 };
 // --------------------------------