Attachment #238735 for bug #136051

View Details Raw Unified Return to Bug 136051

| Differences between



2014-08-18  Brian J. Burg  <burg@cs.washington.edu>

        Web Replay: EventSender dispatches should be deterministic and per-Document
        https://bugs.webkit.org/show_bug.cgi?id=136051

        EventSender uses a Timer to asynchronously dispatch the same event to multiple
        elements of the same type on a future run loop. This is nondeterministic because
        static instances are shared between all Documents in the same process.

        This patch shares EventSender instances among elements in the same Document.
        The event dispatching is made deterministic by using a ReplayableTimer.

        Normal (non-replay) functionality is covered by existing tests.

        * WebCore.xcodeproj/project.pbxproj:
        * dom/Document.cpp:
        (WebCore::Document::Document):
        (WebCore::Document::implicitClose): Dispatch pending events for this document only.
        * dom/Document.h:
        (WebCore::Document::sharedEventSenders):
        * dom/EventSender.h: Keep a Document reference around for firing the timer.
        (WebCore::EventSender::EventSender):
        (WebCore::EventSender::hasPendingEvents):
        (WebCore::EventSender::timerFired):
        (WebCore::EventSender<T>::dispatchEventSoon):
        (WebCore::EventSender<T>::cancelEvent):
        (WebCore::EventSender<T>::dispatchPendingEvents):
        (WebCore::EventSender<T>::EventSender): Deleted. The type argument was not necessary.

        * dom/SharedEventSenders.cpp: Added. Lazily creates event senders as they are requested.
        (WebCore::SharedEventSenders::linkLoadEventSender):
        (WebCore::SharedEventSenders::styleLoadEventSender):
        (WebCore::SharedEventSenders::imageBeforeloadEventSender):
        (WebCore::SharedEventSenders::imageLoadEventSender):
        (WebCore::SharedEventSenders::imageErrorEventSender):
        * dom/SharedEventSenders.h: Added.
        (WebCore::SharedEventSenders::SharedEventSenders):
        * html/HTMLLinkElement.cpp:
        (WebCore::HTMLLinkElement::linkLoadEventSender):
        (WebCore::HTMLLinkElement::dispatchPendingEvent):
        (WebCore::linkLoadEventSender): Deleted.
        (WebCore::HTMLLinkElement::dispatchPendingLoadEvents): Deleted.
        * html/HTMLLinkElement.h:
        * html/HTMLStyleElement.cpp:
        (WebCore::HTMLStyleElement::styleLoadEventSender):
        (WebCore::HTMLStyleElement::dispatchPendingEvent):
        (WebCore::styleLoadEventSender): Deleted.
        (WebCore::HTMLStyleElement::dispatchPendingLoadEvents): Deleted.
        * html/HTMLStyleElement.h:
        * loader/ImageLoader.cpp:
        (WebCore::ImageLoader::beforeLoadEventSender):
        (WebCore::ImageLoader::loadEventSender):
        (WebCore::ImageLoader::errorEventSender):
        (WebCore::ImageLoader::dispatchPendingEvent):
        (WebCore::beforeLoadEventSender): Deleted.
        (WebCore::loadEventSender): Deleted.
        (WebCore::errorEventSender): Deleted.
        (WebCore::ImageLoader::dispatchPendingBeforeLoadEvents): Deleted.
        (WebCore::ImageLoader::dispatchPendingLoadEvents): Deleted.
        (WebCore::ImageLoader::dispatchPendingErrorEvents): Deleted.
        * loader/ImageLoader.h:

        * xml/parser/XMLDocumentParser.cpp:
        (WebCore::XMLDocumentParser::append): Remove an early call to the EventSender for image beforeload
        events. This was a performance optimization, but is no longer safe since the document (and thus
        the event sender) may not be available in a synchronous document write.

2014-07-15  Brian J. Burg  <burg@cs.washington.edu>

        Web Replay: make calls into FrameLoader::checkLoadComplete() deterministic



#include "SelectorQuery.h"
#include "Settings.h"
#include "ShadowRoot.h"
#include "SharedEventSenders.h"
#include "StyleProperties.h"
#include "StyleResolver.h"
#include "StyleSheetContents.h"

    , m_sawElementsInKnownNamespaces(false)
    , m_isSrcdocDocument(false)
    , m_eventQueue(*this)
    , m_sharedEventSenders(std::make_unique<SharedEventSenders>(*this))
    , m_weakFactory(this)
#if ENABLE(FULLSCREEN_API)
    , m_areKeysEnabledInFullScreen(0)

    if (f) {
        f->loader().icon().startLoader();
        f->animation().startAnimationsIfNotSuspended(this);

        // FIXME: We shouldn't be dispatching pending events globally on all Documents here.
        // For now, only do this when there is a Frame, otherwise this could cause JS reentrancy
        // below SVG font parsing, for example. <https://webkit.org/b/136269>
        ImageLoader::dispatchPendingBeforeLoadEvents();
        ImageLoader::dispatchPendingLoadEvents();
        ImageLoader::dispatchPendingErrorEvents();
        HTMLLinkElement::dispatchPendingLoadEvents();
        HTMLStyleElement::dispatchPendingLoadEvents();
    }

    sharedEventSenders().imageBeforeloadEventSender().dispatchPendingEvents();
    sharedEventSenders().imageLoadEventSender().dispatchPendingEvents();
    sharedEventSenders().imageErrorEventSender().dispatchPendingEvents();

    sharedEventSenders().linkLoadEventSender().dispatchPendingEvents();
    sharedEventSenders().styleLoadEventSender().dispatchPendingEvents();

    // To align the HTML load event and the SVGLoad event for the outermost <svg> element, fire it from
    // here, instead of doing it from SVGElement::finishedParsingChildren (if externalResourcesRequired="false",
    // which is the default, for ='true' its fired at a later time, once all external resources finished loading).

Lines 145-150 class SelectorQueryCache; a/Source/WebCore/dom/Document.h_sec1
- a/Source/WebCore/dom/Document.h +5 lines
145	class SerializedScriptValue;	145	class SerializedScriptValue;
146	class SegmentedString;	146	class SegmentedString;
147	class Settings;	147	class Settings;
		148	class SharedEventSenders;
148	class StyleResolver;	149	class StyleResolver;
149	class StyleSheet;	150	class StyleSheet;
150	class StyleSheetContents;	151	class StyleSheetContents;
Lines 1123-1128 public: a/Source/WebCore/dom/Document.h_sec2
1123	void enqueuePopstateEvent(PassRefPtr<SerializedScriptValue> stateObject);	1124	void enqueuePopstateEvent(PassRefPtr<SerializedScriptValue> stateObject);
1124	virtual DocumentEventQueue& eventQueue() const override { return m_eventQueue; }	1125	virtual DocumentEventQueue& eventQueue() const override { return m_eventQueue; }
1125		1126
		1127	SharedEventSenders& sharedEventSenders() const { return *m_sharedEventSenders; }
		1128
