Source/WebCore/ChangeLog

 12011-10-26 Adam Klein <adamk@chromium.org>
 2
 3 [MutationObservers] Support attributeOldValue for attribute mutations
 4 https://bugs.webkit.org/show_bug.cgi?id=70861
 5
 6 Reviewed by NOBODY (OOPS!).
 7
 8 Respect 'attributeOldValue' when passed to WebKitMutationObserver.observe().
 9
 10 If multiple observers have different attributeOldValue settings in
 11 their registrations, two different MutationRecords are created (one is
 12 a wrapper around the other).
 13
 14 If a single observer has multiple registrations that apply to a single
 15 mutation, and those registrations have different values for
 16 attributeOldValue, the observer is passed the oldValue.
 17
 18 * dom/Element.cpp:
 19 (WebCore::hasOldValue):
 20 (WebCore::enqueueAttributesMutationRecord):
 21 (WebCore::Element::setAttribute):
 22 * dom/MutationRecord.cpp:
 23 (WebCore::MutationRecord::createAttributes):
 24 (WebCore::MutationRecord::createWithNullOldValue):
 25 * dom/MutationRecord.h:
 26 (WebCore::MutationRecord::oldValue):
 27
1282011-10-27 Rafael Weinstein <rafaelw@chromium.org>
229
330 [MutationObservers] Implement subtree observation of transiently disconnected nodes

Source/WebCore/dom/Element.cpp

@@const AtomicString& Element::getAttributeNS(const String& namespaceURI, const St
617617}
618618
619619#if ENABLE(MUTATION_OBSERVERS)
620 static void enqueueAttributesMutationRecord(Element* element, const QualifiedName& name)
 620static inline bool hasOldValue(MutationObserverOptions options)
 621{
 622 return options & WebKitMutationObserver::AttributeOldValue;
 623}
 624
 625static inline bool isOldValueRequested(const HashMap<WebKitMutationObserver*, MutationObserverOptions>& observers)
 626{
 627 for (HashMap<WebKitMutationObserver*, MutationObserverOptions>::const_iterator iter = observers.begin(); iter != observers.end(); ++iter) {
 628 if (hasOldValue(iter->second))
 629 return true;
 630 }
 631 return false;
 632}
 633
 634static void enqueueAttributesMutationRecord(Element* element, const QualifiedName& name, const AtomicString& oldValue)
621635{
622636 HashMap<WebKitMutationObserver*, MutationObserverOptions> observers;
623637 element->getRegisteredMutationObserversOfType(observers, WebKitMutationObserver::Attributes);
624638 if (observers.isEmpty())
625639 return;
626640
627  RefPtr<MutationRecord> mutation = MutationRecord::createAttributes(element, name);
 641 RefPtr<MutationRecord> mutation = MutationRecord::createAttributes(element, name, isOldValueRequested(observers) ? oldValue : nullAtom);
 642 RefPtr<MutationRecord> mutationWithNullOldValue = MutationRecord::createWithNullOldValue(mutation);
628643 for (HashMap<WebKitMutationObserver*, MutationObserverOptions>::iterator iter = observers.begin(); iter != observers.end(); ++iter)
629  iter->first->enqueueMutationRecord(mutation);
 644 iter->first->enqueueMutationRecord(hasOldValue(iter->second) ? mutation : mutationWithNullOldValue);
630645}
631646#endif
632647

