Implement Custom Elements inserted and removed callbacks.

Source/core/dom/CustomElementCallbackDispatcher.h

 /*
  * 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 22 matching lines @@
 
 #include "core/dom/CustomElementCallback.h"
 #include "core/dom/Element.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
+class Element;
+
 class CustomElementCallbackDispatcher {
     WTF_MAKE_NONCOPYABLE(CustomElementCallbackDispatcher);
 public:
     static CustomElementCallbackDispatcher& instance();
 
     class CallbackDeliveryScope {

[dglazkov, 2013/06/25 18:04:31]

Do you still use this guy?

     public:
         CallbackDeliveryScope() { }
         ~CallbackDeliveryScope()
         {
             CustomElementCallbackDispatcher& dispatcher = CustomElementCallbackDispatcher::instance();
             if (dispatcher.hasQueuedCallbacks())
                 dispatcher.dispatch();
         }
     };
 
-    void enqueueReadyCallback(CustomElementCallback*, Element*);
+    void enqueueCreationCallbacks(CustomElementCallback*, Element*, bool createdByParser);
+    void enqueueInsertedCallback(CustomElementCallback*, Element*);
+    void enqueueRemovedCallback(CustomElementCallback*, Element*);
 
     // Returns true if more work may have to be performed at the
     // checkpoint by this or other workers (for example, this work
     // invoked author scripts)
     bool dispatch();
 
     // Eagerly dispatches the ready callback. Used for createElement,
     // createElementNS and generated constructors.
     void dispatchReadyCallback(Element*);
 
-private:
-    explicit CustomElementCallbackDispatcher() { }
-
-    bool hasQueuedCallbacks() { return !m_invocations.isEmpty(); }
-
-    class ReadyInvocation {
+    class Invocation {
     public:
-        ReadyInvocation(PassRefPtr<CustomElementCallback>, PassRefPtr<Element>);
-        virtual ~ReadyInvocation() { }
-        void invoke() { m_callback->ready(m_element.get()); }
+        Invocation(CustomElementCallback::CallbackType, PassRefPtr<CustomElementCallback>, PassRefPtr<Element>);
         Element* element() { return m_element.get(); }
+        CustomElementCallback::CallbackType type() { return m_type; }
+        void invoke();
 
     private:
+        CustomElementCallback::CallbackType m_type;
         RefPtr<CustomElementCallback> m_callback;
         RefPtr<Element> m_element;
     };
 
-    typedef Vector<OwnPtr<ReadyInvocation> > InvocationList;
+private:
+    explicit CustomElementCallbackDispatcher() { }
+    bool hasQueuedCallbacks() { return !m_invocations.isEmpty(); }
+
+    typedef Vector<OwnPtr<Invocation> > InvocationList;
     InvocationList m_invocations;
 };
 
 }
 
 #endif // CustomElementCallbackDispatcher_h