1126	WEBCORE_EXPORT void addMediaCanStartListener(MediaCanStartListener*);	1129	WEBCORE_EXPORT void addMediaCanStartListener(MediaCanStartListener*);
1127	WEBCORE_EXPORT void removeMediaCanStartListener(MediaCanStartListener*);	1130	WEBCORE_EXPORT void removeMediaCanStartListener(MediaCanStartListener*);
1128	MediaCanStartListener* takeAnyMediaCanStartListener();	1131	MediaCanStartListener* takeAnyMediaCanStartListener();
Lines 1570-1575 private: a/Source/WebCore/dom/Document.h_sec3
1570	RenderPtr<RenderView> m_renderView;	1573	RenderPtr<RenderView> m_renderView;
1571	mutable DocumentEventQueue m_eventQueue;	1574	mutable DocumentEventQueue m_eventQueue;
1572		1575
		1576	const std::unique_ptr<SharedEventSenders> m_sharedEventSenders;
		1577
1573	WeakPtrFactory<Document> m_weakFactory;	1578	WeakPtrFactory<Document> m_weakFactory;
1574		1579
1575	HashSet<MediaCanStartListener*> m_mediaCanStartListeners;	1580	HashSet<MediaCanStartListener*> m_mediaCanStartListeners;

Lines 1-5 a/Source/WebCore/dom/EventSender.h_sec1
- a/Source/WebCore/dom/EventSender.h -25 / +30 lines
1	/*	1	/*
2	* Copyright (C) 2012 Apple Inc. All rights reserved.	2	* Copyright (C) 2012 Apple Inc. All rights reserved.
		3	* Copyright (C) 2014 University of Washington. All rights reserved.
3	*	4	*
4	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
Lines 26-40 a/Source/WebCore/dom/EventSender.h_sec2
26	#ifndef EventSender_h	27	#ifndef EventSender_h
27	#define EventSender_h	28	#define EventSender_h
28		29
29	#include "Timer.h"	30	#include "ReplayableTimer.h"
30	#include <wtf/Vector.h>	31	#include <wtf/Vector.h>
31		32
32	namespace WebCore {	33	namespace WebCore {
33		34
34	template<typename T> class EventSender {	35	class Document;
		36
		37	template <typename T>
		38	class EventSender {
35	WTF_MAKE_NONCOPYABLE(EventSender); WTF_MAKE_FAST_ALLOCATED;	39	WTF_MAKE_NONCOPYABLE(EventSender); WTF_MAKE_FAST_ALLOCATED;
36	public:	40	public:
37	explicit EventSender(const AtomicString& eventType);	41	EventSender(Document& document, const AtomicString& eventType)
		42	: m_document(document)
		43	, m_eventType(eventType)
		44	, m_timer(this, &EventSender::timerFired)
		45	{
		46	}
38		47
39	const AtomicString& eventType() const { return m_eventType; }	48	const AtomicString& eventType() const { return m_eventType; }
40	void dispatchEventSoon(T&);	49	void dispatchEventSoon(T&);
Lines 42-90 public: a/Source/WebCore/dom/EventSender.h_sec3
42	void dispatchPendingEvents();	51	void dispatchPendingEvents();
43		52
44	#ifndef NDEBUG	53	#ifndef NDEBUG
45	bool hasPendingEvents(T& sender) const	54	bool hasPendingEvents(T& client) const
46	{	55	{
47	return m_dispatchSoonList.find(&sender) != notFound \|\| m_dispatchingList.find(&sender) != notFound;	56	return m_dispatchSoonList.find(&client) != notFound \|\| m_dispatchingList.find(&client) != notFound;
48	}	57	}
49	#endif	58	#endif
50		59
51	private:	60	private:
52	void timerFired(Timer<EventSender<T>>&) { dispatchPendingEvents(); }	61	void timerFired(ReplayableTimer<EventSender<T>>&) { dispatchPendingEvents(); }
53		62
		63	Document& m_document;
54	AtomicString m_eventType;	64	AtomicString m_eventType;
55	Timer<EventSender<T>> m_timer;	65	ReplayableTimer<EventSender<T>> m_timer;
56	Vector<T*> m_dispatchSoonList;	66	Vector<T*> m_dispatchSoonList;
57	Vector<T*> m_dispatchingList;	67	Vector<T*> m_dispatchingList;
58	};	68	};
59		69
60	template<typename T> EventSender<T>::EventSender(const AtomicString& eventType)	70	template <typename T>
61	: m_eventType(eventType)	71	void EventSender<T>::dispatchEventSoon(T& client)
62	, m_timer(this, &EventSender::timerFired)
63	{	72	{
64	}	73	m_dispatchSoonList.append(&client);
65
66	template<typename T> void EventSender<T>::dispatchEventSoon(T& sender)
67	{
68	m_dispatchSoonList.append(&sender);
69	if (!m_timer.isActive())	74	if (!m_timer.isActive())
70	m_timer.startOneShot(0);	75	m_timer.startOneShot(0, &m_document);
71	}	76	}
72		77
73	template<typename T> void EventSender<T>::cancelEvent(T& sender)	78	template<typename T>
		79	void EventSender<T>::cancelEvent(T& client)
74	{	80	{
75	// Remove instances of this sender from both lists.	81	// Remove instances of this client from both lists.
76	// Use loops because we allow multiple instances to get into the lists.	82	// Use loops because we allow multiple instances to get into the lists.
77	for (auto& event : m_dispatchSoonList) {	83	for (auto& event : m_dispatchSoonList) {
78	if (event == &sender)	84	if (event == &client)
79	event = nullptr;	85	event = nullptr;
80	}	86	}
81	for (auto& event : m_dispatchingList) {	87	for (auto& event : m_dispatchingList) {
82	if (event == &sender)	88	if (event == &client)
83	event = nullptr;	89	event = nullptr;
84	}	90	}
85	}	91	}
86		92
87	template<typename T> void EventSender<T>::dispatchPendingEvents()	93	template<typename T>
		94	void EventSender<T>::dispatchPendingEvents()
88	{	95	{
89	// Need to avoid re-entering this function; if new dispatches are	96	// Need to avoid re-entering this function; if new dispatches are
90	// scheduled before the parent finishes processing the list, they	97	// scheduled before the parent finishes processing the list, they
Lines 94-106 template<typename T> void EventSender<T>::dispatchPendingEvents() a/Source/WebCore/dom/EventSender.h_sec4
94		101
95	m_timer.stop();	102	m_timer.stop();
96		103
97	m_dispatchSoonList.checkConsistency();
98
99	m_dispatchingList.swap(m_dispatchSoonList);	104	m_dispatchingList.swap(m_dispatchSoonList);
100	for (auto& event : m_dispatchingList) {	105	for (auto& event : m_dispatchingList) {
101	if (T* sender = event) {	106	if (T* client = event) {
102	event = nullptr;	107	event = nullptr;
103	sender->dispatchPendingEvent(this);	108	client->dispatchPendingEvent(*this);
104	}	109	}
105	}	110	}
106	m_dispatchingList.clear();	111	m_dispatchingList.clear();



/*
 * Copyright (C) 2014 University of Washington. 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
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 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 "SharedEventSenders.h"

#include "HTMLLinkElement.h"
#include "HTMLStyleElement.h"
#include "ImageLoader.h"

namespace WebCore {

EventSender<HTMLLinkElement>& SharedEventSenders::linkLoadEventSender()
{
    if (!m_linkLoadEventSender)
        m_linkLoadEventSender = std::make_unique<EventSender<HTMLLinkElement>>(m_document, eventNames().loadEvent);

    return *m_linkLoadEventSender;
}

EventSender<HTMLStyleElement>& SharedEventSenders::styleLoadEventSender()
{
    if (!m_styleLoadEventSender)
        m_styleLoadEventSender = std::make_unique<EventSender<HTMLStyleElement>>(m_document, eventNames().loadEvent);

    return *m_styleLoadEventSender;
}

EventSender<ImageLoader>& SharedEventSenders::imageBeforeloadEventSender()
{
    if (!m_imageBeforeloadEventSender)
        m_imageBeforeloadEventSender = std::make_unique<EventSender<ImageLoader>>(m_document, eventNames().beforeloadEvent);

    return *m_imageBeforeloadEventSender;
}

EventSender<ImageLoader>& SharedEventSenders::imageLoadEventSender()
{
    if (!m_imageLoadEventSender)
        m_imageLoadEventSender = std::make_unique<EventSender<ImageLoader>>(m_document, eventNames().loadEvent);

    return *m_imageLoadEventSender;
}

EventSender<ImageLoader>& SharedEventSenders::imageErrorEventSender()
{
    if (!m_imageErrorEventSender)
        m_imageErrorEventSender = std::make_unique<EventSender<ImageLoader>>(m_document, eventNames().errorEvent);

    return *m_imageErrorEventSender;
}

} // namespace WebCore



/*
 * Copyright (C) 2014 University of Washington. 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
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 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.
 */