@@void Element::setAttribute(const AtomicString& name, const AtomicString& value,
652667
653668#if ENABLE(MUTATION_OBSERVERS)
654669 // The call to attributeChanged below may dispatch DOMSubtreeModified, so it's important to enqueue a MutationRecord now.
655  enqueueAttributesMutationRecord(this, attributeName);
 670 enqueueAttributesMutationRecord(this, attributeName, old ? old->value() : nullAtom);
656671#endif
657672
658673 if (isIdAttributeName(old ? old->name() : attributeName))

@@void Element::setAttribute(const QualifiedName& name, const AtomicString& value,
690705
691706#if ENABLE(MUTATION_OBSERVERS)
692707 // The call to attributeChanged below may dispatch DOMSubtreeModified, so it's important to enqueue a MutationRecord now.
693  enqueueAttributesMutationRecord(this, name);
 708 enqueueAttributesMutationRecord(this, name, old ? old->value() : nullAtom);
694709#endif
695710
696711 if (isIdAttributeName(name))

Source/WebCore/dom/MutationRecord.cpp

@@namespace WebCore {
4444
4545namespace {
4646
47 class ChildListRecord : public MutationRecord {
 47class MutationRecordBase : public MutationRecord {
 48public:
 49 MutationRecordBase(PassRefPtr<Node> target)
 50 : m_target(target)
 51 {
 52 }
 53
 54 virtual Node* target() { return m_target.get(); }
 55
 56private:
 57 RefPtr<Node> m_target;
 58};
 59
 60class ChildListRecord : public MutationRecordBase {
4861public:
4962 ChildListRecord(PassRefPtr<Node> target, PassRefPtr<NodeList> added, PassRefPtr<NodeList> removed, PassRefPtr<Node> previousSibling, PassRefPtr<Node> nextSibling)
50  : MutationRecord(target)
 63 : MutationRecordBase(target)
5164 , m_addedNodes(added)
5265 , m_removedNodes(removed)
5366 , m_previousSibling(previousSibling)

@@private:
6881 RefPtr<Node> m_nextSibling;
6982};
7083
71 class AttributesRecord : public MutationRecord {
 84class AttributesRecord : public MutationRecordBase {
7285public:
73  AttributesRecord(PassRefPtr<Node> target, const QualifiedName& name)
74  : MutationRecord(target)
 86 AttributesRecord(PassRefPtr<Node> target, const QualifiedName& name, const AtomicString& oldValue)
 87 : MutationRecordBase(target)
7588 , m_attributeName(name.localName())
7689 , m_attributeNamespace(name.namespaceURI())
 90 , m_oldValue(oldValue)
7791 {
7892 }
7993

@@private:
8296 virtual const AtomicString& attributeName() { return m_attributeName; }
8397 virtual const AtomicString& attributeNamespace() { return m_attributeNamespace; }
8498 virtual String oldValue() { return m_oldValue; }
85  virtual void setOldValue(const String& value) { m_oldValue = value; }
8699
87100 AtomicString m_attributeName;
88101 AtomicString m_attributeNamespace;
89  String m_oldValue;
 102 AtomicString m_oldValue;
90103};
91104
92 class CharacterDataRecord : public MutationRecord {
 105class CharacterDataRecord : public MutationRecordBase {
93106public:
94107 CharacterDataRecord(PassRefPtr<Node> target)
95  : MutationRecord(target)
 108 : MutationRecordBase(target)
96109 {
97110 }
98111
99112private:
100113 virtual const AtomicString& type();
101  virtual String oldValue() { return m_oldValue; }
102  virtual void setOldValue(const String& value) { m_oldValue = value; }
 114};
103115
104  String m_oldValue;
 116class MutationRecordWithNullOldValue : public MutationRecord {
 117public:
 118 MutationRecordWithNullOldValue(PassRefPtr<MutationRecord> record)
 119 : m_record(record)
 120 {
 121 }
 122
 123private:
 124 virtual const AtomicString& type() { return m_record->type(); }
 125 virtual Node* target() { return m_record->target(); }
 126 virtual NodeList* addedNodes() { return m_record->addedNodes(); }
 127 virtual NodeList* removedNodes() { return m_record->removedNodes(); }
 128 virtual Node* previousSibling() { return m_record->previousSibling(); }
 129 virtual Node* nextSibling() { return m_record->nextSibling(); }
 130 virtual const AtomicString& attributeName() { return m_record->attributeName(); }
 131 virtual const AtomicString& attributeNamespace() { return m_record->attributeNamespace(); }
 132
 133 virtual String oldValue() { return String(); }
 134
 135 RefPtr<MutationRecord> m_record;
105136};
106137
107138const AtomicString& ChildListRecord::type()

@@PassRefPtr<MutationRecord> MutationRecord::createChildList(PassRefPtr<Node> targ
129160 return adoptRef(static_cast<MutationRecord*>(new ChildListRecord(target, added, removed, previousSibling, nextSibling)));
130161}
131162
132 PassRefPtr<MutationRecord> MutationRecord::createAttributes(PassRefPtr<Node> target, const QualifiedName& name)
 163PassRefPtr<MutationRecord> MutationRecord::createAttributes(PassRefPtr<Node> target, const QualifiedName& name, const AtomicString& oldValue)
133164{
134  return adoptRef(static_cast<MutationRecord*>(new AttributesRecord(target, name)));
 165 return adoptRef(static_cast<MutationRecord*>(new AttributesRecord(target, name, oldValue)));
135166}
136167
137168PassRefPtr<MutationRecord> MutationRecord::createCharacterData(PassRefPtr<Node> target)

@@PassRefPtr<MutationRecord> MutationRecord::createCharacterData(PassRefPtr<Node>
139170 return adoptRef(static_cast<MutationRecord*>(new CharacterDataRecord(target)));
140171}
141172
142 MutationRecord::MutationRecord(PassRefPtr<Node> target)
143  : m_target(target)
 173PassRefPtr<MutationRecord> MutationRecord::createWithNullOldValue(PassRefPtr<MutationRecord> record)
144174{
 175 if (record->oldValue().isNull())
 176 return record;
 177 return adoptRef(static_cast<MutationRecord*>(new MutationRecordWithNullOldValue(record)));
145178}
146179
147180MutationRecord::~MutationRecord()

Source/WebCore/dom/MutationRecord.h

@@class QualifiedName;
4747class MutationRecord : public RefCounted<MutationRecord> {
4848public:
4949 static PassRefPtr<MutationRecord> createChildList(PassRefPtr<Node> target, PassRefPtr<NodeList> added, PassRefPtr<NodeList> removed, PassRefPtr<Node> previousSibling, PassRefPtr<Node> nextSibling);
50  static PassRefPtr<MutationRecord> createAttributes(PassRefPtr<Node> target, const QualifiedName&);
 50 static PassRefPtr<MutationRecord> createAttributes(PassRefPtr<Node> target, const QualifiedName&, const AtomicString& oldValue);
5151 static PassRefPtr<MutationRecord> createCharacterData(PassRefPtr<Node> target);
5252
 53 static PassRefPtr<MutationRecord> createWithNullOldValue(PassRefPtr<MutationRecord>);
 54
5355 virtual ~MutationRecord();
5456
5557 virtual const AtomicString& type() = 0;
56  Node* target() { return m_target.get(); }
 58 virtual Node* target() = 0;
5759
5860 virtual NodeList* addedNodes() { return 0; }
5961 virtual NodeList* removedNodes() { return 0; }

@@public:
6466 virtual const AtomicString& attributeNamespace() { return nullAtom; }
6567
6668 virtual String oldValue() { return String(); }
67  virtual void setOldValue(const String&) { }
68 
69 protected:
70  explicit MutationRecord(PassRefPtr<Node> target);
71 
72 private:
73  RefPtr<Node> m_target;
7469};
7570
76 
7771} // namespace WebCore
7872
7973#endif // ENABLE(MUTATION_OBSERVERS)

LayoutTests/ChangeLog

 12011-10-26 Adam Klein <adamk@chromium.org>
 2
 3 [MutationObservers] Support attributeOldValue for attribute mutations
 4 https://bugs.webkit.org/show_bug.cgi?id=70861
 5
 6 Reviewed by NOBODY (OOPS!).
 7
 8 Added test cases for attributeOldValue to existing tests.
 9
 10 * fast/mutation/observe-attributes-expected.txt:
 11 * fast/mutation/observe-attributes.html:
 12
1132011-10-27 Rafael Weinstein <rafaelw@chromium.org>
214
315 [MutationObservers] Implement subtree observation of transiently disconnected nodes

LayoutTests/fast/mutation/observe-attributes-expected.txt

@@PASS mutations[0].attributeName is "foo"
5858PASS mutations[1].type is "attributes"
5959PASS mutations[1].attributeName is "baz"
6060
 61Testing basic oldValue delivery.
 62PASS mutations.length is 2
 63PASS mutations[0].type is "attributes"
 64PASS mutations[0].attributeName is "foo"
 65PASS mutations[0].oldValue is null
 66PASS mutations[1].type is "attributes"
 67PASS mutations[1].attributeName is "foo"
 68PASS mutations[1].oldValue is "bar"
 69
 70Testing that oldValue is delivered as requested (or not).
 71PASS mutations.length is 1
 72PASS mutations[0].type is "attributes"
 73PASS mutations[0].attributeName is "foo"
 74PASS mutations[0].oldValue is "bar"
 75PASS mutations2.length is 1
 76PASS mutations2[0].type is "attributes"
 77PASS mutations2[0].attributeName is "foo"
 78PASS mutations2[0].oldValue is null
 79
 80An observer with multiple observations will get attributeOldValue if any entries request it.
 81PASS mutations.length is 1
 82PASS mutations[0].type is "attributes"
 83PASS mutations[0].attributeName is "foo"
 84PASS mutations[0].oldValue is "bar"
 85
6186PASS successfullyParsed is true
6287
6388TEST COMPLETE

LayoutTests/fast/mutation/observe-attributes.html

@@function testOrderingWrtDOMSubtreeModified() {
294294
295295 start();
296296}
297 var tests = [testBasic, testWrongType, testMultipleRegistration, testMultipleObservers, testNamespaceURI, testPropertyAccess, testOrderingWrtDOMSubtreeModified];
 297
 298function testOldValue() {
 299 var div;
 300 var observer;
 301
 302 function start() {
 303 debug('Testing basic oldValue delivery.');
 304 mutations = null;
 305 div = document.createElement('div');
 306 observer = new WebKitMutationObserver(function(mutations) {
 307 window.mutations = mutations;
 308 });
 309 observer.observe(div, { attributes: true, attributeOldValue: true });
 310 div.setAttribute('foo', 'bar');
 311 div.setAttribute('foo', 'baz');
 312 setTimeout(finish, 0);
 313 }
 314
 315 function finish() {
 316 shouldBe('mutations.length', '2');
 317 shouldBe('mutations[0].type', '"attributes"');
 318 shouldBe('mutations[0].attributeName', '"foo"');
 319 shouldBe('mutations[0].oldValue', 'null');
 320 shouldBe('mutations[1].type', '"attributes"');
 321 shouldBe('mutations[1].attributeName', '"foo"');
 322 shouldBe('mutations[1].oldValue', '"bar"');
 323 observer.disconnect();
 324 debug('');
 325 runNextTest();
 326 }
 327
 328 start();
 329}
 330
 331function testOldValueAsRequested() {
 332 var div;
 333 var observer;
 334 var observer2;
 335
 336 function start() {
 337 debug('Testing that oldValue is delivered as requested (or not).');
 338 mutations = null;
 339 div = document.createElement('div');
 340 div.setAttribute('foo', 'bar');
 341 observer = new WebKitMutationObserver(function(mutations) {
 342 window.mutations = mutations;
 343 });
 344 observer2 = new WebKitMutationObserver(function(mutations) {
 345 window.mutations2 = mutations;
 346 });
 347 observer.observe(div, { attributes: true, attributeOldValue: true });
 348 observer2.observe(div, { attributes: true });
 349 div.setAttribute('foo', 'baz');
 350 setTimeout(finish, 0);
 351 }
 352
 353 function finish() {
 354 shouldBe('mutations.length', '1');
 355 shouldBe('mutations[0].type', '"attributes"');
 356 shouldBe('mutations[0].attributeName', '"foo"');
 357 shouldBe('mutations[0].oldValue', '"bar"');
 358 shouldBe('mutations2.length', '1');
 359 shouldBe('mutations2[0].type', '"attributes"');
 360 shouldBe('mutations2[0].attributeName', '"foo"');
 361 shouldBe('mutations2[0].oldValue', 'null');
 362 observer.disconnect();
 363 observer2.disconnect();
 364 debug('');
 365 runNextTest();
 366 }
 367
 368 start();
 369}
 370
 371function testOldValueUnionMultipleObservations() {
 372 var div;
 373 var span;
 374 var observer;
 375
 376 function start() {
 377 debug('An observer with multiple observations will get attributeOldValue if any entries request it.');
 378 mutations = null;
 379 div = document.createElement('div');
 380 span = div.appendChild(document.createElement('span'));
 381 span.setAttribute('foo', 'bar');
 382 observer = new WebKitMutationObserver(function(mutations) {
 383 window.mutations = mutations;
 384 });
 385 observer.observe(div, { attributes: true, attributeOldValue: true, subtree: true });
 386 observer.observe(span, { attributes: true });
 387 span.setAttribute('foo', 'baz');
 388 setTimeout(finish, 0);
 389 }
 390
 391 function finish() {
 392 shouldBe('mutations.length', '1');
 393 shouldBe('mutations[0].type', '"attributes"');
 394 shouldBe('mutations[0].attributeName', '"foo"');
 395 shouldBe('mutations[0].oldValue', '"bar"');
 396 observer.disconnect();
 397 debug('');
 398 runNextTest();
 399 }
 400
 401 start();
 402}
 403
 404var tests = [
 405 testBasic,
 406 testWrongType,
 407 testMultipleRegistration,
 408 testMultipleObservers,
 409 testNamespaceURI,
 410 testPropertyAccess,
 411 testOrderingWrtDOMSubtreeModified,
 412 testOldValue,
 413 testOldValueAsRequested,
 414 testOldValueUnionMultipleObservations
 415];
298416var testIndex = 0;
299 
 417
300418function runNextTest() {
301419 if (testIndex < tests.length)
302420 tests[testIndex++]();