Attachment #38543 for bug #28709

View Details Raw Unified Return to Bug 28709

| Differences between



2009-08-25  Vitaly Repeshko  <vitalyr@chromium.org>

        Reviewed by NOBODY (OOPS!).

        WebCore: Make both Node::setAttributeEventListener and
        Node::setOnEvent forward listener to DOM window when necessary.

        Before this patch only Node::setOnEvent functions did the forwarding
        which broke Node::setAttributeEventListener clients.

	https://bugs.webkit.org/show_bug.cgi?id=28709

        Uses already existing tests from http://trac.webkit.org/changeset/47326

        * dom/Node.cpp:
        (WebCore::Node::clearAttributeEventListener):
        (WebCore::Node::setAttributeEventListener):
        (WebCore::Node::getAttributeEventListener):
	Now call shouldForwardEventListenerToWindow to determine if
	listener should be forwarded to DOM window.
        * dom/Node.h:
        (WebCore::Node::shouldForwardEventListenerToWindow):
	New virtual function overridden by HTMLBodyElement and HTMLFrameSetElement.
	Returns false by default.
        * html/HTMLBodyElement.cpp:
        (WebCore::HTMLBodyElement::shouldForwardEventListenerToWindow):
        * html/HTMLBodyElement.h:
        * html/HTMLFrameSetElement.cpp:
        (WebCore::HTMLFrameSetElement::setOnhashchange):
        (WebCore::HTMLFrameSetElement::shouldForwardEventListenerToWindow):
        * html/HTMLFrameSetElement.h:

2009-08-24  Pavel Feldman  <pfeldman@chromium.org>

        Reviewed by Timothy Hatcher.