#ifndef SharedEventSenders_h
#define SharedEventSenders_h

#include "EventNames.h"
#include "EventSender.h"

namespace WebCore {

class HTMLLinkElement;
class HTMLStyleElement;
class ImageLoader;

class SharedEventSenders {
    WTF_MAKE_NONCOPYABLE(SharedEventSenders); WTF_MAKE_FAST_ALLOCATED;
public:
    explicit SharedEventSenders(Document& document)
        : m_document(document)
    {
    }

    EventSender<HTMLLinkElement>& linkLoadEventSender();
    EventSender<HTMLStyleElement>& styleLoadEventSender();
    EventSender<ImageLoader>& imageBeforeloadEventSender();
    EventSender<ImageLoader>& imageLoadEventSender();
    EventSender<ImageLoader>& imageErrorEventSender();
private:
    Document& m_document;
    std::unique_ptr<EventSender<HTMLLinkElement>> m_linkLoadEventSender;
    std::unique_ptr<EventSender<HTMLStyleElement>> m_styleLoadEventSender;
    std::unique_ptr<EventSender<ImageLoader>> m_imageBeforeloadEventSender;
    std::unique_ptr<EventSender<ImageLoader>> m_imageLoadEventSender;
    std::unique_ptr<EventSender<ImageLoader>> m_imageErrorEventSender;
};

} // namespace WebCore

#endif // SharedEventSenders_h



#include "RenderStyle.h"
#include "SecurityOrigin.h"
#include "Settings.h"
#include "SharedEventSenders.h"
#include "StyleInheritedData.h"
#include "StyleResolveForDocument.h"
#include "StyleSheetContents.h"


using namespace HTMLNames;

LinkEventSender& HTMLLinkElement::linkLoadEventSender() const
{
    return document().sharedEventSenders().linkLoadEventSender();
    return sharedLoadEventSender;
}

inline HTMLLinkElement::HTMLLinkElement(const QualifiedName& tagName, Document& document, bool createdByParser)

    return false;
}

void HTMLLinkElement::dispatchPendingEvent(LinkEventSender& eventSender)
{
    ASSERT_UNUSED(eventSender, &eventSender == &linkLoadEventSender());
}

