Attachment 111301 Details for Bug 68956 – Patch

[patch] Patch

bug-68956-20111017122641.patch (text/plain), 34.36 KB, created by Rafael Weinstein on 2011-10-17 12:26:42 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Rafael Weinstein

Created: 2011-10-17 12:26:42 PDT

Size: 34.36 KB

patch

obsolete

>Subversion Revision: 97635
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index bafd4c94847cdff0faa660b414736b046c848364..c1468a33db2436f12205ff44ecb6359aa9b90362 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,55 @@
>+2011-10-13  Rafael Weinstein  <rafaelw@chromium.org>
>+
>+        [MutationObservers] Implement WebKitMutationObserver.observe for attributes
>+        https://bugs.webkit.org/show_bug.cgi?id=68956
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Test: fast/mutation/observe-attributes.html
>+
>+        This adds an initial implementation for registering mutation observers on nodes,
>+        delivering mutation records at the end of the outer-most script invokation and
>+        observing mutations to element attributes.
>+
>+        Note that the outer-most script invokation only works in V8.
>+
>+        Note also that support for observing changes to the style attribute when updated
>+        via the style property is not implemented here.
>+
>+        * bindings/v8/V8Proxy.cpp:
>+        (WebCore::V8Proxy::didLeaveScriptContext):
>+        * dom/Element.cpp:
>+        (WebCore::enqueueAttributesMutationRecord):
>+        (WebCore::Element::setAttribute):
>+        * dom/MutationRecord.cpp:
>+        (WebCore::MutationRecord::createAttributes):
>+        * dom/MutationRecord.h:
>+        * dom/MutationRecord.idl:
>+        * dom/Node.cpp:
>+        (WebCore::Node::clearRareData):
>+        (WebCore::Node::mutationObserverData):
>+        (WebCore::Node::ensureMutationObserverData):
>+        (WebCore::Node::registeredMutationObserversOfType):
>+        (WebCore::Node::registerMutationObserver):
>+        (WebCore::Node::deregisterMutationObserver):
>+        * dom/Node.h:
>+        * dom/NodeRareData.h:
>+        (WebCore::MutationObserverRegistration::MutationObserverRegistration):
>+        (WebCore::MutationObserverRegistration::operator==):
>+        (WebCore::MutationObserverData::MutationObserverData):
>+        (WebCore::MutationObserverData::~MutationObserverData):
>+        (WebCore::NodeRareData::mutationObserverData):
>+        (WebCore::NodeRareData::ensureMutationObserverData):
>+        * dom/WebKitMutationObserver.cpp:
>+        (WebCore::WebKitMutationObserver::observe):
>+        (WebCore::WebKitMutationObserver::disconnect):
>+        (WebCore::WebKitMutationObserver::wasDeregistered):
>+        (WebCore::activeMutationObservers):
>+        (WebCore::WebKitMutationObserver::enqueueMutationRecord):
>+        (WebCore::WebKitMutationObserver::deliverAllMutations):
>+        (WebCore::WebKitMutationObserver::deliver):
>+        * dom/WebKitMutationObserver.h:
>+
> 2011-10-17  Dan Bernstein  <mitz@apple.com>
> 
>         <rdar://problem/10293929> REGRESSION (r97525): iChat transcript has horizontal scroll bar when the conversation includes a wide image
>diff --git a/Source/WebCore/bindings/v8/V8Proxy.cpp b/Source/WebCore/bindings/v8/V8Proxy.cpp
>index 0bf48e8341d04b55536ffb636766c7050e20c066..80a21a0ff0c2d725a4c887c3b60f03a4c1a5dfe1 100644
>--- a/Source/WebCore/bindings/v8/V8Proxy.cpp
>+++ b/Source/WebCore/bindings/v8/V8Proxy.cpp
>@@ -65,6 +65,7 @@
> #include "V8SQLException.h"
> #include "V8XMLHttpRequestException.h"
> #include "V8XPathException.h"
>+#include "WebKitMutationObserver.h"
> #include "WorkerContext.h"
> #include "WorkerContextExecutionProxy.h"
> 
>@@ -620,6 +621,10 @@ void V8Proxy::didLeaveScriptContext()
> #endif // ENABLE(INDEXED_DATABASE)
>     if (page->group().hasLocalStorage())
>         page->group().localStorage()->unlock();
>+
>+#if ENABLE(MUTATION_OBSERVERS)
>+    WebCore::WebKitMutationObserver::deliverAllMutations();
>+#endif
> }
> 
> void V8Proxy::resetIsolatedWorlds()
>diff --git a/Source/WebCore/dom/Element.cpp b/Source/WebCore/dom/Element.cpp
>index e8033e352d37af3b7b00c227ee732cb4d0bdf42e..58aadb339b611d1499b1a2c594a522c92c1f39c1 100644
>--- a/Source/WebCore/dom/Element.cpp
>+++ b/Source/WebCore/dom/Element.cpp
>@@ -48,6 +48,7 @@
> #include "HTMLNames.h"
> #include "HTMLParserIdioms.h"
> #include "InspectorInstrumentation.h"
>+#include "MutationRecord.h"
> #include "NodeList.h"
> #include "NodeRenderStyle.h"
> #include "NodeRenderingContext.h"
>@@ -59,6 +60,11 @@
> #include "ShadowRoot.h"
> #include "Text.h"
> #include "TextIterator.h"
>+
>+#if ENABLE(MUTATION_OBSERVERS)
>+#include "WebKitMutationObserver.h"
>+#endif
>+
> #include "WebKitAnimationList.h"
> #include "XMLNames.h"
> #include "htmlediting.h"
>@@ -610,6 +616,20 @@ const AtomicString& Element::getAttributeNS(const String& namespaceURI, const St
>     return getAttribute(QualifiedName(nullAtom, localName, namespaceURI));
> }
> 
>+#if ENABLE(MUTATION_OBSERVERS)
>+static void enqueueAttributesMutationRecord(Element* element, const QualifiedName& name)
>+{
>+    Vector<WebKitMutationObserver*> observers;
>+    element->registeredMutationObserversOfType(observers, WebKitMutationObserver::Attributes);
>+    if (observers.isEmpty())
>+        return;
>+
>+    RefPtr<MutationRecord> mutation = MutationRecord::createAttributes(element, name);
>+    for (Vector<WebKitMutationObserver*>::iterator iter = observers.begin(); iter != observers.end(); ++iter)
>+        (*iter)->enqueueMutationRecord(mutation);
>+}
>+#endif
>+
> void Element::setAttribute(const AtomicString& name, const AtomicString& value, ExceptionCode& ec)
> {
>     if (!Document::isValidName(name)) {
>@@ -630,6 +650,11 @@ void Element::setAttribute(const AtomicString& name, const AtomicString& value,
> 
>     document()->incDOMTreeVersion();
> 
>+#if ENABLE(MUTATION_OBSERVERS)
>+    // The call to attributeChanged below may dispatch DOMSubtreeModified, so it's important to enqueue a MutationRecord now.
>+    enqueueAttributesMutationRecord(this, attributeName);
>+#endif
>+
>     if (isIdAttributeName(old ? old->name() : attributeName))
>         updateId(old ? old->value() : nullAtom, value);
> 
>@@ -663,6 +688,11 @@ void Element::setAttribute(const QualifiedName& name, const AtomicString& value,
>     // Allocate attribute map if necessary.
>     Attribute* old = attributes(false)->getAttributeItem(name);
> 
>+#if ENABLE(MUTATION_OBSERVERS)
>+    // The call to attributeChanged below may dispatch DOMSubtreeModified, so it's important to enqueue a MutationRecord now.
>+    enqueueAttributesMutationRecord(this, name);
>+#endif
>+
>     if (isIdAttributeName(name))
>         updateId(old ? old->value() : nullAtom, value);
> 
>diff --git a/Source/WebCore/dom/MutationRecord.cpp b/Source/WebCore/dom/MutationRecord.cpp
>index 84b298b0f79394667cf4926de669a34c0d8282b5..c36eca6dde71deee9cd2cfd24c884f58ba7bbfb9 100644
>--- a/Source/WebCore/dom/MutationRecord.cpp
>+++ b/Source/WebCore/dom/MutationRecord.cpp
>@@ -36,6 +36,7 @@
> 
> #include "Node.h"
> #include "NodeList.h"
>+#include "QualifiedName.h"
> #include <wtf/Assertions.h>
> #include <wtf/StdLibExtras.h>
> 
>@@ -69,17 +70,17 @@ private:
> 
> class AttributesRecord : public MutationRecord {
> public:
>-    AttributesRecord(PassRefPtr<Node> target, const AtomicString& attributeName, const AtomicString& attributeNamespace)
>+    AttributesRecord(PassRefPtr<Node> target, const QualifiedName& name)
>         : MutationRecord(target)
>-        , m_attributeName(attributeName)
>-        , m_attributeNamespace(attributeNamespace)
>+        , m_attributeName(name.localName())
>+        , m_attributeNamespace(name.namespaceURI())
>     {
>     }
> 
> private:
>     virtual const AtomicString& type();
>     virtual const AtomicString& attributeName() { return m_attributeName; }
>-    virtual const AtomicString& attributeNamespace() { return m_attributeName; }
>+    virtual const AtomicString& attributeNamespace() { return m_attributeNamespace; }
>     virtual String oldValue() { return m_oldValue; }
>     virtual void setOldValue(const String& value) { m_oldValue = value; }
> 
>@@ -128,9 +129,9 @@ PassRefPtr<MutationRecord> MutationRecord::createChildList(PassRefPtr<Node> targ
>     return adoptRef(static_cast<MutationRecord*>(new ChildListRecord(target, added, removed, previousSibling, nextSibling)));
> }
> 
>-PassRefPtr<MutationRecord> MutationRecord::createAttributes(PassRefPtr<Node> target, const AtomicString& attributeName, const AtomicString& attributeNamespace)
>+PassRefPtr<MutationRecord> MutationRecord::createAttributes(PassRefPtr<Node> target, const QualifiedName& name)
> {
>-    return adoptRef(static_cast<MutationRecord*>(new AttributesRecord(target, attributeName, attributeNamespace)));
>+    return adoptRef(static_cast<MutationRecord*>(new AttributesRecord(target, name)));
> }
> 
> PassRefPtr<MutationRecord> MutationRecord::createCharacterData(PassRefPtr<Node> target)
>diff --git a/Source/WebCore/dom/MutationRecord.h b/Source/WebCore/dom/MutationRecord.h
>index f0cec606687defa215edecc48f32e5dcdd572e99..25af4d3ea3a1799dfa0e34186e18881582236145 100644
>--- a/Source/WebCore/dom/MutationRecord.h
>+++ b/Source/WebCore/dom/MutationRecord.h
>@@ -42,11 +42,12 @@ namespace WebCore {
> 
> class Node;
> class NodeList;
>+class QualifiedName;
> 
> class MutationRecord : public RefCounted<MutationRecord> {
> public:
>     static PassRefPtr<MutationRecord> createChildList(PassRefPtr<Node> target, PassRefPtr<NodeList> added, PassRefPtr<NodeList> removed, PassRefPtr<Node> previousSibling, PassRefPtr<Node> nextSibling);
>-    static PassRefPtr<MutationRecord> createAttributes(PassRefPtr<Node> target, const AtomicString& attributeName, const AtomicString& attributeNamespace);
>+    static PassRefPtr<MutationRecord> createAttributes(PassRefPtr<Node> target, const QualifiedName&);
>     static PassRefPtr<MutationRecord> createCharacterData(PassRefPtr<Node> target);
> 
>     virtual ~MutationRecord();
>diff --git a/Source/WebCore/dom/MutationRecord.idl b/Source/WebCore/dom/MutationRecord.idl
>index 46e7a29bbb84526b4290d9046680038ce0cc5b29..c19b41f216e4a52c46f2184785c36f8802fd2b54 100644
>--- a/Source/WebCore/dom/MutationRecord.idl
>+++ b/Source/WebCore/dom/MutationRecord.idl
>@@ -41,8 +41,8 @@ module core {
>         readonly attribute Node nextSibling;
> 
>         readonly attribute DOMString attributeName;
>-        readonly attribute DOMString attributeNamespace;
>+        readonly attribute [ConvertNullStringTo=Null] DOMString attributeNamespace;
> 
>-        readonly attribute DOMString oldValue;
>+        readonly attribute [ConvertNullStringTo=Null] DOMString oldValue;
>     };
> }
>diff --git a/Source/WebCore/dom/Node.cpp b/Source/WebCore/dom/Node.cpp
>index f5e47f4d88bb27b153209117d6766ab82a818a3c..69a3aa78e688b240c7be25cf78329fb2d9287d01 100644
>--- a/Source/WebCore/dom/Node.cpp
>+++ b/Source/WebCore/dom/Node.cpp
>@@ -100,6 +100,7 @@
> #include <wtf/PassOwnPtr.h>
> #include <wtf/RefCountedLeakCounter.h>
> #include <wtf/UnusedParam.h>
>+#include <wtf/Vector.h>
> #include <wtf/text/CString.h>
> #include <wtf/text/StringBuilder.h>
> 
>@@ -546,6 +547,14 @@ void Node::clearRareData()
>     if (treeScope() && rareData()->nodeLists())
>         treeScope()->removeNodeListCache();
> 
>+#if ENABLE(MUTATION_OBSERVERS)
>+    MutationObserverData* observerData = mutationObserverData();
>+    if (observerData) {
>+        for (MutationObserverRegistrationVector::iterator iter = observerData->observers.begin(); iter != observerData->observers.end(); ++iter)
>+            iter->observer->wasDeregistered(this);
>+    }
>+#endif
>+
>     NodeRareData::NodeRareDataMap& dataMap = NodeRareData::rareDataMap();
>     NodeRareData::NodeRareDataMap::iterator it = dataMap.find(this);
>     ASSERT(it != dataMap.end());
>@@ -2673,6 +2682,62 @@ EventTargetData* Node::ensureEventTargetData()
>     return ensureRareData()->ensureEventTargetData();
> }
> 
>+#if ENABLE(MUTATION_OBSERVERS)
>+MutationObserverData* Node::mutationObserverData()
>+{
>+    return hasRareData() ? rareData()->mutationObserverData() : 0;
>+}
>+
>+MutationObserverData* Node::ensureMutationObserverData()
>+{
>+    return ensureRareData()->ensureMutationObserverData();
>+}
>+
>+void Node::registeredMutationObserversOfType(Vector<WebKitMutationObserver*>& observers, WebKitMutationObserver::MutationType type)
>+{
>+    MutationObserverData* observerData = mutationObserverData();
>+    if (!observerData || observerData->observers.isEmpty())
>+        return;
>+
>+    for (MutationObserverRegistrationVector::iterator iter = observerData->observers.begin(); iter != observerData->observers.end(); ++iter) {
>+        if (iter->options & type)
>+            observers.append(iter->observer.get());
>+    }
>+}
>+
>+Node::MutationRegistrationResult Node::registerMutationObserver(PassRefPtr<WebKitMutationObserver> observer, unsigned char options)
>+{
>+    MutationObserverData* observerData = ensureMutationObserverData();
>+    MutationObserverRegistration registration(observer, options);
>+
>+    size_t index = observerData->observers.find(registration);
>+    if (index == notFound) {
>+        observerData->observers.append(registration);
>+        return MutationObserverRegistered;
>+    }
>+
>+    observerData->observers[index].options = registration.options;
>+    return MutationRegistrationOptionsReset;
>+}
>+
>+void Node::deregisterMutationObserver(PassRefPtr<WebKitMutationObserver> observer)
>+{
>+    MutationObserverData* observerData = mutationObserverData();
>+    ASSERT(observerData);
>+    if (!observerData)
>+        return;
>+
>+    MutationObserverRegistration registration(observer, 0);
>+    size_t index = observerData->observers.find(registration);
>+    ASSERT(index != notFound);
>+    if (index == notFound)
>+        return;
>+
>+    observerData->observers.remove(index);
>+}
>+#endif // ENABLE(MUTATION_OBSERVERS)
>+
>+
> void Node::handleLocalEvents(Event* event)
> {
>     if (!hasRareData() || !rareData()->eventTargetData())
>diff --git a/Source/WebCore/dom/Node.h b/Source/WebCore/dom/Node.h
>index 163caeea40385379b134f99dbbe44e5ebbe3b8e0..5ccd01a80eda82761a29fc2f4023faac74218ff4 100644
>--- a/Source/WebCore/dom/Node.h
>+++ b/Source/WebCore/dom/Node.h
>@@ -31,6 +31,7 @@
> #include "RenderStyleConstants.h"
> #include "ScriptWrappable.h"
> #include "TreeShared.h"
>+#include "WebKitMutationObserver.h"
> #include <wtf/Forward.h>
> #include <wtf/ListHashSet.h>
> 
>@@ -58,6 +59,7 @@ class Frame;
> class HTMLInputElement;
> class IntRect;
> class KeyboardEvent;
>+class MutationObserverData;
> class NSResolver;
> class NamedNodeMap;
> class NameNodeList;
>@@ -585,6 +587,22 @@ public:
>     void itemTypeAttributeChanged();
> #endif
> 
>+#if ENABLE(MUTATION_OBSERVERS)
>+    MutationObserverData* mutationObserverData();
>+    MutationObserverData* ensureMutationObserverData();
>+
>+    void registeredMutationObserversOfType(Vector<WebKitMutationObserver*>&, WebKitMutationObserver::MutationType);
>+
>+    // Returns true if the observer wasn't already registered on this node.
>+    enum MutationRegistrationResult {
>+        MutationObserverRegistered,
>+        MutationRegistrationOptionsReset
>+    };
>+    MutationRegistrationResult registerMutationObserver(PassRefPtr<WebKitMutationObserver>, unsigned char options);
>+
>+    void deregisterMutationObserver(PassRefPtr<WebKitMutationObserver>);
>+#endif // ENABLE(MUTATION_OBSERVERS)
>+
> private:
>     enum NodeFlags {
>         IsTextFlag = 1,
>diff --git a/Source/WebCore/dom/NodeRareData.h b/Source/WebCore/dom/NodeRareData.h
>index 4cf5b996d93c640f6a781321ab84cc7f948f20b2..ecd34649b7f3d3d8b44582463f8003822a7c65f6 100644
>--- a/Source/WebCore/dom/NodeRareData.h
>+++ b/Source/WebCore/dom/NodeRareData.h
>@@ -32,6 +32,7 @@
> #include "NameNodeList.h"
> #include "QualifiedName.h"
> #include "TagNodeList.h"
>+#include "WebKitMutationObserver.h"
> #include <wtf/HashSet.h>
> #include <wtf/OwnPtr.h>
> #include <wtf/PassOwnPtr.h>
>@@ -86,7 +87,36 @@ public:
> private:
>     NodeListsNodeData() : m_labelsNodeListCache(0) {}
> };
>-    
>+
>+#if ENABLE(MUTATION_OBSERVERS)
>+struct MutationObserverRegistration {
>+    MutationObserverRegistration(PassRefPtr<WebKitMutationObserver> observer, unsigned char options)
>+        : observer(observer)
>+        , options(options)
>+    {
>+    }
>+
>+    bool operator==(const MutationObserverRegistration& other) const
>+    {
>+        return observer == other.observer;
>+    }
>+
>+    RefPtr<WebKitMutationObserver> observer;
>+    unsigned char options;
>+};
>+
>+typedef Vector<MutationObserverRegistration> MutationObserverRegistrationVector;
>+struct MutationObserverData {
>+    WTF_MAKE_NONCOPYABLE(MutationObserverData);
>+    WTF_MAKE_FAST_ALLOCATED;
>+public:
>+    MutationObserverData() { }
>+    ~MutationObserverData() { }
>+
>+    MutationObserverRegistrationVector observers;
>+};
>+#endif // ENABLE(MUTATION_OBSERVERS)
>+
> class NodeRareData {
>     WTF_MAKE_NONCOPYABLE(NodeRareData); WTF_MAKE_FAST_ALLOCATED;
> public:    
>@@ -136,6 +166,16 @@ public:
>         return m_eventTargetData.get();
>     }
> 
>+#if ENABLE(MUTATION_OBSERVERS)
>+    MutationObserverData* mutationObserverData() { return m_mutationObserverData.get(); }
>+    MutationObserverData* ensureMutationObserverData()
>+    {
>+        if (!m_mutationObserverData)
>+            m_mutationObserverData = adoptPtr(new MutationObserverData);
>+        return m_mutationObserverData.get();
>+    }
>+#endif
>+
>     bool isFocused() const { return m_isFocused; }
>     void setFocused(bool focused) { m_isFocused = focused; }
> 
>@@ -152,6 +192,10 @@ private:
>     bool m_tabIndexWasSetExplicitly : 1;
>     bool m_isFocused : 1;
>     bool m_needsFocusAppearanceUpdateSoonAfterAttach : 1;
>+
>+#if ENABLE(MUTATION_OBSERVERS)
>+    OwnPtr<MutationObserverData> m_mutationObserverData;
>+#endif
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/dom/WebKitMutationObserver.cpp b/Source/WebCore/dom/WebKitMutationObserver.cpp
>index 1487364c818294b66e4fe656c0ca90ba84569366..e77f01acaceb4a955d9cf9d59ef29c12b1c6c048 100644
>--- a/Source/WebCore/dom/WebKitMutationObserver.cpp
>+++ b/Source/WebCore/dom/WebKitMutationObserver.cpp
>@@ -34,8 +34,11 @@
> 
> #include "WebKitMutationObserver.h"
> 
>+#include "MutationObserverOptions.h"
> #include "MutationCallback.h"
>-#include "NotImplemented.h"
>+#include "MutationRecord.h"
>+#include "Node.h"
>+#include <wtf/ListHashSet.h>
> 
> namespace WebCore {
> 
>@@ -53,14 +56,70 @@ WebKitMutationObserver::~WebKitMutationObserver()
> {
> }
> 
>-void WebKitMutationObserver::observe(Node*, MutationObserverOptions*)
>+void WebKitMutationObserver::observe(Node* node, MutationObserverOptions* options)
> {
>-    notImplemented();
>+    unsigned char optionFlags = 0;
>+
>+    // FIXME: Push composition of the optionFlags into the custom binding.
>+    if (options->childList())
>+        optionFlags |= ChildList;
>+    if (options->attributes())
>+        optionFlags |= Attributes;
>+    if (options->characterData())
>+        optionFlags |= CharacterData;
>+    // FIXME: More options composition work needs to be done here.
>+
>+    if (node->registerMutationObserver(this, optionFlags) == Node::MutationObserverRegistered)
>+        m_registrations.append(node);
> }
> 
> void WebKitMutationObserver::disconnect()
> {
>-    notImplemented();
>+    for (Vector<Node*>::iterator iter = m_registrations.begin(); iter !=  m_registrations.end(); ++iter)
>+        (*iter)->deregisterMutationObserver(this);
>+
>+    m_registrations.clear();
>+}
>+
>+void WebKitMutationObserver::wasDeregistered(Node* node)
>+{
>+    size_t index = m_registrations.find(node);
>+    ASSERT(index != notFound);
>+    if (index == notFound)
>+        return;
>+
>+    m_registrations.remove(index);
>+}
>+
>+typedef ListHashSet<RefPtr<WebKitMutationObserver> > MutationObserverSet;
>+
>+static MutationObserverSet& activeMutationObservers()
>+{
>+    DEFINE_STATIC_LOCAL(MutationObserverSet, activeObservers, ());
>+    return activeObservers;
>+}
>+
>+void WebKitMutationObserver::enqueueMutationRecord(PassRefPtr<MutationRecord> mutation)
>+{
>+    m_records.append(mutation);
>+    activeMutationObservers().add(this);
>+}
>+
>+void WebKitMutationObserver::deliverAllMutations()
>+{
>+    while (!activeMutationObservers().isEmpty()) {
>+        MutationObserverSet::iterator iter = activeMutationObservers().begin();
>+        RefPtr<WebKitMutationObserver> observer = *iter;
>+        activeMutationObservers().remove(iter);
>+        observer->deliver();
>+    }
>+}
>+
>+void WebKitMutationObserver::deliver()
>+{
>+    MutationRecordArray records;
>+    records.swap(m_records);
>+    m_callback->handleEvent(&records, this);
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/dom/WebKitMutationObserver.h b/Source/WebCore/dom/WebKitMutationObserver.h
>index 087944756b2fc26d144bafa043ac7e82d500b0db..467029b96954e7425e7803f976c5a71a34fb458b 100644
>--- a/Source/WebCore/dom/WebKitMutationObserver.h
>+++ b/Source/WebCore/dom/WebKitMutationObserver.h
>@@ -36,28 +36,52 @@
> #include <wtf/PassOwnPtr.h>
> #include <wtf/RefCounted.h>
> #include <wtf/RefPtr.h>
>+#include <wtf/Vector.h>
> 
> namespace WebCore {
> 
> class MutationCallback;
> class MutationObserverOptions;
>+class MutationRecord;
> class Node;
> 
> class WebKitMutationObserver : public RefCounted<WebKitMutationObserver> {
> public:
>+    enum MutationType {
>+        ChildList = 1 << 0,
>+        Attributes = 1 << 1,
>+        CharacterData = 1 << 2
>+    };
>+
>+    enum OptionFlags {
>+        Subtree = 1 << 3,
>+        AttributeOldValue = 1 << 4,
>+        CharacterDataOldValue = 1 << 5,
>+        AttributeFilter = 1 << 6
>+    };
>+
>     static PassRefPtr<WebKitMutationObserver> create(PassRefPtr<MutationCallback>);
>+    static void deliverAllMutations();
> 
>     ~WebKitMutationObserver();
> 
>     void observe(Node*, MutationObserverOptions*);
>     void disconnect();
>+    void wasDeregistered(Node*);
>+    void enqueueMutationRecord(PassRefPtr<MutationRecord>);
> 
> private:
>     WebKitMutationObserver(PassRefPtr<MutationCallback>);
> 
>+    void deliver();
>+
>     RefPtr<MutationCallback> m_callback;
>+    Vector<RefPtr<MutationRecord> > m_records;
>+    Vector<Node*> m_registrations; // NodeRareData has a RefPtr to this, so use a weak pointer to avoid a cycle.
> };
> 
>+void ensureMutationQueued(PassRefPtr<WebKitMutationObserver> , PassRefPtr<MutationRecord>);
>+
> }
> 
> #endif // ENABLE(MUTATION_OBSERVERS)
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index f8848eaabe0ebb6cd4aec422d5549caf8d3a5f0f..3e326d72da5fc6357a80959d1db3c7c25cd07c41 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,13 @@
>+2011-10-13  Rafael Weinstein  <rafaelw@chromium.org>
>+
>+        [MutationObservers] Implement WebKitMutationObserver.observe for attributes
>+        https://bugs.webkit.org/show_bug.cgi?id=68956
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * fast/mutation/observe-attributes-expected.txt: Added.
>+        * fast/mutation/observe-attributes.html: Added.
>+
> 2011-10-17  Dan Bernstein  <mitz@apple.com>
> 
>         <rdar://problem/10293929> REGRESSION (r97525): iChat transcript has horizontal scroll bar when the conversation includes a wide image
>diff --git a/LayoutTests/fast/mutation/observe-attributes-expected.txt b/LayoutTests/fast/mutation/observe-attributes-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..c8b2f683f9cfb71ae948968401129f295d2cdc26
>--- /dev/null
>+++ b/LayoutTests/fast/mutation/observe-attributes-expected.txt
>@@ -0,0 +1,64 @@
>+Test the constructor of WebKitMutationObserver
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Testing basic aspects of attribute observation.
>+...can attribute changes be observed at all
>+PASS mutations.length is 1
>+PASS mutations[0].type is "attributes"
>+PASS mutations[0].attributeName is "foo"
>+PASS mutations[0].attributeNamespace is null
>+...observer.disconnect() should prevent further delivery of mutations.
>+PASS mutations is null
>+...re-observing after disconnect works with the same observer.
>+PASS mutations.length is 2
>+PASS mutations[0].type is "attributes"
>+PASS mutations[0].attributeName is "foo"
>+PASS mutations[0].attributeNamespace is null
>+PASS mutations[1].type is "attributes"
>+PASS mutations[1].attributeName is "bar"
>+PASS mutations[1].attributeNamespace is null
>+
>+Testing that observing without specifying "attributes" does not result in hearing about attribute changes.
>+PASS mutations is null
>+
>+Testing that re-observing the same node with the same observing has the effect of resetting the options.
>+PASS calls is 1
>+PASS mutations.length is 1
>+PASS mutations[0].type is "attributes"
>+PASS mutations[0].attributeName is "foo"
>+PASS mutations is null
>+
>+Testing that multiple observers can be registered to a given node and both receive mutations.
>+PASS mutations.length is 1
>+PASS mutations[0].type is "attributes"
>+PASS mutations[0].attributeName is "foo"
>+PASS mutations2.length is 1
>+PASS mutations2[0].type is "attributes"
>+PASS mutations2[0].attributeName is "foo"
>+
>+Testing that "attributeNamespace" value is delivered properly.
>+PASS mutations.length is 1
>+PASS mutations[0].type is "attributes"
>+PASS mutations[0].attributeName is "foo"
>+PASS mutations[0].attributeNamespace is "http://www.foo.com/bar"
>+
>+Testing that modifications to node properties which delegate to attribute storage deliver mutations.
>+PASS mutations.length is 2
>+PASS mutations[0].type is "attributes"
>+PASS mutations[0].attributeName is "src"
>+PASS mutations[1].type is "attributes"
>+PASS mutations[1].attributeName is "href"
>+
>+Testing mutation records are enqueued for attributes before DOMSubtreeModified is dispatched.
>+PASS mutations.length is 2
>+PASS mutations[0].type is "attributes"
>+PASS mutations[0].attributeName is "foo"
>+PASS mutations[1].type is "attributes"
>+PASS mutations[1].attributeName is "baz"
>+
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/fast/mutation/observe-attributes.html b/LayoutTests/fast/mutation/observe-attributes.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..58eab818e88176adff3bb5ba27ec805d5e9fef5b
>--- /dev/null
>+++ b/LayoutTests/fast/mutation/observe-attributes.html
>@@ -0,0 +1,322 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+<meta charset="utf-8">
>+<link rel="stylesheet" href="../js/resources/js-test-style.css">
>+<script src="../js/resources/js-test-pre.js"></script>
>+<title></title>
>+</head>
>+<body>
>+<p id=description></p>
>+<div id="console"></div>
>+<script>
>+
>+window.jsTestIsAsync = true;
>+var mutations;
>+var mutations2;
>+var calls;
>+
>+function testBasic() {
>+    var div;
>+    var observer;
>+
>+    function start() {
>+        debug('Testing basic aspects of attribute observation.');
>+
>+        mutations = null;
>+        div = document.createElement('div');
>+        observer = new WebKitMutationObserver(function(m) {
>+            mutations = m;
>+        });
>+
>+        observer.observe(div, { attributes: true, characterData: true });
>+        div.setAttribute('foo', 'bar');
>+        setTimeout(checkDisconnectAndMutate, 0);
>+    }
>+
>+    function checkDisconnectAndMutate() {
>+        debug('...can attribute changes be observed at all');
>+
>+        shouldBe('mutations.length', '1');
>+        shouldBe('mutations[0].type', '"attributes"');
>+        shouldBe('mutations[0].attributeName', '"foo"');
>+        shouldBe('mutations[0].attributeNamespace', 'null');
>+
>+        mutations = null;
>+        observer.disconnect();
>+        div.setAttribute('foo', 'baz');
>+        setTimeout(checkNotDeliveredAndMutateMultiple, 0);
>+    }
>+
>+    function checkNotDeliveredAndMutateMultiple() {
>+        debug('...observer.disconnect() should prevent further delivery of mutations.');
>+
>+        shouldBe('mutations', 'null');
>+        observer.observe(div, { attributes: true });
>+        div.setAttribute('foo', 'bat');
>+        div.setAttribute('bar', 'foo');
>+        setTimeout(finish);
>+    }
>+
>+    function finish() {
>+        debug('...re-observing after disconnect works with the same observer.');
>+
>+        shouldBe('mutations.length', '2');
>+        shouldBe('mutations[0].type', '"attributes"');
>+        shouldBe('mutations[0].attributeName', '"foo"');
>+        shouldBe('mutations[0].attributeNamespace', 'null');
>+        shouldBe('mutations[1].type', '"attributes"');
>+        shouldBe('mutations[1].attributeName', '"bar"');
>+        shouldBe('mutations[1].attributeNamespace', 'null');
>+        observer.disconnect();
>+        debug('');
>+        runNextTest();
>+    }
>+
>+    start();
>+}
>+
>+function testWrongType() {
>+    var div;
>+    var observer;
>+
>+    function start() {
>+        debug('Testing that observing without specifying "attributes" does not result in hearing about attribute changes.');
>+
>+        mutations = null;
>+        div = document.createElement('div');
>+        observer = new WebKitMutationObserver(function(m) {
>+            mutations = m;
>+        });
>+
>+        observer.observe(div, { childList: true, characterData: true });
>+        div.setAttribute('foo', 'bar');
>+        setTimeout(finish, 0);
>+    }
>+
>+    function finish() {
>+        shouldBe('mutations', 'null');
>+        observer.disconnect();
>+        debug('');
>+        runNextTest();
>+    }
>+
>+    start();
>+}
>+
>+function testMultipleRegistration() {
>+    var div;
>+    var observer;
>+
>+    function start() {
>+        debug('Testing that re-observing the same node with the same observing has the effect of resetting the options.');
>+    
>+		calls = 0;
>+        mutations = null;
>+        div = document.createElement('div');
>+        observer = new WebKitMutationObserver(function(m) {
>+            mutations = m;
>+			calls++;
>+        });
>+
>+        observer.observe(div, { attributes: true, characterData: true });
>+        observer.observe(div, { attributes: true });
>+        div.setAttribute('foo', 'bar');
>+        setTimeout(checkDisconnectAndMutate, 0);
>+    }
>+
>+    function checkDisconnectAndMutate() {
>+        shouldBe('calls', '1');
>+        shouldBe('mutations.length', '1');
>+        shouldBe('mutations[0].type', '"attributes"');
>+        shouldBe('mutations[0].attributeName', '"foo"');
>+        mutations = null;
>+        observer.observe(div, { attributes: true, characterData: true });
>+        observer.observe(div, { childList: true });
>+        div.setAttribute('foo', 'baz');
>+        setTimeout(finish, 0);
>+    }
>+
>+    function finish() {
>+        shouldBe('mutations', 'null');
>+        observer.disconnect();
>+        debug('');
>+        runNextTest();
>+    }
>+
>+    start();
>+}
>+
>+function testMultipleObservers() {
>+    var div;
>+    var observer;
>+    var observer2;
>+
>+    function start() {
>+        debug('Testing that multiple observers can be registered to a given node and both receive mutations.');
>+        mutations = null;
>+        div = document.createElement('div');
>+        observer = new WebKitMutationObserver(function(m) {
>+            mutations = m;
>+        });
>+        observer2 = new WebKitMutationObserver(function(m) {
>+            mutations2 = m;
>+        });
>+        observer.observe(div, { attributes: true });
>+        observer2.observe(div, { attributes: true });
>+        div.setAttribute('foo', 'bar');
>+        setTimeout(finish, 0);
>+    }
>+
>+    function finish() {
>+        shouldBe('mutations.length', '1');
>+        shouldBe('mutations[0].type', '"attributes"');
>+        shouldBe('mutations[0].attributeName', '"foo"');
>+        shouldBe('mutations2.length', '1');
>+        shouldBe('mutations2[0].type', '"attributes"');
>+        shouldBe('mutations2[0].attributeName', '"foo"');
>+        observer.disconnect();
>+        observer2.disconnect();
>+        debug('');
>+        runNextTest();
>+    }
>+
>+    start();
>+}
>+
>+function testNamespaceURI() {
>+    var div;
>+    var observer;
>+
>+    function start() {
>+        debug('Testing that "attributeNamespace" value is delivered properly.');
>+        mutations = null;
>+        div = document.createElement('div');
>+        observer = new WebKitMutationObserver(function(m) {
>+            mutations = m;
>+        });
>+
>+        observer.observe(div, { attributes: true, childList: true });
>+        div.setAttributeNS('http://www.foo.com/bar', 'foo', 'bar');
>+        setTimeout(finish, 0);    
>+    }
>+
>+    function finish() {
>+        shouldBe('mutations.length', '1');
>+        shouldBe('mutations[0].type', '"attributes"');
>+        shouldBe('mutations[0].attributeName', '"foo"');
>+        shouldBe('mutations[0].attributeNamespace', '"http://www.foo.com/bar"');        
>+        observer.disconnect();
>+        debug('');
>+        runNextTest();
>+    }
>+
>+    start();
>+}
>+
>+function testPropertyAccess() {
>+    var img, a;
>+    var observer;
>+
>+    function start() {
>+        debug('Testing that modifications to node properties which delegate to attribute storage deliver mutations.');
>+        mutations = null;
>+        img = document.createElement('img');
>+        a = document.createElement('a');
>+
>+        observer = new WebKitMutationObserver(function(m) {
>+            mutations = m;
>+        });
>+
>+        observer.observe(img, { attributes: true });
>+        observer.observe(a, { attributes: true });
>+
>+        img.src = 'baz.png';
>+        a.href = 'foo.html';
>+
>+        setTimeout(finish, 0);
>+    }
>+
>+    function finish() {
>+        shouldBe('mutations.length', '2');
>+        shouldBe('mutations[0].type', '"attributes"');
>+        shouldBe('mutations[0].attributeName', '"src"');
>+        shouldBe('mutations[1].type', '"attributes"');
>+        shouldBe('mutations[1].attributeName', '"href"');
>+        observer.disconnect();
>+        debug('');
>+        runNextTest();
>+    }
>+
>+    start();
>+}
>+
>+function testOrderingWrtDOMSubtreeModified() {
>+    var div, div2, subDiv;
>+    var observer;
>+    var listener;
>+
>+    function start() {
>+        debug('Testing mutation records are enqueued for attributes before DOMSubtreeModified is dispatched.');
>+
>+        mutations = null;
>+        div = document.body.appendChild(document.createElement('div'));
>+        div2 = document.body.appendChild(document.createElement('div'));
>+
>+        subDiv = div.appendChild(document.createElement('div'));
>+
>+        observer = new WebKitMutationObserver(function(m) {
>+            mutations = m;
>+        });
>+
>+        listener = function(e) {
>+            div2.setAttribute('baz', 'bat');
>+        }
>+
>+        div.addEventListener('DOMSubtreeModified', listener);
>+        observer.observe(subDiv, { attributes: true });
>+        observer.observe(div2, { attributes: true });
>+
>+        subDiv.setAttribute('foo', 'bar');
>+
>+        setTimeout(finish, 0);
>+    }
>+
>+    function finish() {
>+        shouldBe('mutations.length', '2');
>+        shouldBe('mutations[0].type', '"attributes"');
>+        shouldBe('mutations[0].attributeName', '"foo"');
>+        shouldBe('mutations[1].type', '"attributes"');
>+        shouldBe('mutations[1].attributeName', '"baz"');
>+        div.removeEventListener(listener);
>+        document.body.removeChild(div);
>+        observer.disconnect();
>+        debug('');
>+        runNextTest();
>+    }
>+
>+    start();
>+}
>+var tests = [testBasic, testWrongType, testMultipleRegistration, testMultipleObservers, testNamespaceURI, testPropertyAccess, testOrderingWrtDOMSubtreeModified];
>+var testIndex = 0;
>+ 
>+function runNextTest() {
>+    if (testIndex < tests.length)
>+        tests[testIndex++]();
>+    else
>+        finishJSTest();
>+}
>+
>+description('Test the constructor of WebKitMutationObserver');
>+
>+if (!window.WebKitMutationObserver)
>+    testFailed('This test requires ENABLE(MUTATION_OBSERVERS)');
>+else
>+    runNextTest();
>+
>+var successfullyParsed = true;
>+
>+</script>
>+<script src="../js/resources/js-test-post.js"></script>
>+</body>
>+</html>

Actions: View | Formatted Diff | Diff

Attachments on bug 68956: 110865 | 110906 | 110952 | 111047 | 111301 | 111326 | 111330