Lines 2906-2911 void Node::dispatchProgressEvent(const AtomicString &eventType, bool lengthCompu a/WebCore/dom/Node.cpp_sec1
- a/WebCore/dom/Node.cpp +21 lines
2906		2906
2907	void Node::clearAttributeEventListener(const AtomicString& eventType)	2907	void Node::clearAttributeEventListener(const AtomicString& eventType)
2908	{	2908	{
		2909	if (shouldForwardEventListenerToWindow(eventType)) {
		2910	DOMWindow* window = document()->domWindow();
		2911	if (window)
		2912	window->clearAttributeEventListener(eventType);
		2913	return;
		2914	}
		2915
2909	if (!hasRareData())	2916	if (!hasRareData())
2910	return;	2917	return;
2911		2918
Lines 2933-2938 void Node::clearAttributeEventListener(const AtomicString& eventType) a/WebCore/dom/Node.cpp_sec2
2933		2940
2934	void Node::setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)	2941	void Node::setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
2935	{	2942	{
		2943	if (shouldForwardEventListenerToWindow(eventType)) {
		2944	DOMWindow* window = document()->domWindow();
		2945	if (window)
		2946	window->setAttributeEventListener(eventType, listener);
		2947	return;
		2948	}
		2949
2936	clearAttributeEventListener(eventType);	2950	clearAttributeEventListener(eventType);
2937	if (listener)	2951	if (listener)
2938	addEventListener(eventType, listener, false);	2952	addEventListener(eventType, listener, false);
Lines 2940-2945 void Node::setAttributeEventListener(const AtomicString& eventType, PassRefPtr<E a/WebCore/dom/Node.cpp_sec3
2940		2954
2941	EventListener* Node::getAttributeEventListener(const AtomicString& eventType) const	2955	EventListener* Node::getAttributeEventListener(const AtomicString& eventType) const
2942	{	2956	{
		2957	if (shouldForwardEventListenerToWindow(eventType)) {
		2958	DOMWindow* window = document()->domWindow();
		2959	if (window)
		2960	return window->getAttributeEventListener(eventType);
		2961	return 0;
		2962	}
		2963
2943	const RegisteredEventListenerVector& listeners = eventListeners();	2964	const RegisteredEventListenerVector& listeners = eventListeners();
2944	size_t size = listeners.size();	2965	size_t size = listeners.size();
2945	for (size_t i = 0; i < size; ++i) {	2966	for (size_t i = 0; i < size; ++i) {



    virtual void removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture);

    // Used for legacy "onEvent" property APIs.
    //
    // If shouldForwardEventListenerToWindow below returns true for the given event type, then the listener is forwarded
    // to DOM window.
    void setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener>);
    void clearAttributeEventListener(const AtomicString& eventType);
    EventListener* getAttributeEventListener(const AtomicString& eventType) const;


    const RegisteredEventListenerVector& eventListeners() const;

    EventListener* onblur() const;
    void setOnblur(PassRefPtr<EventListener>);
    EventListener* onerror() const;
    void setOnerror(PassRefPtr<EventListener>);
    EventListener* onfocus() const;
    void setOnfocus(PassRefPtr<EventListener>);
    EventListener* onload() const;
    void setOnload(PassRefPtr<EventListener>);
    virtual EventListener* onload() const;
    virtual void setOnload(PassRefPtr<EventListener>);

    EventListener* onabort() const;
    void setOnabort(PassRefPtr<EventListener>);
    EventListener* onchange() const;


    virtual void willMoveToNewOwnerDocument();
    virtual void didMoveToNewOwnerDocument();

    // Overridden by HTMLBodyElement and HTMLFrameSetElement to forward certain event listener types to DOM window.
    virtual bool shouldForwardEventListenerToWindow(const AtomicString& eventType) const { return false; }

    virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const { }
    void setTabIndexExplicitly(short);
    



#include "MappedAttribute.h"
#include "ScriptEventListener.h"

#include <wtf/HashSet.h>

namespace WebCore {

using namespace HTMLNames;

    HTMLElement::didMoveToNewOwnerDocument();
}

EventListener* HTMLBodyElement::onblur() const
{
    return document()->getWindowAttributeEventListener(eventNames().blurEvent);
}

void HTMLBodyElement::setOnblur(PassRefPtr<EventListener> eventListener)
{
    document()->setWindowAttributeEventListener(eventNames().blurEvent, eventListener);
}

EventListener* HTMLBodyElement::onerror() const
{
    return document()->getWindowAttributeEventListener(eventNames().errorEvent);
}

void HTMLBodyElement::setOnerror(PassRefPtr<EventListener> eventListener)
{
    document()->setWindowAttributeEventListener(eventNames().errorEvent, eventListener);
}

EventListener* HTMLBodyElement::onfocus() const
{
    return document()->getWindowAttributeEventListener(eventNames().focusEvent);
}

void HTMLBodyElement::setOnfocus(PassRefPtr<EventListener> eventListener)
{
    document()->setWindowAttributeEventListener(eventNames().focusEvent, eventListener);
}

EventListener* HTMLBodyElement::onload() const
{
    return document()->getWindowAttributeEventListener(eventNames().loadEvent);
}

void HTMLBodyElement::setOnload(PassRefPtr<EventListener> eventListener)
{
    document()->setWindowAttributeEventListener(eventNames().loadEvent, eventListener);
}

EventListener* HTMLBodyElement::onbeforeunload() const
{
    return document()->getWindowAttributeEventListener(eventNames().beforeunloadEvent);

    document()->setWindowAttributeEventListener(eventNames().unloadEvent, eventListener);
}

bool HTMLBodyElement::shouldForwardEventListenerToWindow(const AtomicString& eventType) const
{
    DEFINE_STATIC_LOCAL(HashSet<AtomicString>, forwardTypes, ());
    if (forwardTypes.isEmpty()) {
        forwardTypes.add(eventNames().focusEvent);
        forwardTypes.add(eventNames().blurEvent);
        forwardTypes.add(eventNames().errorEvent);
        forwardTypes.add(eventNames().loadEvent);
        forwardTypes.add(eventNames().unloadEvent);
        forwardTypes.add(eventNames().beforeunloadEvent);
        forwardTypes.add(eventNames().messageEvent);
        forwardTypes.add(eventNames().offlineEvent);
        forwardTypes.add(eventNames().onlineEvent);
        forwardTypes.add(eventNames().resizeEvent);
        forwardTypes.add(eventNames().storageEvent);
        forwardTypes.add(eventNames().unloadEvent);
        forwardTypes.add(eventNames().hashchangeEvent);
    }
    return forwardTypes.contains(eventType);
}

} // namespace WebCore



    String vLink() const;
    void setVLink(const String&);

    virtual EventListener* onblur() const;
    virtual void setOnblur(PassRefPtr<EventListener>);
    virtual EventListener* onerror() const;
    virtual void setOnerror(PassRefPtr<EventListener>);
    virtual EventListener* onfocus() const;
    virtual void setOnfocus(PassRefPtr<EventListener>);
    virtual EventListener* onload() const;
    virtual void setOnload(PassRefPtr<EventListener>);

    EventListener* onbeforeunload() const;
    void setOnbeforeunload(PassRefPtr<EventListener>);
    EventListener* onmessage() const;

    EventListener* onunload() const;
    void setOnunload(PassRefPtr<EventListener>);

protected:
    virtual bool shouldForwardEventListenerToWindow(const AtomicString& eventType) const;

private:
    virtual HTMLTagStatus endTagRequirement() const { return TagStatusRequired; }
    virtual int tagPriority() const { return 10; }



    setAttribute(rowsAttr, value);
}

EventListener* HTMLFrameSetElement::onblur() const
{
    return document()->getWindowAttributeEventListener(eventNames().blurEvent);
}

void HTMLFrameSetElement::setOnblur(PassRefPtr<EventListener> eventListener)
{
    document()->setWindowAttributeEventListener(eventNames().blurEvent, eventListener);
}

EventListener* HTMLFrameSetElement::onerror() const
{
    return document()->getWindowAttributeEventListener(eventNames().errorEvent);
}

void HTMLFrameSetElement::setOnerror(PassRefPtr<EventListener> eventListener)
{
    document()->setWindowAttributeEventListener(eventNames().errorEvent, eventListener);
}

EventListener* HTMLFrameSetElement::onfocus() const
{
    return document()->getWindowAttributeEventListener(eventNames().focusEvent);
}

void HTMLFrameSetElement::setOnfocus(PassRefPtr<EventListener> eventListener)
{
    document()->setWindowAttributeEventListener(eventNames().focusEvent, eventListener);
}

EventListener* HTMLFrameSetElement::onhashchange() const
{
    return document()->getWindowAttributeEventListener(eventNames().hashchangeEvent);

void HTMLFrameSetElement::setOnhashchange(PassRefPtr<EventListener> eventListener)
{
    document()->setWindowAttributeEventListener(eventNames().hashchangeEvent, eventListener);
}   

EventListener* HTMLFrameSetElement::onload() const
{
    return document()->getWindowAttributeEventListener(eventNames().loadEvent);
}

void HTMLFrameSetElement::setOnload(PassRefPtr<EventListener> eventListener)
{
    document()->setWindowAttributeEventListener(eventNames().loadEvent, eventListener);
}

EventListener* HTMLFrameSetElement::onbeforeunload() const

    document()->setWindowAttributeEventListener(eventNames().unloadEvent, eventListener);
}

bool HTMLFrameSetElement::shouldForwardEventListenerToWindow(const AtomicString& eventType) const
{
    DEFINE_STATIC_LOCAL(HashSet<AtomicString>, forwardTypes, ());
    if (forwardTypes.isEmpty()) {
        forwardTypes.add(eventNames().focusEvent);
        forwardTypes.add(eventNames().blurEvent);
        forwardTypes.add(eventNames().errorEvent);
        forwardTypes.add(eventNames().loadEvent);
        forwardTypes.add(eventNames().unloadEvent);
        forwardTypes.add(eventNames().beforeunloadEvent);
        forwardTypes.add(eventNames().messageEvent);
        forwardTypes.add(eventNames().offlineEvent);
        forwardTypes.add(eventNames().onlineEvent);
        forwardTypes.add(eventNames().resizeEvent);
        forwardTypes.add(eventNames().storageEvent);
        forwardTypes.add(eventNames().unloadEvent);
        forwardTypes.add(eventNames().hashchangeEvent);
    }
    return forwardTypes.contains(eventType);
}



} // namespace WebCore



    const Length* rowLengths() const { return m_rows; }
    const Length* colLengths() const { return m_cols; }

    // Event handler attributes.
    virtual EventListener* onblur() const;
    virtual void setOnblur(PassRefPtr<EventListener>);
    virtual EventListener* onerror() const;
    virtual void setOnerror(PassRefPtr<EventListener>);
    virtual EventListener* onfocus() const;
    virtual void setOnfocus(PassRefPtr<EventListener>);
    virtual EventListener* onload() const;
    virtual void setOnload(PassRefPtr<EventListener>);

    EventListener* onbeforeunload() const;
    void setOnbeforeunload(PassRefPtr<EventListener>);
    EventListener* onhashchange() const;

    EventListener* onunload() const;
    void setOnunload(PassRefPtr<EventListener>);

protected:
    virtual bool shouldForwardEventListenerToWindow(const AtomicString& eventType) const;

private:
    Length* m_rows;
    Length* m_cols;

Return to Bug 28709

Lines 506-511 public: a/WebCore/dom/Node.h_sec1
- a/WebCore/dom/Node.h -12 / +15 lines
506	virtual void removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture);	506	virtual void removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
507		507
508	// Used for legacy "onEvent" property APIs.	508	// Used for legacy "onEvent" property APIs.
		509	//
		510	// If shouldForwardEventListenerToWindow below returns true for the given event type, then the listener is forwarded
		511	// to DOM window.
509	void setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener>);	512	void setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener>);
510	void clearAttributeEventListener(const AtomicString& eventType);	513	void clearAttributeEventListener(const AtomicString& eventType);
511	EventListener* getAttributeEventListener(const AtomicString& eventType) const;	514	EventListener* getAttributeEventListener(const AtomicString& eventType) const;
Lines 552-568 public: a/WebCore/dom/Node.h_sec2
552		555
553	const RegisteredEventListenerVector& eventListeners() const;	556	const RegisteredEventListenerVector& eventListeners() const;
554		557
555	// These 4 attribute event handler attributes are overrided by HTMLBodyElement	558	EventListener* onblur() const;
556	// and HTMLFrameSetElement to forward to the DOMWindow.	559	void setOnblur(PassRefPtr<EventListener>);
557	virtual EventListener* onblur() const;	560	EventListener* onerror() const;
558	virtual void setOnblur(PassRefPtr<EventListener>);	561	void setOnerror(PassRefPtr<EventListener>);
559	virtual EventListener* onerror() const;	562	EventListener* onfocus() const;
560	virtual void setOnerror(PassRefPtr<EventListener>);	563	void setOnfocus(PassRefPtr<EventListener>);
561	virtual EventListener* onfocus() const;	564	EventListener* onload() const;
562	virtual void setOnfocus(PassRefPtr<EventListener>);	565	void setOnload(PassRefPtr<EventListener>);
563	virtual EventListener* onload() const;
564	virtual void setOnload(PassRefPtr<EventListener>);
565
566	EventListener* onabort() const;	566	EventListener* onabort() const;
567	void setOnabort(PassRefPtr<EventListener>);	567	void setOnabort(PassRefPtr<EventListener>);
568	EventListener* onchange() const;	568	EventListener* onchange() const;
Lines 647-653 protected: a/WebCore/dom/Node.h_sec3
647		647
648	virtual void willMoveToNewOwnerDocument();	648	virtual void willMoveToNewOwnerDocument();
649	virtual void didMoveToNewOwnerDocument();	649	virtual void didMoveToNewOwnerDocument();
650		650
		651	// Overridden by HTMLBodyElement and HTMLFrameSetElement to forward certain event listener types to DOM window.
		652	virtual bool shouldForwardEventListenerToWindow(const AtomicString& eventType) const { return false; }
		653
651	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const { }	654	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const { }
652	void setTabIndexExplicitly(short);	655	void setTabIndexExplicitly(short);
653		656

Lines 35-40 a/WebCore/html/HTMLBodyElement.cpp_sec1
- a/WebCore/html/HTMLBodyElement.cpp -40 / +23 lines
35	#include "MappedAttribute.h"	35	#include "MappedAttribute.h"
36	#include "ScriptEventListener.h"	36	#include "ScriptEventListener.h"
37		37
		38	#include <wtf/HashSet.h>
		39
38	namespace WebCore {	40	namespace WebCore {
39		41
40	using namespace HTMLNames;	42	using namespace HTMLNames;
Lines 318-363 void HTMLBodyElement::didMoveToNewOwnerDocument() a/WebCore/html/HTMLBodyElement.cpp_sec2
318	HTMLElement::didMoveToNewOwnerDocument();	320	HTMLElement::didMoveToNewOwnerDocument();
319	}	321	}
320		322
321	EventListener* HTMLBodyElement::onblur() const
322	{
323	return document()->getWindowAttributeEventListener(eventNames().blurEvent);
324	}
325
326	void HTMLBodyElement::setOnblur(PassRefPtr<EventListener> eventListener)
327	{
328	document()->setWindowAttributeEventListener(eventNames().blurEvent, eventListener);
329	}
330
331	EventListener* HTMLBodyElement::onerror() const
332	{
333	return document()->getWindowAttributeEventListener(eventNames().errorEvent);
334	}
335
336	void HTMLBodyElement::setOnerror(PassRefPtr<EventListener> eventListener)
337	{
338	document()->setWindowAttributeEventListener(eventNames().errorEvent, eventListener);
339	}
340
341	EventListener* HTMLBodyElement::onfocus() const
342	{
343	return document()->getWindowAttributeEventListener(eventNames().focusEvent);
344	}
345
346	void HTMLBodyElement::setOnfocus(PassRefPtr<EventListener> eventListener)
347	{
348	document()->setWindowAttributeEventListener(eventNames().focusEvent, eventListener);
349	}
350
351	EventListener* HTMLBodyElement::onload() const
352	{
353	return document()->getWindowAttributeEventListener(eventNames().loadEvent);
354	}
355
356	void HTMLBodyElement::setOnload(PassRefPtr<EventListener> eventListener)
357	{
358	document()->setWindowAttributeEventListener(eventNames().loadEvent, eventListener);
359	}
360
361	EventListener* HTMLBodyElement::onbeforeunload() const	323	EventListener* HTMLBodyElement::onbeforeunload() const
362	{	324	{
363	return document()->getWindowAttributeEventListener(eventNames().beforeunloadEvent);	325	return document()->getWindowAttributeEventListener(eventNames().beforeunloadEvent);
Lines 438-441 void HTMLBodyElement::setOnunload(PassRefPtr<EventListener> eventListener) a/WebCore/html/HTMLBodyElement.cpp_sec3
438	document()->setWindowAttributeEventListener(eventNames().unloadEvent, eventListener);	400	document()->setWindowAttributeEventListener(eventNames().unloadEvent, eventListener);
439	}	401	}
440		402
		403	bool HTMLBodyElement::shouldForwardEventListenerToWindow(const AtomicString& eventType) const
		404	{
		405	DEFINE_STATIC_LOCAL(HashSet<AtomicString>, forwardTypes, ());
		406	if (forwardTypes.isEmpty()) {
		407	forwardTypes.add(eventNames().focusEvent);
		408	forwardTypes.add(eventNames().blurEvent);
		409	forwardTypes.add(eventNames().errorEvent);
		410	forwardTypes.add(eventNames().loadEvent);
		411	forwardTypes.add(eventNames().unloadEvent);
		412	forwardTypes.add(eventNames().beforeunloadEvent);
		413	forwardTypes.add(eventNames().messageEvent);
		414	forwardTypes.add(eventNames().offlineEvent);
		415	forwardTypes.add(eventNames().onlineEvent);
		416	forwardTypes.add(eventNames().resizeEvent);
		417	forwardTypes.add(eventNames().storageEvent);
		418	forwardTypes.add(eventNames().unloadEvent);
		419	forwardTypes.add(eventNames().hashchangeEvent);
		420	}
		421	return forwardTypes.contains(eventType);
		422	}
		423
441	} // namespace WebCore	424	} // namespace WebCore