void HTMLLinkElement::dispatchPendingEvent(LinkEventSender* eventSender)
{
    ASSERT_UNUSED(eventSender, eventSender == &linkLoadEventSender());
    if (m_loadedSheet)
        linkLoaded();
    else



    void setSizes(const String&);
    DOMSettableTokenList* sizes() const;

    void dispatchPendingEvent(LinkEventSender&);
    LinkEventSender& linkLoadEventSender() const;

private:
    virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;



#include "RuntimeEnabledFeatures.h"
#include "ScriptableDocumentParser.h"
#include "ShadowRoot.h"
#include "SharedEventSenders.h"
#include "StyleSheetContents.h"

namespace WebCore {

using namespace HTMLNames;

StyleEventSender& HTMLStyleElement::styleLoadEventSender() const
{
    return document().sharedEventSenders().styleLoadEventSender();
    return sharedLoadEventSender;
}

inline HTMLStyleElement::HTMLStyleElement(const QualifiedName& tagName, Document& document, bool createdByParser)

    m_styleSheetOwner.childrenChanged(*this);
}

void HTMLStyleElement::dispatchPendingEvent(StyleEventSender& eventSender)
{
    ASSERT_UNUSED(eventSender, &eventSender == &styleLoadEventSender());
}

void HTMLStyleElement::dispatchPendingEvent(StyleEventSender* eventSender)
{
    ASSERT_UNUSED(eventSender, eventSender == &styleLoadEventSender());
    if (m_loadedSheet)
        dispatchEvent(Event::create(eventNames().loadEvent, false, false));
    else



    bool disabled() const;
    void setDisabled(bool);

    void dispatchPendingEvent(StyleEventSender&);

    StyleEventSender& styleLoadEventSender() const;

private:
    HTMLStyleElement(const QualifiedName&, Document&, bool createdByParser);



#include "RenderImage.h"
#include "RenderSVGImage.h"
#include "SecurityOrigin.h"
#include "SharedEventSenders.h"
#include <wtf/NeverDestroyed.h>

#if ENABLE(VIDEO)


namespace WebCore {

ImageEventSender& ImageLoader::beforeLoadEventSender() const
{
    return m_element.document().sharedEventSenders().imageBeforeloadEventSender();
    return sender;
}

ImageEventSender& ImageLoader::loadEventSender() const
{
    return m_element.document().sharedEventSenders().imageLoadEventSender();
    return sender;
}

ImageEventSender& ImageLoader::errorEventSender() const
{
    return m_element.document().sharedEventSenders().imageErrorEventSender();
    return sender;
}

static inline bool pageIsBeingDismissed(Document& document)

    element().deref();
}

void ImageLoader::dispatchPendingEvent(ImageEventSender& eventSender)
{
    ASSERT(&eventSender == &beforeLoadEventSender() || &eventSender == &loadEventSender() || &eventSender == &errorEventSender());
    const AtomicString& eventType = eventSender.eventType();
    if (eventType == eventNames().beforeloadEvent)
        dispatchPendingBeforeLoadEvent();
    if (eventType == eventNames().loadEvent)

    updatedHasPendingEvent();
}

void ImageLoader::dispatchPendingBeforeLoadEvents()
{
    beforeLoadEventSender().dispatchPendingEvents();
}

void ImageLoader::dispatchPendingLoadEvents()
{
    loadEventSender().dispatchPendingEvents();
}

void ImageLoader::dispatchPendingErrorEvents()
{
    errorEventSender().dispatchPendingEvents();
}

void ImageLoader::elementDidMoveToNewDocument()
{
    clearFailedLoadURL();



    bool hasPendingBeforeLoadEvent() const { return m_hasPendingBeforeLoadEvent; }
    bool hasPendingActivity() const { return m_hasPendingLoadEvent || m_hasPendingErrorEvent; }

    void dispatchPendingEvent(ImageEventSender&);

    ImageEventSender& beforeLoadEventSender() const;
    ImageEventSender& loadEventSender() const;
    ImageEventSender& errorEventSender() const;

protected:
    explicit ImageLoader(Element&);



#include "SVGStyleElement.h"
#include "ScriptElement.h"
#include "ScriptSourceCode.h"
#include "SharedEventSenders.h"
#include "TextResourceDecoder.h"
#include "TreeDepthLimit.h"
#include <wtf/Ref.h>

    }

    doWrite(source.toString());

    // After parsing, go ahead and dispatch image beforeload events.
    ImageLoader::dispatchPendingBeforeLoadEvents();
}

void XMLDocumentParser::handleError(XMLErrors::ErrorType type, const char* m, TextPosition position)

Return to Bug 136051

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +67 lines
		1	2014-08-18 Brian J. Burg <burg@cs.washington.edu>
		2
		3	Web Replay: EventSender dispatches should be deterministic and per-Document
		4	https://bugs.webkit.org/show_bug.cgi?id=136051
		5
		6	EventSender uses a Timer to asynchronously dispatch the same event to multiple
		7	elements of the same type on a future run loop. This is nondeterministic because
		8	static instances are shared between all Documents in the same process.
		9
		10	This patch shares EventSender instances among elements in the same Document.
		11	The event dispatching is made deterministic by using a ReplayableTimer.
		12
		13	Normal (non-replay) functionality is covered by existing tests.
		14
		15	* WebCore.xcodeproj/project.pbxproj:
		16	* dom/Document.cpp:
		17	(WebCore::Document::Document):
		18	(WebCore::Document::implicitClose): Dispatch pending events for this document only.
		19	* dom/Document.h:
		20	(WebCore::Document::sharedEventSenders):
		21	* dom/EventSender.h: Keep a Document reference around for firing the timer.
		22	(WebCore::EventSender::EventSender):
		23	(WebCore::EventSender::hasPendingEvents):
		24	(WebCore::EventSender::timerFired):
		25	(WebCore::EventSender<T>::dispatchEventSoon):
		26	(WebCore::EventSender<T>::cancelEvent):
		27	(WebCore::EventSender<T>::dispatchPendingEvents):
		28	(WebCore::EventSender<T>::EventSender): Deleted. The type argument was not necessary.
		29
		30	* dom/SharedEventSenders.cpp: Added. Lazily creates event senders as they are requested.
		31	(WebCore::SharedEventSenders::linkLoadEventSender):
		32	(WebCore::SharedEventSenders::styleLoadEventSender):
		33	(WebCore::SharedEventSenders::imageBeforeloadEventSender):
		34	(WebCore::SharedEventSenders::imageLoadEventSender):
		35	(WebCore::SharedEventSenders::imageErrorEventSender):
		36	* dom/SharedEventSenders.h: Added.
		37	(WebCore::SharedEventSenders::SharedEventSenders):
		38	* html/HTMLLinkElement.cpp:
		39	(WebCore::HTMLLinkElement::linkLoadEventSender):
		40	(WebCore::HTMLLinkElement::dispatchPendingEvent):
		41	(WebCore::linkLoadEventSender): Deleted.
		42	(WebCore::HTMLLinkElement::dispatchPendingLoadEvents): Deleted.
		43	* html/HTMLLinkElement.h:
		44	* html/HTMLStyleElement.cpp:
		45	(WebCore::HTMLStyleElement::styleLoadEventSender):
		46	(WebCore::HTMLStyleElement::dispatchPendingEvent):
		47	(WebCore::styleLoadEventSender): Deleted.
		48	(WebCore::HTMLStyleElement::dispatchPendingLoadEvents): Deleted.
		49	* html/HTMLStyleElement.h:
		50	* loader/ImageLoader.cpp:
		51	(WebCore::ImageLoader::beforeLoadEventSender):
		52	(WebCore::ImageLoader::loadEventSender):
		53	(WebCore::ImageLoader::errorEventSender):
		54	(WebCore::ImageLoader::dispatchPendingEvent):
		55	(WebCore::beforeLoadEventSender): Deleted.
		56	(WebCore::loadEventSender): Deleted.
		57	(WebCore::errorEventSender): Deleted.
		58	(WebCore::ImageLoader::dispatchPendingBeforeLoadEvents): Deleted.
		59	(WebCore::ImageLoader::dispatchPendingLoadEvents): Deleted.
		60	(WebCore::ImageLoader::dispatchPendingErrorEvents): Deleted.
		61	* loader/ImageLoader.h:
		62
		63	* xml/parser/XMLDocumentParser.cpp:
		64	(WebCore::XMLDocumentParser::append): Remove an early call to the EventSender for image beforeload
65	events. This was a performance optimization, but is no longer safe since the document (and thus
66	the event sender) may not be available in a synchronous document write.
67
1	2014-07-15 Brian J. Burg <burg@cs.washington.edu>	68	2014-07-15 Brian J. Burg <burg@cs.washington.edu>
2		69
3	Web Replay: make calls into FrameLoader::checkLoadComplete() deterministic	70	Web Replay: make calls into FrameLoader::checkLoadComplete() deterministic

Lines 5510-5515 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj +10 lines
5510	C3CF17A615B0063F00276D39 /* IdTargetObserverRegistry.cpp in Sources / = {isa = PBXBuildFile; fileRef = C3CF17A215B0063F00276D39 / IdTargetObserverRegistry.cpp */; };	5510	C3CF17A615B0063F00276D39 /* IdTargetObserverRegistry.cpp in Sources / = {isa = PBXBuildFile; fileRef = C3CF17A215B0063F00276D39 / IdTargetObserverRegistry.cpp */; };
5511	C3CF17A715B0063F00276D39 /* IdTargetObserverRegistry.h in Headers / = {isa = PBXBuildFile; fileRef = C3CF17A315B0063F00276D39 / IdTargetObserverRegistry.h */; settings = {ATTRIBUTES = (Private, ); }; };	5511	C3CF17A715B0063F00276D39 /* IdTargetObserverRegistry.h in Headers / = {isa = PBXBuildFile; fileRef = C3CF17A315B0063F00276D39 / IdTargetObserverRegistry.h */; settings = {ATTRIBUTES = (Private, ); }; };
5512	C400D10918F1C8F60090D863 /* EventLoopInput.cpp in Sources / = {isa = PBXBuildFile; fileRef = C400D10818F1C8F60090D863 / EventLoopInput.cpp */; };	5512	C400D10918F1C8F60090D863 /* EventLoopInput.cpp in Sources / = {isa = PBXBuildFile; fileRef = C400D10818F1C8F60090D863 / EventLoopInput.cpp */; };
		5513	C49474A119A2847C009B3DE8 /* SharedEventSenders.h in Headers / = {isa = PBXBuildFile; fileRef = C49474A019A2847C009B3DE8 / SharedEventSenders.h */; };
		5514	C49474A819A2D612009B3DE8 /* EventSender.h in Headers / = {isa = PBXBuildFile; fileRef = CE5CB1B314EDAB6F00BB2795 / EventSender.h */; };
		5515	C49474AA19A2E2E5009B3DE8 /* SharedEventSenders.cpp in Sources / = {isa = PBXBuildFile; fileRef = C49474A919A2E2E5009B3DE8 / SharedEventSenders.cpp */; };
