Implement Custom Elements inserted and removed callbacks.

Source/core/dom/CustomElementCallbackDispatcher.cpp

 /*
  * Copyright (C) 2013 Google 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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/dom/CustomElementCallbackDispatcher.h"
 
-#include "core/dom/CustomElementCallback.h"
 #include "wtf/PassOwnPtr.h"
 
 namespace WebCore {
 
+CustomElementCallbackDispatcher::Invocation::Invocation(CustomElementCallback::CallbackType type, PassRefPtr<CustomElementCallback> callback, PassRefPtr<Element> element)
+    : m_type(type)
+    , m_callback(callback)
+    , m_element(element)
+{
+}
+
+void CustomElementCallbackDispatcher::Invocation::invoke()
+{
+    switch (m_type) {
+    case CustomElementCallback::Ready:
+        m_callback->ready(m_element.get());
+        break;
+
+    case CustomElementCallback::Inserted:
+        m_callback->inserted(m_element.get());
+        break;
+
+    case CustomElementCallback::Removed:
+        m_callback->removed(m_element.get());
+        break;
+
+    default:
+        ASSERT_NOT_REACHED();
+    }
+}
+
 CustomElementCallbackDispatcher& CustomElementCallbackDispatcher::instance()
 {
     DEFINE_STATIC_LOCAL(CustomElementCallbackDispatcher, instance, ());
     return instance;
 }
 
-CustomElementCallbackDispatcher::ReadyInvocation::ReadyInvocation(PassRefPtr<CustomElementCallback> callback, PassRefPtr<Element> element)
-    : m_callback(callback)
-    , m_element(element)
-{
-}
-
 bool CustomElementCallbackDispatcher::dispatch()
 {
     if (m_invocations.isEmpty())
         return false;
 
     do  {
         InvocationList invocations;
         m_invocations.swap(invocations);
 
         for (InvocationList::iterator it = invocations.begin(); it != invocations.end(); ++it)
             it->get()->invoke();
     } while (!m_invocations.isEmpty());
 
     return true;
 }
 
 void CustomElementCallbackDispatcher::dispatchReadyCallback(Element* element)
 {
     for (size_t i = 0; i < m_invocations.size(); ++i) {
-        if (m_invocations[i].get()->element() == element) {
-            OwnPtr<ReadyInvocation> invocation = m_invocations[i].release();
+        Invocation* invocation = m_invocations[i].get();
+        if (invocation->element() == element && invocation->type() == CustomElementCallback::Ready) {
+            OwnPtr<Invocation> protect(m_invocations[i].release());
             m_invocations.remove(i);
             invocation->invoke();
             return;
         }
     }
     // The element is unresolved, or it has no ready callback.
 }
 
-void CustomElementCallbackDispatcher::enqueueReadyCallback(CustomElementCallback* callback, Element* element)
+void CustomElementCallbackDispatcher::enqueueCreationCallbacks(CustomElementCallback* callback, Element* element, bool createdByParser)
 {
-    if (!callback->hasReady())
+    if (callback->hasReady()) {
+        OwnPtr<Invocation> readyInvocation = adoptPtr(new Invocation(CustomElementCallback::Ready, callback, element));
+        if (createdByParser)
+            m_invocations.prepend(readyInvocation.release());
+        else
+            m_invocations.append(readyInvocation.release());
+    }
+
+    if (element->inDocument())
+        enqueueInsertedCallback(callback, element);
+}
+
+void CustomElementCallbackDispatcher::enqueueInsertedCallback(CustomElementCallback* callback, Element* element)
+{
+    if (!callback->hasInserted())
         return;
 
-    m_invocations.append(adoptPtr(new ReadyInvocation(callback, element)));
+    m_invocations.append(adoptPtr(new Invocation(CustomElementCallback::Inserted, callback, element)));
+}
+
+void CustomElementCallbackDispatcher::enqueueRemovedCallback(CustomElementCallback* callback, Element* element)
+{
+    if (!callback->hasRemoved())
+        return;
+
+    m_invocations.append(adoptPtr(new Invocation(CustomElementCallback::Removed, callback, element)));
 }
 
 } // namespace WebCore