Lines 230-265 void HTMLFrameSetElement::setRows(const String &value) a/WebCore/html/HTMLFrameSetElement.cpp_sec1
- a/WebCore/html/HTMLFrameSetElement.cpp -40 / +23 lines
230	setAttribute(rowsAttr, value);	230	setAttribute(rowsAttr, value);
231	}	231	}
232		232
233	EventListener* HTMLFrameSetElement::onblur() const
234	{
235	return document()->getWindowAttributeEventListener(eventNames().blurEvent);
236	}
237
238	void HTMLFrameSetElement::setOnblur(PassRefPtr<EventListener> eventListener)
239	{
240	document()->setWindowAttributeEventListener(eventNames().blurEvent, eventListener);
241	}
242
243	EventListener* HTMLFrameSetElement::onerror() const
244	{
245	return document()->getWindowAttributeEventListener(eventNames().errorEvent);
246	}
247
248	void HTMLFrameSetElement::setOnerror(PassRefPtr<EventListener> eventListener)
249	{
250	document()->setWindowAttributeEventListener(eventNames().errorEvent, eventListener);
251	}
252
253	EventListener* HTMLFrameSetElement::onfocus() const
254	{
255	return document()->getWindowAttributeEventListener(eventNames().focusEvent);
256	}
257
258	void HTMLFrameSetElement::setOnfocus(PassRefPtr<EventListener> eventListener)
259	{
260	document()->setWindowAttributeEventListener(eventNames().focusEvent, eventListener);
261	}
262
263	EventListener* HTMLFrameSetElement::onhashchange() const	233	EventListener* HTMLFrameSetElement::onhashchange() const
264	{	234	{
265	return document()->getWindowAttributeEventListener(eventNames().hashchangeEvent);	235	return document()->getWindowAttributeEventListener(eventNames().hashchangeEvent);
Lines 268-283 EventListener* HTMLFrameSetElement::onhashchange() const a/WebCore/html/HTMLFrameSetElement.cpp_sec2
268	void HTMLFrameSetElement::setOnhashchange(PassRefPtr<EventListener> eventListener)	238	void HTMLFrameSetElement::setOnhashchange(PassRefPtr<EventListener> eventListener)
269	{	239	{
270	document()->setWindowAttributeEventListener(eventNames().hashchangeEvent, eventListener);	240	document()->setWindowAttributeEventListener(eventNames().hashchangeEvent, eventListener);
271	}
272
273	EventListener* HTMLFrameSetElement::onload() const
274	{
275	return document()->getWindowAttributeEventListener(eventNames().loadEvent);
276	}
277
278	void HTMLFrameSetElement::setOnload(PassRefPtr<EventListener> eventListener)
279	{
280	document()->setWindowAttributeEventListener(eventNames().loadEvent, eventListener);
281	}	241	}
282		242
283	EventListener* HTMLFrameSetElement::onbeforeunload() const	243	EventListener* HTMLFrameSetElement::onbeforeunload() const
Lines 350-353 void HTMLFrameSetElement::setOnunload(PassRefPtr<EventListener> eventListener) a/WebCore/html/HTMLFrameSetElement.cpp_sec3
350	document()->setWindowAttributeEventListener(eventNames().unloadEvent, eventListener);	310	document()->setWindowAttributeEventListener(eventNames().unloadEvent, eventListener);
351	}	311	}
352		312
		313	bool HTMLFrameSetElement::shouldForwardEventListenerToWindow(const AtomicString& eventType) const
		314	{
		315	DEFINE_STATIC_LOCAL(HashSet<AtomicString>, forwardTypes, ());
		316	if (forwardTypes.isEmpty()) {
		317	forwardTypes.add(eventNames().focusEvent);
		318	forwardTypes.add(eventNames().blurEvent);
		319	forwardTypes.add(eventNames().errorEvent);
		320	forwardTypes.add(eventNames().loadEvent);
		321	forwardTypes.add(eventNames().unloadEvent);
		322	forwardTypes.add(eventNames().beforeunloadEvent);
		323	forwardTypes.add(eventNames().messageEvent);
		324	forwardTypes.add(eventNames().offlineEvent);
		325	forwardTypes.add(eventNames().onlineEvent);
		326	forwardTypes.add(eventNames().resizeEvent);
		327	forwardTypes.add(eventNames().storageEvent);
		328	forwardTypes.add(eventNames().unloadEvent);
		329	forwardTypes.add(eventNames().hashchangeEvent);
		330	}
		331	return forwardTypes.contains(eventType);
		332	}
		333
		334
		335