5513	C4CD629A18383766007EBAF1 /* FrameSnapshotting.cpp in Sources / = {isa = PBXBuildFile; fileRef = C4CD629818383766007EBAF1 / FrameSnapshotting.cpp */; };	5516	C4CD629A18383766007EBAF1 /* FrameSnapshotting.cpp in Sources / = {isa = PBXBuildFile; fileRef = C4CD629818383766007EBAF1 / FrameSnapshotting.cpp */; };
5514	C4CD629B18383766007EBAF1 /* FrameSnapshotting.h in Headers / = {isa = PBXBuildFile; fileRef = C4CD629918383766007EBAF1 / FrameSnapshotting.h */; settings = {ATTRIBUTES = (Private, ); }; };	5517	C4CD629B18383766007EBAF1 /* FrameSnapshotting.h in Headers / = {isa = PBXBuildFile; fileRef = C4CD629918383766007EBAF1 / FrameSnapshotting.h */; settings = {ATTRIBUTES = (Private, ); }; };
5515	C4D4F52B1975C88B003EF5BC /* ReplayableTimer.cpp in Sources / = {isa = PBXBuildFile; fileRef = C4D4F5271975C88B003EF5BC / ReplayableTimer.cpp */; };	5518	C4D4F52B1975C88B003EF5BC /* ReplayableTimer.cpp in Sources / = {isa = PBXBuildFile; fileRef = C4D4F5271975C88B003EF5BC / ReplayableTimer.cpp */; };
Lines 12925-12930 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
12925	C3CF17A315B0063F00276D39 /* IdTargetObserverRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IdTargetObserverRegistry.h; sourceTree = "<group>"; };	12928	C3CF17A315B0063F00276D39 /* IdTargetObserverRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IdTargetObserverRegistry.h; sourceTree = "<group>"; };
12926	C3E61C653A64807A83E76FB8 /* MathMLMencloseElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MathMLMencloseElement.cpp; sourceTree = "<group>"; };	12929	C3E61C653A64807A83E76FB8 /* MathMLMencloseElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MathMLMencloseElement.cpp; sourceTree = "<group>"; };
12927	C400D10818F1C8F60090D863 /* EventLoopInput.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EventLoopInput.cpp; sourceTree = "<group>"; };	12930	C400D10818F1C8F60090D863 /* EventLoopInput.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EventLoopInput.cpp; sourceTree = "<group>"; };
		12931	C49474A019A2847C009B3DE8 /* SharedEventSenders.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SharedEventSenders.h; sourceTree = "<group>"; };
		12932	C49474A919A2E2E5009B3DE8 /* SharedEventSenders.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SharedEventSenders.cpp; sourceTree = "<group>"; };
12928	C4CD629818383766007EBAF1 /* FrameSnapshotting.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FrameSnapshotting.cpp; sourceTree = "<group>"; };	12933	C4CD629818383766007EBAF1 /* FrameSnapshotting.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FrameSnapshotting.cpp; sourceTree = "<group>"; };
12929	C4CD629918383766007EBAF1 /* FrameSnapshotting.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FrameSnapshotting.h; sourceTree = "<group>"; };	12934	C4CD629918383766007EBAF1 /* FrameSnapshotting.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FrameSnapshotting.h; sourceTree = "<group>"; };
12930	C4D4F5271975C88B003EF5BC /* ReplayableTimer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ReplayableTimer.cpp; sourceTree = "<group>"; };	12935	C4D4F5271975C88B003EF5BC /* ReplayableTimer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ReplayableTimer.cpp; sourceTree = "<group>"; };
Lines 22775-22780 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
22775	E45322AA140CE267005A0F92 /* SelectorQuery.h */,	22780	E45322AA140CE267005A0F92 /* SelectorQuery.h */,
22776	A6D169611346B49B000EB770 /* ShadowRoot.cpp */,	22781	A6D169611346B49B000EB770 /* ShadowRoot.cpp */,
22777	A6D169631346B4C1000EB770 /* ShadowRoot.h */,	22782	A6D169631346B4C1000EB770 /* ShadowRoot.h */,
		22783	C49474A919A2E2E5009B3DE8 /* SharedEventSenders.cpp */,
		22784	C49474A019A2847C009B3DE8 /* SharedEventSenders.h */,
22778	31741AAB16635E45008A5B7E /* SimulatedClickOptions.h */,	22785	31741AAB16635E45008A5B7E /* SimulatedClickOptions.h */,
22779	D01A27AB10C9BFD800026A42 /* SpaceSplitString.cpp */,	22786	D01A27AB10C9BFD800026A42 /* SpaceSplitString.cpp */,
22780	D01A27AC10C9BFD800026A42 /* SpaceSplitString.h */,	22787	D01A27AC10C9BFD800026A42 /* SpaceSplitString.h */,
Lines 23368-23373 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
23368	070363E0181A1CDC00C074A5 /* AVAudioCaptureSource.h in Headers */,	23375	070363E0181A1CDC00C074A5 /* AVAudioCaptureSource.h in Headers */,
23369	070363E2181A1CDC00C074A5 /* AVCaptureDeviceManager.h in Headers */,	23376	070363E2181A1CDC00C074A5 /* AVCaptureDeviceManager.h in Headers */,
23370	070363E4181A1CDC00C074A5 /* AVMediaCaptureSource.h in Headers */,	23377	070363E4181A1CDC00C074A5 /* AVMediaCaptureSource.h in Headers */,
		23378	C49474A819A2D612009B3DE8 /* EventSender.h in Headers */,
23371	CD336F6217F9F64700DDDCD0 /* AVTrackPrivateAVFObjCImpl.h in Headers */,	23379	CD336F6217F9F64700DDDCD0 /* AVTrackPrivateAVFObjCImpl.h in Headers */,
23372	070363E6181A1CDC00C074A5 /* AVVideoCaptureSource.h in Headers */,	23380	070363E6181A1CDC00C074A5 /* AVVideoCaptureSource.h in Headers */,
23373	29A812380FBB9C1D00510293 /* AXObjectCache.h in Headers */,	23381	29A812380FBB9C1D00510293 /* AXObjectCache.h in Headers */,
Lines 26405-26410 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec5
26405	85031B4F0A44EFC700F992E0 /* UIEventWithKeyState.h in Headers */,	26413	85031B4F0A44EFC700F992E0 /* UIEventWithKeyState.h in Headers */,
26406	AA4739D21757AFEC00E76767 /* UIRequestEvent.h in Headers */,	26414	AA4739D21757AFEC00E76767 /* UIRequestEvent.h in Headers */,
26407	9B2D8A7914997CCF00ECEF3E /* UndoStep.h in Headers */,	26415	9B2D8A7914997CCF00ECEF3E /* UndoStep.h in Headers */,
		26416	C49474A119A2847C009B3DE8 /* SharedEventSenders.h in Headers */,
