callTheAdoptionAgency should work asynchronously

Source/core/html/parser/HTMLConstructionSite.h

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  * Copyright (C) 2011 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 23 matching lines @@
 #include <wtf/Noncopyable.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
 #include <wtf/Vector.h>
 
 namespace WebCore {
 
 struct HTMLConstructionSiteTask {
     enum Operation {
         Insert,
+        InsertAlreadyParsedChild,
         Reparent,
+        TakeAllChildren,
     };
 
     explicit HTMLConstructionSiteTask(Operation op)
         : operation(op)
         , selfClosing(false)
     {
     }
 
+    ContainerNode* oldParent()
+    {
+        // It's sort of ugly, but we store the |oldParent| in the |child| field
+        // of the task so that we don't bloat the HTMLConstructionSiteTask
+        // object in the common case of the Insert operation.
+        ASSERT(child->isContainerNode());
+        return static_cast<ContainerNode*>(child.get());

[eseidel, 2013/05/07 00:49:40]

I believe there is a toContainerNode() which does a RELEASE_ASSERT. :)

+    }
+
     Operation operation;
     RefPtr<ContainerNode> parent;
     RefPtr<Node> nextChild;
     RefPtr<Node> child;
     bool selfClosing;
 };
 
 } // namespace WebCore
 
 namespace WTF {
@@ skipping 38 matching lines @@
     void insertHTMLFormElement(AtomicHTMLToken*, bool isDemoted = false);
     void insertScriptElement(AtomicHTMLToken*);
     void insertTextNode(const String&, WhitespaceMode = WhitespaceUnknown);
     void insertForeignElement(AtomicHTMLToken*, const AtomicString& namespaceURI);
 
     void insertHTMLHtmlStartTagBeforeHTML(AtomicHTMLToken*);
     void insertHTMLHtmlStartTagInBody(AtomicHTMLToken*);
     void insertHTMLBodyStartTagInBody(AtomicHTMLToken*);
 
     void reparent(HTMLElementStack::ElementRecord* newParent, HTMLElementStack::ElementRecord* child);
+    void reparent(HTMLElementStack::ElementRecord* newParent, HTMLStackItem* child);
+    // insertAlreadyParsedChild assumes that |child| has already been parsed (i.e., we're just
+    // moving it around in the tree rather than parsing it for the first time). That means
+    // this function doesn't call beginParsingChildren / finishParsingChildren.
+    void insertAlreadyParsedChild(HTMLStackItem* newParent, HTMLElementStack::ElementRecord* child);
+    void takeAllChildren(HTMLStackItem* newParent, HTMLElementStack::ElementRecord* oldParent);
 
     PassRefPtr<HTMLStackItem> createElementFromSavedToken(HTMLStackItem*);
 
     bool shouldFosterParent() const;
     void fosterParent(PassRefPtr<Node>);
 
     bool indexOfFirstUnopenFormattingElement(unsigned& firstUnopenElementIndex) const;
     void reconstructTheActiveFormattingElements();
 
     void generateImpliedEndTags();
@@ skipping 81 matching lines @@
     // "whenever a node would be inserted into the current node, it must instead
     // be foster parented."  This flag tracks whether we're in that state.
     bool m_redirectAttachToFosterParent;
 
     bool m_inQuirksMode;
 };
 
 } // namespace WebCore
 
 #endif