353	} // namespace WebCore	336	} // namespace WebCore

Lines 1-3 a/WebCore/ChangeLog_sec1
- a/WebCore/ChangeLog +32 lines
		1	2009-08-25 Vitaly Repeshko <vitalyr@chromium.org>
		2
		3	Reviewed by NOBODY (OOPS!).
		4
		5	WebCore: Make both Node::setAttributeEventListener and
		6	Node::setOnEvent forward listener to DOM window when necessary.
		7
		8	Before this patch only Node::setOnEvent functions did the forwarding
		9	which broke Node::setAttributeEventListener clients.
		10
		11	https://bugs.webkit.org/show_bug.cgi?id=28709
		12
		13	Uses already existing tests from http://trac.webkit.org/changeset/47326
		14
		15	* dom/Node.cpp:
		16	(WebCore::Node::clearAttributeEventListener):
		17	(WebCore::Node::setAttributeEventListener):
		18	(WebCore::Node::getAttributeEventListener):
		19	Now call shouldForwardEventListenerToWindow to determine if
		20	listener should be forwarded to DOM window.
		21	* dom/Node.h:
		22	(WebCore::Node::shouldForwardEventListenerToWindow):
		23	New virtual function overridden by HTMLBodyElement and HTMLFrameSetElement.
		24	Returns false by default.
		25	* html/HTMLBodyElement.cpp:
		26	(WebCore::HTMLBodyElement::shouldForwardEventListenerToWindow):
		27	* html/HTMLBodyElement.h:
		28	* html/HTMLFrameSetElement.cpp:
		29	(WebCore::HTMLFrameSetElement::setOnhashchange):
		30	(WebCore::HTMLFrameSetElement::shouldForwardEventListenerToWindow):
		31	* html/HTMLFrameSetElement.h:
		32