26408	A863E2011343412000274926 /* UnicodeBidi.h in Headers */,	26417	A863E2011343412000274926 /* UnicodeBidi.h in Headers */,
26409	E4AFCFA50DAF29A300F5F55C /* UnitBezier.h in Headers */,	26418	E4AFCFA50DAF29A300F5F55C /* UnitBezier.h in Headers */,
26410	D086FE9809D53AAB005BC74D /* UnlinkCommand.h in Headers */,	26419	D086FE9809D53AAB005BC74D /* UnlinkCommand.h in Headers */,
Lines 28070-28075 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec6
28070	8931DE5B14C44C44000DC9D2 /* JSBlobCustom.cpp in Sources */,	28079	8931DE5B14C44C44000DC9D2 /* JSBlobCustom.cpp in Sources */,
28071	1449E287107D4DB400B5793F /* JSCallbackData.cpp in Sources */,	28080	1449E287107D4DB400B5793F /* JSCallbackData.cpp in Sources */,
28072	65DF323909D1DE65000BE325 /* JSCanvasGradient.cpp in Sources */,	28081	65DF323909D1DE65000BE325 /* JSCanvasGradient.cpp in Sources */,
		28082	C49474AA19A2E2E5009B3DE8 /* SharedEventSenders.cpp in Sources */,
28073	65DF323B09D1DE65000BE325 /* JSCanvasPattern.cpp in Sources */,	28083	65DF323B09D1DE65000BE325 /* JSCanvasPattern.cpp in Sources */,
28074	49EED1421051969400099FAB /* JSCanvasRenderingContext.cpp in Sources */,	28084	49EED1421051969400099FAB /* JSCanvasRenderingContext.cpp in Sources */,
28075	49EED1441051969400099FAB /* JSCanvasRenderingContext2D.cpp in Sources */,	28085	49EED1441051969400099FAB /* JSCanvasRenderingContext2D.cpp in Sources */,

Lines 138-143 a/Source/WebCore/dom/Document.cpp_sec1
- a/Source/WebCore/dom/Document.cpp -9 / +9 lines
138	#include "SelectorQuery.h"	138	#include "SelectorQuery.h"
139	#include "Settings.h"	139	#include "Settings.h"
140	#include "ShadowRoot.h"	140	#include "ShadowRoot.h"
		141	#include "SharedEventSenders.h"