1	2009-08-24 Pavel Feldman <pfeldman@chromium.org>	33	2009-08-24 Pavel Feldman <pfeldman@chromium.org>
2		34
3	Reviewed by Timothy Hatcher.	35	Reviewed by Timothy Hatcher.

Lines 44-58 public: a/WebCore/html/HTMLBodyElement.h_sec1
- a/WebCore/html/HTMLBodyElement.h -9 / +3 lines
44	String vLink() const;	44	String vLink() const;
45	void setVLink(const String&);	45	void setVLink(const String&);
46		46
47	virtual EventListener* onblur() const;
48	virtual void setOnblur(PassRefPtr<EventListener>);
49	virtual EventListener* onerror() const;
50	virtual void setOnerror(PassRefPtr<EventListener>);
51	virtual EventListener* onfocus() const;
52	virtual void setOnfocus(PassRefPtr<EventListener>);
53	virtual EventListener* onload() const;
54	virtual void setOnload(PassRefPtr<EventListener>);
55
56	EventListener* onbeforeunload() const;	47	EventListener* onbeforeunload() const;
57	void setOnbeforeunload(PassRefPtr<EventListener>);	48	void setOnbeforeunload(PassRefPtr<EventListener>);
58	EventListener* onmessage() const;	49	EventListener* onmessage() const;
Lines 70-75 public: a/WebCore/html/HTMLBodyElement.h_sec2
70	EventListener* onunload() const;	61	EventListener* onunload() const;
71	void setOnunload(PassRefPtr<EventListener>);	62	void setOnunload(PassRefPtr<EventListener>);
72		63
		64	protected:
		65	virtual bool shouldForwardEventListenerToWindow(const AtomicString& eventType) const;
		66
73	private:	67	private:
74	virtual HTMLTagStatus endTagRequirement() const { return TagStatusRequired; }	68	virtual HTMLTagStatus endTagRequirement() const { return TagStatusRequired; }
75	virtual int tagPriority() const { return 10; }	69	virtual int tagPriority() const { return 10; }

Lines 67-82 public: a/WebCore/html/HTMLFrameSetElement.h_sec1
- a/WebCore/html/HTMLFrameSetElement.h -10 / +4 lines
67	const Length* rowLengths() const { return m_rows; }	67	const Length* rowLengths() const { return m_rows; }
68	const Length* colLengths() const { return m_cols; }	68	const Length* colLengths() const { return m_cols; }
69		69
70	// Event handler attributes	70	// Event handler attributes.
71	virtual EventListener* onblur() const;
72	virtual void setOnblur(PassRefPtr<EventListener>);
73	virtual EventListener* onerror() const;
74	virtual void setOnerror(PassRefPtr<EventListener>);
75	virtual EventListener* onfocus() const;
76	virtual void setOnfocus(PassRefPtr<EventListener>);
77	virtual EventListener* onload() const;
78	virtual void setOnload(PassRefPtr<EventListener>);
79
80	EventListener* onbeforeunload() const;	71	EventListener* onbeforeunload() const;
81	void setOnbeforeunload(PassRefPtr<EventListener>);	72	void setOnbeforeunload(PassRefPtr<EventListener>);
82	EventListener* onhashchange() const;	73	EventListener* onhashchange() const;
Lines 94-99 public: a/WebCore/html/HTMLFrameSetElement.h_sec2
94	EventListener* onunload() const;	85	EventListener* onunload() const;
95	void setOnunload(PassRefPtr<EventListener>);	86	void setOnunload(PassRefPtr<EventListener>);
96		87
		88	protected:
		89	virtual bool shouldForwardEventListenerToWindow(const AtomicString& eventType) const;
		90
97	private:	91	private:
98	Length* m_rows;	92	Length* m_rows;
99	Length* m_cols;	93	Length* m_cols;