141	#include "StyleProperties.h"	142	#include "StyleProperties.h"
142	#include "StyleResolver.h"	143	#include "StyleResolver.h"
143	#include "StyleSheetContents.h"	144	#include "StyleSheetContents.h"
Lines 472-477 Document::Document(Frame* frame, const URL& url, unsigned documentClasses, unsig a/Source/WebCore/dom/Document.cpp_sec2
472	, m_sawElementsInKnownNamespaces(false)	473	, m_sawElementsInKnownNamespaces(false)
473	, m_isSrcdocDocument(false)	474	, m_isSrcdocDocument(false)
474	, m_eventQueue(*this)	475	, m_eventQueue(*this)
		476	, m_sharedEventSenders(std::make_unique<SharedEventSenders>(*this))
475	, m_weakFactory(this)	477	, m_weakFactory(this)
476	#if ENABLE(FULLSCREEN_API)	478	#if ENABLE(FULLSCREEN_API)
477	, m_areKeysEnabledInFullScreen(0)	479	, m_areKeysEnabledInFullScreen(0)
Lines 2383-2399 void Document::implicitClose() a/Source/WebCore/dom/Document.cpp_sec3
2383	if (f) {	2385	if (f) {
2384	f->loader().icon().startLoader();	2386	f->loader().icon().startLoader();
2385	f->animation().startAnimationsIfNotSuspended(this);	2387	f->animation().startAnimationsIfNotSuspended(this);
2386
2387	// FIXME: We shouldn't be dispatching pending events globally on all Documents here.
2388	// For now, only do this when there is a Frame, otherwise this could cause JS reentrancy
2389	// below SVG font parsing, for example. <https://webkit.org/b/136269>
2390	ImageLoader::dispatchPendingBeforeLoadEvents();
2391	ImageLoader::dispatchPendingLoadEvents();
2392	ImageLoader::dispatchPendingErrorEvents();
2393	HTMLLinkElement::dispatchPendingLoadEvents();
2394	HTMLStyleElement::dispatchPendingLoadEvents();
2395	}	2388	}
2396		2389
		2390	sharedEventSenders().imageBeforeloadEventSender().dispatchPendingEvents();
		2391	sharedEventSenders().imageLoadEventSender().dispatchPendingEvents();
		2392	sharedEventSenders().imageErrorEventSender().dispatchPendingEvents();
		2393
		2394	sharedEventSenders().linkLoadEventSender().dispatchPendingEvents();
		2395	sharedEventSenders().styleLoadEventSender().dispatchPendingEvents();
		2396
2397	// To align the HTML load event and the SVGLoad event for the outermost <svg> element, fire it from	2397	// To align the HTML load event and the SVGLoad event for the outermost <svg> element, fire it from
2398	// here, instead of doing it from SVGElement::finishedParsingChildren (if externalResourcesRequired="false",	2398	// here, instead of doing it from SVGElement::finishedParsingChildren (if externalResourcesRequired="false",
2399	// which is the default, for ='true' its fired at a later time, once all external resources finished loading).	2399	// which is the default, for ='true' its fired at a later time, once all external resources finished loading).

Line 0 a/Source/WebCore/dom/SharedEventSenders.cpp_sec1
- a/Source/WebCore/dom/SharedEventSenders.cpp +75 lines
		1	/*
		2	* Copyright (C) 2014 University of Washington. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
		14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
		17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
		23	* THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "SharedEventSenders.h"
		28
		29	#include "HTMLLinkElement.h"
		30	#include "HTMLStyleElement.h"
		31	#include "ImageLoader.h"
		32
		33	namespace WebCore {
		34
		35	EventSender<HTMLLinkElement>& SharedEventSenders::linkLoadEventSender()
		36	{
		37	if (!m_linkLoadEventSender)
		38	m_linkLoadEventSender = std::make_unique<EventSender<HTMLLinkElement>>(m_document, eventNames().loadEvent);
		39
		40	return *m_linkLoadEventSender;
		41	}
		42
		43	EventSender<HTMLStyleElement>& SharedEventSenders::styleLoadEventSender()
		44	{
		45	if (!m_styleLoadEventSender)
		46	m_styleLoadEventSender = std::make_unique<EventSender<HTMLStyleElement>>(m_document, eventNames().loadEvent);
		47
		48	return *m_styleLoadEventSender;
		49	}
		50
		51	EventSender<ImageLoader>& SharedEventSenders::imageBeforeloadEventSender()
		52	{
		53	if (!m_imageBeforeloadEventSender)
		54	m_imageBeforeloadEventSender = std::make_unique<EventSender<ImageLoader>>(m_document, eventNames().beforeloadEvent);
		55
		56	return *m_imageBeforeloadEventSender;
		57	}
		58
		59	EventSender<ImageLoader>& SharedEventSenders::imageLoadEventSender()
		60	{
		61	if (!m_imageLoadEventSender)
		62	m_imageLoadEventSender = std::make_unique<EventSender<ImageLoader>>(m_document, eventNames().loadEvent);
		63
		64	return *m_imageLoadEventSender;
65	}
66
67	EventSender<ImageLoader>& SharedEventSenders::imageErrorEventSender()
68	{
69	if (!m_imageErrorEventSender)
70	m_imageErrorEventSender = std::make_unique<EventSender<ImageLoader>>(m_document, eventNames().errorEvent);
71
72	return *m_imageErrorEventSender;
73	}
74
75	} // namespace WebCore

Lines 47-52 a/Source/WebCore/html/HTMLLinkElement.cpp_sec1
- a/Source/WebCore/html/HTMLLinkElement.cpp -10 / +5 lines
47	#include "RenderStyle.h"	47	#include "RenderStyle.h"
48	#include "SecurityOrigin.h"	48	#include "SecurityOrigin.h"
49	#include "Settings.h"	49	#include "Settings.h"
		50	#include "SharedEventSenders.h"
50	#include "StyleInheritedData.h"	51	#include "StyleInheritedData.h"
51	#include "StyleResolveForDocument.h"	52	#include "StyleResolveForDocument.h"
52	#include "StyleSheetContents.h"	53	#include "StyleSheetContents.h"
Lines 57-66 namespace WebCore { a/Source/WebCore/html/HTMLLinkElement.cpp_sec2
57		58
58	using namespace HTMLNames;	59	using namespace HTMLNames;
59		60
60	static LinkEventSender& linkLoadEventSender()	61	LinkEventSender& HTMLLinkElement::linkLoadEventSender() const
61	{	62	{
62	DEPRECATED_DEFINE_STATIC_LOCAL(LinkEventSender, sharedLoadEventSender, (eventNames().loadEvent));	63	return document().sharedEventSenders().linkLoadEventSender();
63	return sharedLoadEventSender;
64	}	64	}
65		65
66	inline HTMLLinkElement::HTMLLinkElement(const QualifiedName& tagName, Document& document, bool createdByParser)	66	inline HTMLLinkElement::HTMLLinkElement(const QualifiedName& tagName, Document& document, bool createdByParser)
Lines 361-374 bool HTMLLinkElement::sheetLoaded() a/Source/WebCore/html/HTMLLinkElement.cpp_sec3
361	return false;	361	return false;
362	}	362	}
363		363
364	void HTMLLinkElement::dispatchPendingLoadEvents()	364	void HTMLLinkElement::dispatchPendingEvent(LinkEventSender& eventSender)
365	{	365	{
366	linkLoadEventSender().dispatchPendingEvents();	366	ASSERT_UNUSED(eventSender, &eventSender == &linkLoadEventSender());
367	}
368
369	void HTMLLinkElement::dispatchPendingEvent(LinkEventSender* eventSender)
370	{
371	ASSERT_UNUSED(eventSender, eventSender == &linkLoadEventSender());
372	if (m_loadedSheet)	367	if (m_loadedSheet)
373	linkLoaded();	368	linkLoaded();
374	else	369	else

Lines 68-75 public: a/Source/WebCore/html/HTMLLinkElement.h_sec1
- a/Source/WebCore/html/HTMLLinkElement.h -2 / +2 lines
68	void setSizes(const String&);	68	void setSizes(const String&);
69	DOMSettableTokenList* sizes() const;	69	DOMSettableTokenList* sizes() const;
70		70
71	void dispatchPendingEvent(LinkEventSender*);	71	void dispatchPendingEvent(LinkEventSender&);
72	static void dispatchPendingLoadEvents();	72	LinkEventSender& linkLoadEventSender() const;
73		73
74	private:	74	private:
75	virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;	75	virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;

Lines 33-48 a/Source/WebCore/html/HTMLStyleElement.cpp_sec1
- a/Source/WebCore/html/HTMLStyleElement.cpp -10 / +5 lines
33	#include "RuntimeEnabledFeatures.h"	33	#include "RuntimeEnabledFeatures.h"
34	#include "ScriptableDocumentParser.h"	34	#include "ScriptableDocumentParser.h"
35	#include "ShadowRoot.h"	35	#include "ShadowRoot.h"
		36	#include "SharedEventSenders.h"
36	#include "StyleSheetContents.h"	37	#include "StyleSheetContents.h"
37		38
38	namespace WebCore {	39	namespace WebCore {
39		40
40	using namespace HTMLNames;	41	using namespace HTMLNames;
41		42
42	static StyleEventSender& styleLoadEventSender()	43	StyleEventSender& HTMLStyleElement::styleLoadEventSender() const
43	{	44	{
44	DEPRECATED_DEFINE_STATIC_LOCAL(StyleEventSender, sharedLoadEventSender, (eventNames().loadEvent));	45	return document().sharedEventSenders().styleLoadEventSender();
45	return sharedLoadEventSender;
46	}	46	}
47		47
48	inline HTMLStyleElement::HTMLStyleElement(const QualifiedName& tagName, Document& document, bool createdByParser)	48	inline HTMLStyleElement::HTMLStyleElement(const QualifiedName& tagName, Document& document, bool createdByParser)
Lines 114-127 void HTMLStyleElement::childrenChanged(const ChildChange& change) a/Source/WebCore/html/HTMLStyleElement.cpp_sec2
114	m_styleSheetOwner.childrenChanged(*this);	114	m_styleSheetOwner.childrenChanged(*this);
115	}	115	}
116		116
117	void HTMLStyleElement::dispatchPendingLoadEvents()	117	void HTMLStyleElement::dispatchPendingEvent(StyleEventSender& eventSender)
118	{	118	{
119	styleLoadEventSender().dispatchPendingEvents();	119	ASSERT_UNUSED(eventSender, &eventSender == &styleLoadEventSender());
120	}
121
122	void HTMLStyleElement::dispatchPendingEvent(StyleEventSender* eventSender)
123	{
124	ASSERT_UNUSED(eventSender, eventSender == &styleLoadEventSender());
125	if (m_loadedSheet)	120	if (m_loadedSheet)
126	dispatchEvent(Event::create(eventNames().loadEvent, false, false));	121	dispatchEvent(Event::create(eventNames().loadEvent, false, false));
127	else	122	else

Lines 44-51 public: a/Source/WebCore/html/HTMLStyleElement.h_sec1
- a/Source/WebCore/html/HTMLStyleElement.h -2 / +3 lines
44	bool disabled() const;	44	bool disabled() const;
45	void setDisabled(bool);	45	void setDisabled(bool);
46		46
47	void dispatchPendingEvent(StyleEventSender*);	47	void dispatchPendingEvent(StyleEventSender&);
48	static void dispatchPendingLoadEvents();	48
		49	StyleEventSender& styleLoadEventSender() const;
49		50
50	private:	51	private:
51	HTMLStyleElement(const QualifiedName&, Document&, bool createdByParser);	52	HTMLStyleElement(const QualifiedName&, Document&, bool createdByParser);

Lines 38-43 a/Source/WebCore/loader/ImageLoader.cpp_sec1
- a/Source/WebCore/loader/ImageLoader.cpp -27 / +10 lines
38	#include "RenderImage.h"	38	#include "RenderImage.h"
39	#include "RenderSVGImage.h"	39	#include "RenderSVGImage.h"
40	#include "SecurityOrigin.h"	40	#include "SecurityOrigin.h"
		41	#include "SharedEventSenders.h"
41	#include <wtf/NeverDestroyed.h>	42	#include <wtf/NeverDestroyed.h>
42		43
43	#if ENABLE(VIDEO)	44	#if ENABLE(VIDEO)
Lines 63-84 template<> struct ValueCheck<WebCore::ImageLoader*> { a/Source/WebCore/loader/ImageLoader.cpp_sec2
63		64
64	namespace WebCore {	65	namespace WebCore {
65		66
66	static ImageEventSender& beforeLoadEventSender()	67	ImageEventSender& ImageLoader::beforeLoadEventSender() const
67	{	68	{
68	static NeverDestroyed<ImageEventSender> sender(eventNames().beforeloadEvent);	69	return m_element.document().sharedEventSenders().imageBeforeloadEventSender();
69	return sender;
70	}	70	}
71		71
72	static ImageEventSender& loadEventSender()	72	ImageEventSender& ImageLoader::loadEventSender() const
73	{	73	{
74	static NeverDestroyed<ImageEventSender> sender(eventNames().loadEvent);	74	return m_element.document().sharedEventSenders().imageLoadEventSender();
75	return sender;
76	}	75	}
77		76
78	static ImageEventSender& errorEventSender()	77	ImageEventSender& ImageLoader::errorEventSender() const
79	{	78	{
80	static NeverDestroyed<ImageEventSender> sender(eventNames().errorEvent);	79	return m_element.document().sharedEventSenders().imageErrorEventSender();
81	return sender;
82	}	80	}
83		81
84	static inline bool pageIsBeingDismissed(Document& document)	82	static inline bool pageIsBeingDismissed(Document& document)
Lines 379-388 void ImageLoader::timerFired(Timer<ImageLoader>&) a/Source/WebCore/loader/ImageLoader.cpp_sec3
379	element().deref();	377	element().deref();
380	}	378	}
381		379
382	void ImageLoader::dispatchPendingEvent(ImageEventSender* eventSender)	380	void ImageLoader::dispatchPendingEvent(ImageEventSender& eventSender)
383	{	381	{
384	ASSERT(eventSender == &beforeLoadEventSender() \|\| eventSender == &loadEventSender() \|\| eventSender == &errorEventSender());	382	ASSERT(&eventSender == &beforeLoadEventSender() \|\| &eventSender == &loadEventSender() \|\| &eventSender == &errorEventSender());
385	const AtomicString& eventType = eventSender->eventType();	383	const AtomicString& eventType = eventSender.eventType();
386	if (eventType == eventNames().beforeloadEvent)	384	if (eventType == eventNames().beforeloadEvent)
387	dispatchPendingBeforeLoadEvent();	385	dispatchPendingBeforeLoadEvent();
388	if (eventType == eventNames().loadEvent)	386	if (eventType == eventNames().loadEvent)
Lines 448-468 void ImageLoader::dispatchPendingErrorEvent() a/Source/WebCore/loader/ImageLoader.cpp_sec4
448	updatedHasPendingEvent();	446	updatedHasPendingEvent();
449	}	447	}
450		448
451	void ImageLoader::dispatchPendingBeforeLoadEvents()
452	{
453	beforeLoadEventSender().dispatchPendingEvents();
454	}
455
456	void ImageLoader::dispatchPendingLoadEvents()
457	{
458	loadEventSender().dispatchPendingEvents();
459	}
460
461	void ImageLoader::dispatchPendingErrorEvents()
462	{
463	errorEventSender().dispatchPendingEvents();
464	}
465
466	void ImageLoader::elementDidMoveToNewDocument()	449	void ImageLoader::elementDidMoveToNewDocument()
467	{	450	{
468	clearFailedLoadURL();	451	clearFailedLoadURL();

Lines 65-75 public: a/Source/WebCore/loader/ImageLoader.h_sec1
- a/Source/WebCore/loader/ImageLoader.h -4 / +4 lines
65	bool hasPendingBeforeLoadEvent() const { return m_hasPendingBeforeLoadEvent; }	65	bool hasPendingBeforeLoadEvent() const { return m_hasPendingBeforeLoadEvent; }
66	bool hasPendingActivity() const { return m_hasPendingLoadEvent \|\| m_hasPendingErrorEvent; }	66	bool hasPendingActivity() const { return m_hasPendingLoadEvent \|\| m_hasPendingErrorEvent; }
67		67
68	void dispatchPendingEvent(ImageEventSender*);	68	void dispatchPendingEvent(ImageEventSender&);
69		69
70	static void dispatchPendingBeforeLoadEvents();	70	ImageEventSender& beforeLoadEventSender() const;
71	static void dispatchPendingLoadEvents();	71	ImageEventSender& loadEventSender() const;
72	static void dispatchPendingErrorEvents();	72	ImageEventSender& errorEventSender() const;
73		73
74	protected:	74	protected:
75	explicit ImageLoader(Element&);	75	explicit ImageLoader(Element&);

Lines 48-53 a/Source/WebCore/xml/parser/XMLDocumentParser.cpp_sec1
- a/Source/WebCore/xml/parser/XMLDocumentParser.cpp -3 / +1 lines
48	#include "SVGStyleElement.h"	48	#include "SVGStyleElement.h"
49	#include "ScriptElement.h"	49	#include "ScriptElement.h"
50	#include "ScriptSourceCode.h"	50	#include "ScriptSourceCode.h"
		51	#include "SharedEventSenders.h"
51	#include "TextResourceDecoder.h"	52	#include "TextResourceDecoder.h"
52	#include "TreeDepthLimit.h"	53	#include "TreeDepthLimit.h"
53	#include <wtf/Ref.h>	54	#include <wtf/Ref.h>
Lines 120-128 void XMLDocumentParser::append(PassRefPtr<StringImpl> inputSource) a/Source/WebCore/xml/parser/XMLDocumentParser.cpp_sec2
120	}	121	}
121		122
122	doWrite(source.toString());	123	doWrite(source.toString());
123
124	// After parsing, go ahead and dispatch image beforeload events.
125	ImageLoader::dispatchPendingBeforeLoadEvents();
126	}	124	}
127		125
128	void XMLDocumentParser::handleError(XMLErrors::ErrorType type, const char* m, TextPosition position)	126	void XMLDocumentParser::handleError(XMLErrors::ErrorType type, const char* m, TextPosition position)