Changeset 42633 in webkit


Ignore:
Timestamp:
Apr 17, 2009 6:31:50 PM (15 years ago)
Author:
ggaren@apple.com
Message:

2009-04-17 Geoffrey Garen <​ggaren@apple.com>

Reviewed by Oliver Hunt.

More fix for ​https://bugs.webkit.org/show_bug.cgi?id=21260
Unbounded memory growth when churning elements with anonymous event handler functions


Some refactoring of "inline" event listeners.


Renames:

dispatchEventForType => dispatchEvent
setWindowInlineEventListenerForTypeAndAttribute => setWindowInlineEventListener
removeInlineEventListenerForType => clearInlineEventListener
setInlineEventListenerForType => setInlineEventListener
inlineEventListenerForType => getInlineEventListener

  • bindings/js/JSLazyEventListener.cpp: (WebCore::eventParameterName): (WebCore::JSLazyEventListener::JSLazyEventListener): (WebCore::createInlineEventListener):
  • bindings/js/JSLazyEventListener.h: Added two helper functions for creating "inline" event listeners. These replace Document::createEventListener, and abstract the creation of JS event listeners for DOM attributes out of the DOM. Removed legacy JSProtectedEventListener constructor code for adding the event listener's function to a map, since lazy event listeners don't have functions at construction time.
  • dom/Document.cpp: (WebCore::Document::setFocusedNode):
  • dom/Document.h: (WebCore::Document::isSVGDocument):
  • dom/Element.cpp: (WebCore::Element::setWindowInlineEventListener):
  • dom/Element.h: Updated for renames. Nixed Document::createEventListener, mentioned above. Moved setWindowInlineEventListenerForTypeAndAttribute to Element, for simplicity.
  • dom/InputElement.cpp: (WebCore::InputElement::setValueFromRenderer):
  • dom/Node.cpp: (WebCore::Node::dispatchFocusEvent): (WebCore::Node::dispatchBlurEvent): (WebCore::Node::dispatchEvent): (WebCore::Node::clearInlineEventListener): (WebCore::Node::setInlineEventListener): (WebCore::Node::getInlineEventListener): (WebCore::Node::onabort): (WebCore::Node::setOnabort): (WebCore::Node::etc.):
  • dom/Node.h: Updated for renames.


  • editing/ReplaceSelectionCommand.cpp: (WebCore::ReplacementFragment::ReplacementFragment): Updated for renames.


Updated these files for renames, and to use the new createInlineEventListener
helper function:

  • html/HTMLBodyElement.cpp: (WebCore::HTMLBodyElement::parseMappedAttribute):
  • html/HTMLButtonElement.cpp: (WebCore::HTMLButtonElement::parseMappedAttribute):
  • html/HTMLElement.cpp: (WebCore::HTMLElement::parseMappedAttribute):
  • html/HTMLFormControlElement.cpp: (WebCore::HTMLFormControlElement::onChange):
  • html/HTMLFormElement.cpp: (WebCore::HTMLFormElement::prepareSubmit): (WebCore::HTMLFormElement::reset): (WebCore::HTMLFormElement::parseMappedAttribute):
  • html/HTMLFrameElementBase.cpp: (WebCore::HTMLFrameElementBase::parseMappedAttribute):
  • html/HTMLFrameSetElement.cpp: (WebCore::HTMLFrameSetElement::parseMappedAttribute):
  • html/HTMLImageElement.cpp: (WebCore::HTMLImageElement::parseMappedAttribute):
  • html/HTMLImageLoader.cpp: (WebCore::HTMLImageLoader::dispatchLoadEvent):
  • html/HTMLInputElement.cpp: (WebCore::HTMLInputElement::parseMappedAttribute): (WebCore::HTMLInputElement::onSearch):
  • html/HTMLMediaElement.cpp: (WebCore::HTMLMediaElement::loadInternal):
  • html/HTMLObjectElement.cpp: (WebCore::HTMLObjectElement::parseMappedAttribute):
  • html/HTMLScriptElement.cpp: (WebCore::HTMLScriptElement::parseMappedAttribute): (WebCore::HTMLScriptElement::dispatchLoadEvent): (WebCore::HTMLScriptElement::dispatchErrorEvent):
  • html/HTMLSelectElement.cpp: (WebCore::HTMLSelectElement::parseMappedAttribute):
  • html/HTMLTextAreaElement.cpp: (WebCore::HTMLTextAreaElement::parseMappedAttribute):
  • html/HTMLTokenizer.cpp: (WebCore::HTMLTokenizer::notifyFinished):
  • page/AccessibilityRenderObject.cpp: (WebCore::AccessibilityRenderObject::mouseButtonListener):
  • page/DOMWindow.cpp:
  • page/DOMWindow.h: (WebCore::DOMWindow::eventListeners):
  • page/EventHandler.cpp: (WebCore::EventHandler::canMouseDownStartSelect): (WebCore::EventHandler::canMouseDragExtendSelect): (WebCore::EventHandler::sendScrollEvent):
  • page/Page.cpp: (WebCore::networkStateChanged):
  • rendering/RenderListBox.cpp: (WebCore::RenderListBox::valueChanged):
  • rendering/RenderTextControl.cpp: (WebCore::RenderTextControl::selectionChanged):
  • svg/SVGElement.cpp: (WebCore::SVGElement::parseMappedAttribute):
  • svg/SVGElementInstance.cpp:
  • svg/SVGImageLoader.cpp: (WebCore::SVGImageLoader::dispatchLoadEvent):
  • svg/SVGSVGElement.cpp: (WebCore::SVGSVGElement::parseMappedAttribute):
  • svg/SVGScriptElement.cpp: (WebCore::SVGScriptElement::dispatchErrorEvent):
  • wml/WMLInputElement.cpp: (WebCore::WMLInputElement::defaultEventHandler):
Location:
trunk/WebCore
Files:
40 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r42631 r42633  
     12009-04-17  Geoffrey Garen  <ggaren@apple.com>
     2
     3        Reviewed by Oliver Hunt.
     4
     5        More fix for https://bugs.webkit.org/show_bug.cgi?id=21260
     6        Unbounded memory growth when churning elements with anonymous event handler functions
     7       
     8        Some refactoring of "inline" event listeners.
     9       
     10        Renames:
     11            dispatchEventForType => dispatchEvent
     12            setWindowInlineEventListenerForTypeAndAttribute => setWindowInlineEventListener
     13            removeInlineEventListenerForType => clearInlineEventListener
     14            setInlineEventListenerForType => setInlineEventListener
     15            inlineEventListenerForType => getInlineEventListener
     16
     17        * bindings/js/JSLazyEventListener.cpp:
     18        (WebCore::eventParameterName):
     19        (WebCore::JSLazyEventListener::JSLazyEventListener):
     20        (WebCore::createInlineEventListener):
     21        * bindings/js/JSLazyEventListener.h: Added two helper functions for
     22        creating "inline" event listeners. These replace Document::createEventListener,
     23        and abstract the creation of JS event listeners for DOM attributes out
     24        of the DOM. Removed legacy JSProtectedEventListener constructor code for
     25        adding the event listener's function to a map, since lazy event listeners
     26        don't have functions at construction time.
     27
     28        * dom/Document.cpp:
     29        (WebCore::Document::setFocusedNode):
     30        * dom/Document.h:
     31        (WebCore::Document::isSVGDocument):
     32        * dom/Element.cpp:
     33        (WebCore::Element::setWindowInlineEventListener):
     34        * dom/Element.h: Updated for renames. Nixed Document::createEventListener,
     35        mentioned above. Moved setWindowInlineEventListenerForTypeAndAttribute
     36        to Element, for simplicity.
     37
     38        * dom/InputElement.cpp:
     39        (WebCore::InputElement::setValueFromRenderer):
     40        * dom/Node.cpp:
     41        (WebCore::Node::dispatchFocusEvent):
     42        (WebCore::Node::dispatchBlurEvent):
     43        (WebCore::Node::dispatchEvent):
     44        (WebCore::Node::clearInlineEventListener):
     45        (WebCore::Node::setInlineEventListener):
     46        (WebCore::Node::getInlineEventListener):
     47        (WebCore::Node::onabort):
     48        (WebCore::Node::setOnabort):
     49        (WebCore::Node::etc.):
     50        * dom/Node.h: Updated for renames.
     51       
     52        * editing/ReplaceSelectionCommand.cpp:
     53        (WebCore::ReplacementFragment::ReplacementFragment): Updated for renames.
     54       
     55        Updated these files for renames, and to use the new createInlineEventListener
     56        helper function:
     57
     58        * html/HTMLBodyElement.cpp:
     59        (WebCore::HTMLBodyElement::parseMappedAttribute):
     60        * html/HTMLButtonElement.cpp:
     61        (WebCore::HTMLButtonElement::parseMappedAttribute):
     62        * html/HTMLElement.cpp:
     63        (WebCore::HTMLElement::parseMappedAttribute):
     64        * html/HTMLFormControlElement.cpp:
     65        (WebCore::HTMLFormControlElement::onChange):
     66        * html/HTMLFormElement.cpp:
     67        (WebCore::HTMLFormElement::prepareSubmit):
     68        (WebCore::HTMLFormElement::reset):
     69        (WebCore::HTMLFormElement::parseMappedAttribute):
     70        * html/HTMLFrameElementBase.cpp:
     71        (WebCore::HTMLFrameElementBase::parseMappedAttribute):
     72        * html/HTMLFrameSetElement.cpp:
     73        (WebCore::HTMLFrameSetElement::parseMappedAttribute):
     74        * html/HTMLImageElement.cpp:
     75        (WebCore::HTMLImageElement::parseMappedAttribute):
     76        * html/HTMLImageLoader.cpp:
     77        (WebCore::HTMLImageLoader::dispatchLoadEvent):
     78        * html/HTMLInputElement.cpp:
     79        (WebCore::HTMLInputElement::parseMappedAttribute):
     80        (WebCore::HTMLInputElement::onSearch):
     81        * html/HTMLMediaElement.cpp:
     82        (WebCore::HTMLMediaElement::loadInternal):
     83        * html/HTMLObjectElement.cpp:
     84        (WebCore::HTMLObjectElement::parseMappedAttribute):
     85        * html/HTMLScriptElement.cpp:
     86        (WebCore::HTMLScriptElement::parseMappedAttribute):
     87        (WebCore::HTMLScriptElement::dispatchLoadEvent):
     88        (WebCore::HTMLScriptElement::dispatchErrorEvent):
     89        * html/HTMLSelectElement.cpp:
     90        (WebCore::HTMLSelectElement::parseMappedAttribute):
     91        * html/HTMLTextAreaElement.cpp:
     92        (WebCore::HTMLTextAreaElement::parseMappedAttribute):
     93        * html/HTMLTokenizer.cpp:
     94        (WebCore::HTMLTokenizer::notifyFinished):
     95        * page/AccessibilityRenderObject.cpp:
     96        (WebCore::AccessibilityRenderObject::mouseButtonListener):
     97        * page/DOMWindow.cpp:
     98        * page/DOMWindow.h:
     99        (WebCore::DOMWindow::eventListeners):
     100        * page/EventHandler.cpp:
     101        (WebCore::EventHandler::canMouseDownStartSelect):
     102        (WebCore::EventHandler::canMouseDragExtendSelect):
     103        (WebCore::EventHandler::sendScrollEvent):
     104        * page/Page.cpp:
     105        (WebCore::networkStateChanged):
     106        * rendering/RenderListBox.cpp:
     107        (WebCore::RenderListBox::valueChanged):
     108        * rendering/RenderTextControl.cpp:
     109        (WebCore::RenderTextControl::selectionChanged):
     110        * svg/SVGElement.cpp:
     111        (WebCore::SVGElement::parseMappedAttribute):
     112        * svg/SVGElementInstance.cpp:
     113        * svg/SVGImageLoader.cpp:
     114        (WebCore::SVGImageLoader::dispatchLoadEvent):
     115        * svg/SVGSVGElement.cpp:
     116        (WebCore::SVGSVGElement::parseMappedAttribute):
     117        * svg/SVGScriptElement.cpp:
     118        (WebCore::SVGScriptElement::dispatchErrorEvent):
     119        * wml/WMLInputElement.cpp:
     120        (WebCore::WMLInputElement::defaultEventHandler):
     121
    11222009-04-17  David Kilzer  <ddkilzer@apple.com>
    2123

  • trunk/WebCore/bindings/js/JSLazyEventListener.cpp

    r42589 r42633  
    2424#include "JSNode.h"
    2525#include <runtime/FunctionConstructor.h>
     26#include <runtime/JSLock.h>
    2627#include <wtf/RefCountedLeakCounter.h>
    2728
    … …  
    3334static WTF::RefCountedLeakCounter eventListenerCounter("JSLazyEventListener");
    3435#endif
     36
     37static const String& eventParameterName(bool isSVGEvent)
     38{
     39    DEFINE_STATIC_LOCAL(const String, eventString, ("event"));
     40#if ENABLE(SVG)
     41    DEFINE_STATIC_LOCAL(const String, evtString, ("evt"));
     42#endif
     43    return isSVGEvent ? evtString : eventString;
     44}
    3545
    3646JSLazyEventListener::JSLazyEventListener(const String& functionName, const String& eventParameterName, const String& code, JSDOMGlobalObject* globalObject, Node* node, int lineNumber)
    … …  
    5565        m_lineNumber = 1;
    5666
    57     if (m_jsFunction) {
    58         JSDOMWindow::ProtectedListenersMap& listeners = isInline()
    59             ? m_globalObject->jsProtectedInlineEventListeners() : m_globalObject->jsProtectedEventListeners();
    60         listeners.set(m_jsFunction, this);
    61     }
    6267#ifndef NDEBUG
    6368    eventListenerCounter.increment();
    … …  
    148153}
    149154
     155PassRefPtr<JSLazyEventListener> createInlineEventListener(Node* node, Attribute* attr)
     156{
     157    ASSERT(node);
     158
     159    Document* document = node->document();
     160
     161    Frame* frame = document->frame();
     162    if (!frame)
     163        return 0;
     164
     165    ScriptController* scriptController = frame->script();
     166    if (!scriptController->isEnabled())
     167        return 0;
     168
     169    JSDOMWindow* globalObject = scriptController->globalObject();
     170
     171    return JSLazyEventListener::create(attr->localName().string(), eventParameterName(node->isSVGElement()), attr->value(), globalObject, node, scriptController->eventHandlerLineNumber());
     172}
     173
     174PassRefPtr<JSLazyEventListener> createInlineEventListener(Frame* frame, Attribute* attr)
     175{
     176    if (!frame)
     177        return 0;
     178
     179    ScriptController* scriptController = frame->script();
     180    if (!scriptController->isEnabled())
     181        return 0;
     182
     183    JSDOMWindow* globalObject = scriptController->globalObject();
     184
     185    return JSLazyEventListener::create(attr->localName().string(), eventParameterName(frame->document()->isSVGDocument()), attr->value(), globalObject, 0, scriptController->eventHandlerLineNumber());
     186}
     187
    150188} // namespace WebCore

  • trunk/WebCore/bindings/js/JSLazyEventListener.h

    r42589 r42633  
    2626namespace WebCore {
    2727
     28    class Attribute;
    2829    class Node;
    2930
    … …  
    5859    };
    5960
     61    PassRefPtr<JSLazyEventListener> createInlineEventListener(Node*, Attribute*);
     62    PassRefPtr<JSLazyEventListener> createInlineEventListener(Frame*, Attribute*);
     63
    6064} // namespace WebCore
    6165

  • trunk/WebCore/dom/Document.cpp

    r42589 r42633  
    24892489        RenderObject* r = static_cast<RenderObject*>(oldFocusedNode.get()->renderer());
    24902490        if (r && r->isTextControl() && toRenderTextControl(r)->isEdited()) {
    2491             oldFocusedNode->dispatchEventForType(eventNames().changeEvent, true, false);
     2491            oldFocusedNode->dispatchEvent(eventNames().changeEvent, true, false);
    24922492            if ((r = static_cast<RenderObject*>(oldFocusedNode.get()->renderer()))) {
    24932493                if (r->isTextControl())
    … …  
    27572757{
    27582758    return 0;
    2759 }
    2760 
    2761 PassRefPtr<EventListener> Document::createEventListener(const String& functionName, const String& code, Node* node)
    2762 {
    2763     Frame* frm = frame();
    2764     if (!frm || !frm->script()->isEnabled())
    2765         return 0;
    2766 
    2767     DEFINE_STATIC_LOCAL(const String, eventString, ("event"));
    2768 
    2769 #if ENABLE(SVG)
    2770     DEFINE_STATIC_LOCAL(const String, evtString, ("evt"));
    2771     if (node ? node->isSVGElement() : isSVGDocument())
    2772         return JSLazyEventListener::create(functionName, evtString, code, frm->script()->globalObject(), node, frm->script()->eventHandlerLineNumber());
    2773 #endif
    2774 
    2775     return JSLazyEventListener::create(functionName, eventString, code, frm->script()->globalObject(), node, frm->script()->eventHandlerLineNumber());
    2776 }
    2777 
    2778 void Document::setWindowInlineEventListenerForTypeAndAttribute(const AtomicString& eventType, Attribute* attr)
    2779 {
    2780     DOMWindow* domWindow = this->domWindow();
    2781     if (!domWindow)
    2782         return;
    2783     domWindow->setInlineEventListenerForType(eventType, createEventListener(attr->localName().string(), attr->value(), 0));
    27842759}
    27852760

  • trunk/WebCore/dom/Document.h

    r42446 r42633  
    305305#if ENABLE(SVG)
    306306    virtual bool isSVGDocument() const { return false; }
     307#else
     308    static bool isSVGDocument() const { return false; }
    307309#endif
    308310    virtual bool isPluginDocument() const { return false; }
    … …  
    576578    void addListenerTypeIfNeeded(const AtomicString& eventType);
    577579
    578     void setWindowInlineEventListenerForTypeAndAttribute(const AtomicString& eventType, Attribute*);
    579 
    580     PassRefPtr<EventListener> createEventListener(const String& functionName, const String& code, Node*);
    581 
    582580    CSSStyleDeclaration* getOverrideStyle(Element*, const String& pseudoElt);
    583581

  • trunk/WebCore/dom/Element.cpp

    r42377 r42633  
    13071307}
    13081308
    1309 }
     1309void Element::setWindowInlineEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
     1310{
     1311    DOMWindow* domWindow = document()->domWindow();
     1312    if (!domWindow)
     1313        return;
     1314    domWindow->setInlineEventListener(eventType, listener);
     1315}
     1316
     1317} // namespace WebCore

  • trunk/WebCore/dom/Element.h

    r42107 r42633  
    230230    ElementRareData* rareData() const;
    231231    ElementRareData* ensureRareData();
     232    void setWindowInlineEventListener(const AtomicString& eventType, PassRefPtr<EventListener>);
    232233   
    233234    mutable RefPtr<NamedNodeMap> namedAttrMap;

  • trunk/WebCore/dom/InputElement.cpp

    r42377 r42633  
    149149
    150150    // Fire the "input" DOM event
    151     element->dispatchEventForType(eventNames().inputEvent, true, false);
     151    element->dispatchEvent(eventNames().inputEvent, true, false);
    152152    notifyFormStateChanged(data, document);
    153153}

  • trunk/WebCore/dom/Node.cpp

    r42446 r42633  
    27652765void Node::dispatchFocusEvent()
    27662766{
    2767     dispatchEventForType(eventNames().focusEvent, false, false);
     2767    dispatchEvent(eventNames().focusEvent, false, false);
    27682768}
    27692769
    27702770void Node::dispatchBlurEvent()
    27712771{
    2772     dispatchEventForType(eventNames().blurEvent, false, false);
    2773 }
    2774 
    2775 bool Node::dispatchEventForType(const AtomicString& eventType, bool canBubbleArg, bool cancelableArg)
     2772    dispatchEvent(eventNames().blurEvent, false, false);
     2773}
     2774
     2775bool Node::dispatchEvent(const AtomicString& eventType, bool canBubbleArg, bool cancelableArg)
    27762776{
    27772777    ASSERT(!eventDispatchForbidden());
    … …  
    27962796}
    27972797
    2798 void Node::removeInlineEventListenerForType(const AtomicString& eventType)
     2798void Node::clearInlineEventListener(const AtomicString& eventType)
    27992799{
    28002800    if (!hasRareData())
    … …  
    28232823}
    28242824
    2825 void Node::setInlineEventListenerForType(const AtomicString& eventType, PassRefPtr<EventListener> listener)
    2826 {
    2827     // In case we are the only one holding a reference to it, we don't want removeInlineEventListenerForType to destroy it.
    2828     removeInlineEventListenerForType(eventType);
     2825void Node::setInlineEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
     2826{
     2827    clearInlineEventListener(eventType);
    28292828    if (listener)
    28302829        addEventListener(eventType, listener, false);
    28312830}
    28322831
    2833 void Node::setInlineEventListenerForTypeAndAttribute(const AtomicString& eventType, Attribute* attr)
    2834 {
    2835     setInlineEventListenerForType(eventType, document()->createEventListener(attr->localName().string(), attr->value(), this));
    2836 }
    2837 
    2838 EventListener* Node::inlineEventListenerForType(const AtomicString& eventType) const
     2832EventListener* Node::getInlineEventListener(const AtomicString& eventType) const
    28392833{
    28402834    const RegisteredEventListenerVector& listeners = eventListeners();
    … …  
    28782872EventListener* Node::onabort() const
    28792873{
    2880     return inlineEventListenerForType(eventNames().abortEvent);
     2874    return getInlineEventListener(eventNames().abortEvent);
    28812875}
    28822876
    28832877void Node::setOnabort(PassRefPtr<EventListener> eventListener)
    28842878{
    2885     setInlineEventListenerForType(eventNames().abortEvent, eventListener);
     2879    setInlineEventListener(eventNames().abortEvent, eventListener);
    28862880}
    28872881
    28882882EventListener* Node::onblur() const
    28892883{
    2890     return inlineEventListenerForType(eventNames().blurEvent);
     2884    return getInlineEventListener(eventNames().blurEvent);
    28912885}
    28922886
    28932887void Node::setOnblur(PassRefPtr<EventListener> eventListener)
    28942888{
    2895     setInlineEventListenerForType(eventNames().blurEvent, eventListener);
     2889    setInlineEventListener(eventNames().blurEvent, eventListener);
    28962890}
    28972891
    28982892EventListener* Node::onchange() const
    28992893{
    2900     return inlineEventListenerForType(eventNames().changeEvent);
     2894    return getInlineEventListener(eventNames().changeEvent);
    29012895}
    29022896
    29032897void Node::setOnchange(PassRefPtr<EventListener> eventListener)
    29042898{
    2905     setInlineEventListenerForType(eventNames().changeEvent, eventListener);
     2899    setInlineEventListener(eventNames().changeEvent, eventListener);
    29062900}
    29072901
    29082902EventListener* Node::onclick() const
    29092903{
    2910     return inlineEventListenerForType(eventNames().clickEvent);
     2904    return getInlineEventListener(eventNames().clickEvent);
    29112905}
    29122906
    29132907void Node::setOnclick(PassRefPtr<EventListener> eventListener)
    29142908{
    2915     setInlineEventListenerForType(eventNames().clickEvent, eventListener);
     2909    setInlineEventListener(eventNames().clickEvent, eventListener);
    29162910}
    29172911
    29182912EventListener* Node::oncontextmenu() const
    29192913{
    2920     return inlineEventListenerForType(eventNames().contextmenuEvent);
     2914    return getInlineEventListener(eventNames().contextmenuEvent);
    29212915}
    29222916
    29232917void Node::setOncontextmenu(PassRefPtr<EventListener> eventListener)
    29242918{
    2925     setInlineEventListenerForType(eventNames().contextmenuEvent, eventListener);
     2919    setInlineEventListener(eventNames().contextmenuEvent, eventListener);
    29262920}
    29272921
    29282922EventListener* Node::ondblclick() const
    29292923{
    2930     return inlineEventListenerForType(eventNames().dblclickEvent);
     2924    return getInlineEventListener(eventNames().dblclickEvent);
    29312925}
    29322926
    29332927void Node::setOndblclick(PassRefPtr<EventListener> eventListener)
    29342928{
    2935     setInlineEventListenerForType(eventNames().dblclickEvent, eventListener);
     2929    setInlineEventListener(eventNames().dblclickEvent, eventListener);
    29362930}
    29372931
    29382932EventListener* Node::onerror() const
    29392933{
    2940     return inlineEventListenerForType(eventNames().errorEvent);
     2934    return getInlineEventListener(eventNames().errorEvent);
    29412935}
    29422936
    29432937void Node::setOnerror(PassRefPtr<EventListener> eventListener)
    29442938{
    2945     setInlineEventListenerForType(eventNames().errorEvent, eventListener);
     2939    setInlineEventListener(eventNames().errorEvent, eventListener);
    29462940}
    29472941
    29482942EventListener* Node::onfocus() const
    29492943{
    2950     return inlineEventListenerForType(eventNames().focusEvent);
     2944    return getInlineEventListener(eventNames().focusEvent);
    29512945}
    29522946
    29532947void Node::setOnfocus(PassRefPtr<EventListener> eventListener)
    29542948{
    2955     setInlineEventListenerForType(eventNames().focusEvent, eventListener);
     2949    setInlineEventListener(eventNames().focusEvent, eventListener);
    29562950}
    29572951
    29582952EventListener* Node::oninput() const
    29592953{
    2960     return inlineEventListenerForType(eventNames().inputEvent);
     2954    return getInlineEventListener(eventNames().inputEvent);
    29612955}
    29622956
    29632957void Node::setOninput(PassRefPtr<EventListener> eventListener)
    29642958{
    2965     setInlineEventListenerForType(eventNames().inputEvent, eventListener);
     2959    setInlineEventListener(eventNames().inputEvent, eventListener);
    29662960}
    29672961
    29682962EventListener* Node::onkeydown() const
    29692963{
    2970     return inlineEventListenerForType(eventNames().keydownEvent);
     2964    return getInlineEventListener(eventNames().keydownEvent);
    29712965}
    29722966
    29732967void Node::setOnkeydown(PassRefPtr<EventListener> eventListener)
    29742968{
    2975     setInlineEventListenerForType(eventNames().keydownEvent, eventListener);
     2969    setInlineEventListener(eventNames().keydownEvent, eventListener);
    29762970}
    29772971
    29782972EventListener* Node::onkeypress() const
    29792973{
    2980     return inlineEventListenerForType(eventNames().keypressEvent);
     2974    return getInlineEventListener(eventNames().keypressEvent);
    29812975}
    29822976
    29832977void Node::setOnkeypress(PassRefPtr<EventListener> eventListener)
    29842978{
    2985     setInlineEventListenerForType(eventNames().keypressEvent, eventListener);
     2979    setInlineEventListener(eventNames().keypressEvent, eventListener);
    29862980}
    29872981
    29882982EventListener* Node::onkeyup() const
    29892983{
    2990     return inlineEventListenerForType(eventNames().keyupEvent);
     2984    return getInlineEventListener(eventNames().keyupEvent);
    29912985}
    29922986
    29932987void Node::setOnkeyup(PassRefPtr<EventListener> eventListener)
    29942988{
    2995     setInlineEventListenerForType(eventNames().keyupEvent, eventListener);
     2989    setInlineEventListener(eventNames().keyupEvent, eventListener);
    29962990}
    29972991
    29982992EventListener* Node::onload() const
    29992993{
    3000     return inlineEventListenerForType(eventNames().loadEvent);
     2994    return getInlineEventListener(eventNames().loadEvent);
    30012995}
    30022996
    30032997void Node::setOnload(PassRefPtr<EventListener> eventListener)
    30042998{
    3005     setInlineEventListenerForType(eventNames().loadEvent, eventListener);
     2999    setInlineEventListener(eventNames().loadEvent, eventListener);
    30063000}
    30073001
    30083002EventListener* Node::onmousedown() const
    30093003{
    3010     return inlineEventListenerForType(eventNames().mousedownEvent);
     3004    return getInlineEventListener(eventNames().mousedownEvent);
    30113005}
    30123006
    30133007void Node::setOnmousedown(PassRefPtr<EventListener> eventListener)
    30143008{
    3015     setInlineEventListenerForType(eventNames().mousedownEvent, eventListener);
     3009    setInlineEventListener(eventNames().mousedownEvent, eventListener);
    30163010}
    30173011
    30183012EventListener* Node::onmousemove() const
    30193013{
    3020     return inlineEventListenerForType(eventNames().mousemoveEvent);
     3014    return getInlineEventListener(eventNames().mousemoveEvent);
    30213015}
    30223016
    30233017void Node::setOnmousemove(PassRefPtr<EventListener> eventListener)
    30243018{
    3025     setInlineEventListenerForType(eventNames().mousemoveEvent, eventListener);
     3019    setInlineEventListener(eventNames().mousemoveEvent, eventListener);
    30263020}
    30273021
    30283022EventListener* Node::onmouseout() const
    30293023{
    3030     return inlineEventListenerForType(eventNames().mouseoutEvent);
     3024    return getInlineEventListener(eventNames().mouseoutEvent);
    30313025}
    30323026
    30333027void Node::setOnmouseout(PassRefPtr<EventListener> eventListener)
    30343028{
    3035     setInlineEventListenerForType(eventNames().mouseoutEvent, eventListener);
     3029    setInlineEventListener(eventNames().mouseoutEvent, eventListener);
    30363030}
    30373031
    30383032EventListener* Node::onmouseover() const
    30393033{
    3040     return inlineEventListenerForType(eventNames().mouseoverEvent);
     3034    return getInlineEventListener(eventNames().mouseoverEvent);
    30413035}
    30423036
    30433037void Node::setOnmouseover(PassRefPtr<EventListener> eventListener)
    30443038{
    3045     setInlineEventListenerForType(eventNames().mouseoverEvent, eventListener);
     3039    setInlineEventListener(eventNames().mouseoverEvent, eventListener);
    30463040}
    30473041
    30483042EventListener* Node::onmouseup() const
    30493043{
    3050     return inlineEventListenerForType(eventNames().mouseupEvent);
     3044    return getInlineEventListener(eventNames().mouseupEvent);
    30513045}
    30523046
    30533047void Node::setOnmouseup(PassRefPtr<EventListener> eventListener)
    30543048{
    3055     setInlineEventListenerForType(eventNames().mouseupEvent, eventListener);
     3049    setInlineEventListener(eventNames().mouseupEvent, eventListener);
    30563050}
    30573051
    30583052EventListener* Node::onmousewheel() const
    30593053{
    3060     return inlineEventListenerForType(eventNames().mousewheelEvent);
     3054    return getInlineEventListener(eventNames().mousewheelEvent);
    30613055}
    30623056
    30633057void Node::setOnmousewheel(PassRefPtr<EventListener> eventListener)
    30643058{
    3065     setInlineEventListenerForType(eventNames().mousewheelEvent, eventListener);
     3059    setInlineEventListener(eventNames().mousewheelEvent, eventListener);
    30663060}
    30673061
    30683062EventListener* Node::onbeforecut() const
    30693063{
    3070     return inlineEventListenerForType(eventNames().beforecutEvent);
     3064    return getInlineEventListener(eventNames().beforecutEvent);
    30713065}
    30723066
    30733067void Node::setOnbeforecut(PassRefPtr<EventListener> eventListener)
    30743068{
    3075     setInlineEventListenerForType(eventNames().beforecutEvent, eventListener);
     3069    setInlineEventListener(eventNames().beforecutEvent, eventListener);
    30763070}
    30773071
    30783072EventListener* Node::oncut() const
    30793073{
    3080     return inlineEventListenerForType(eventNames().cutEvent);
     3074    return getInlineEventListener(eventNames().cutEvent);
    30813075}
    30823076
    30833077void Node::setOncut(PassRefPtr<EventListener> eventListener)
    30843078{
    3085     setInlineEventListenerForType(eventNames().cutEvent, eventListener);
     3079    setInlineEventListener(eventNames().cutEvent, eventListener);
    30863080}
    30873081
    30883082EventListener* Node::onbeforecopy() const
    30893083{
    3090     return inlineEventListenerForType(eventNames().beforecopyEvent);
     3084    return getInlineEventListener(eventNames().beforecopyEvent);
    30913085}
    30923086
    30933087void Node::setOnbeforecopy(PassRefPtr<EventListener> eventListener)
    30943088{
    3095     setInlineEventListenerForType(eventNames().beforecopyEvent, eventListener);
     3089    setInlineEventListener(eventNames().beforecopyEvent, eventListener);
    30963090}
    30973091
    30983092EventListener* Node::oncopy() const
    30993093{
    3100     return inlineEventListenerForType(eventNames().copyEvent);
     3094    return getInlineEventListener(eventNames().copyEvent);
    31013095}
    31023096
    31033097void Node::setOncopy(PassRefPtr<EventListener> eventListener)
    31043098{
    3105     setInlineEventListenerForType(eventNames().copyEvent, eventListener);
     3099    setInlineEventListener(eventNames().copyEvent, eventListener);
    31063100}
    31073101
    31083102EventListener* Node::onbeforepaste() const
    31093103{
    3110     return inlineEventListenerForType(eventNames().beforepasteEvent);
     3104    return getInlineEventListener(eventNames().beforepasteEvent);
    31113105}
    31123106
    31133107void Node::setOnbeforepaste(PassRefPtr<EventListener> eventListener)
    31143108{
    3115     setInlineEventListenerForType(eventNames().beforepasteEvent, eventListener);
     3109    setInlineEventListener(eventNames().beforepasteEvent, eventListener);
    31163110}
    31173111
    31183112EventListener* Node::onpaste() const
    31193113{
    3120     return inlineEventListenerForType(eventNames().pasteEvent);
     3114    return getInlineEventListener(eventNames().pasteEvent);
    31213115}
    31223116
    31233117void Node::setOnpaste(PassRefPtr<EventListener> eventListener)
    31243118{
    3125     setInlineEventListenerForType(eventNames().pasteEvent, eventListener);
     3119    setInlineEventListener(eventNames().pasteEvent, eventListener);
    31263120}
    31273121
    31283122EventListener* Node::ondragenter() const
    31293123{
    3130     return inlineEventListenerForType(eventNames().dragenterEvent);
     3124    return getInlineEventListener(eventNames().dragenterEvent);
    31313125}
    31323126
    31333127void Node::setOndragenter(PassRefPtr<EventListener> eventListener)
    31343128{
    3135     setInlineEventListenerForType(eventNames().dragenterEvent, eventListener);
     3129    setInlineEventListener(eventNames().dragenterEvent, eventListener);
    31363130}
    31373131
    31383132EventListener* Node::ondragover() const
    31393133{
    3140     return inlineEventListenerForType(eventNames().dragoverEvent);
     3134    return getInlineEventListener(eventNames().dragoverEvent);
    31413135}
    31423136
    31433137void Node::setOndragover(PassRefPtr<EventListener> eventListener)
    31443138{
    3145     setInlineEventListenerForType(eventNames().dragoverEvent, eventListener);
     3139    setInlineEventListener(eventNames().dragoverEvent, eventListener);
    31463140}
    31473141
    31483142EventListener* Node::ondragleave() const
    31493143{
    3150     return inlineEventListenerForType(eventNames().dragleaveEvent);
     3144    return getInlineEventListener(eventNames().dragleaveEvent);
    31513145}
    31523146
    31533147void Node::setOndragleave(PassRefPtr<EventListener> eventListener)
    31543148{
    3155     setInlineEventListenerForType(eventNames().dragleaveEvent, eventListener);
     3149    setInlineEventListener(eventNames().dragleaveEvent, eventListener);
    31563150}
    31573151
    31583152EventListener* Node::ondrop() const
    31593153{
    3160     return inlineEventListenerForType(eventNames().dropEvent);
     3154    return getInlineEventListener(eventNames().dropEvent);
    31613155}
    31623156
    31633157void Node::setOndrop(PassRefPtr<EventListener> eventListener)
    31643158{
    3165     setInlineEventListenerForType(eventNames().dropEvent, eventListener);
     3159    setInlineEventListener(eventNames().dropEvent, eventListener);
    31663160}
    31673161
    31683162EventListener* Node::ondragstart() const
    31693163{
    3170     return inlineEventListenerForType(eventNames().dragstartEvent);
     3164    return getInlineEventListener(eventNames().dragstartEvent);
    31713165}
    31723166
    31733167void Node::setOndragstart(PassRefPtr<EventListener> eventListener)
    31743168{
    3175     setInlineEventListenerForType(eventNames().dragstartEvent, eventListener);
     3169    setInlineEventListener(eventNames().dragstartEvent, eventListener);
    31763170}
    31773171
    31783172EventListener* Node::ondrag() const
    31793173{
    3180     return inlineEventListenerForType(eventNames().dragEvent);
     3174    return getInlineEventListener(eventNames().dragEvent);
    31813175}
    31823176
    31833177void Node::setOndrag(PassRefPtr<EventListener> eventListener)
    31843178{
    3185     setInlineEventListenerForType(eventNames().dragEvent, eventListener);
     3179    setInlineEventListener(eventNames().dragEvent, eventListener);
    31863180}
    31873181
    31883182EventListener* Node::ondragend() const
    31893183{
    3190     return inlineEventListenerForType(eventNames().dragendEvent);
     3184    return getInlineEventListener(eventNames().dragendEvent);
    31913185}
    31923186
    31933187void Node::setOndragend(PassRefPtr<EventListener> eventListener)
    31943188{
    3195     setInlineEventListenerForType(eventNames().dragendEvent, eventListener);
     3189    setInlineEventListener(eventNames().dragendEvent, eventListener);
    31963190}
    31973191
    31983192EventListener* Node::onreset() const
    31993193{
    3200     return inlineEventListenerForType(eventNames().resetEvent);
     3194    return getInlineEventListener(eventNames().resetEvent);
    32013195}
    32023196
    32033197void Node::setOnreset(PassRefPtr<EventListener> eventListener)
    32043198{
    3205     setInlineEventListenerForType(eventNames().resetEvent, eventListener);
     3199    setInlineEventListener(eventNames().resetEvent, eventListener);
    32063200}
    32073201
    32083202EventListener* Node::onresize() const
    32093203{
    3210     return inlineEventListenerForType(eventNames().resizeEvent);
     3204    return getInlineEventListener(eventNames().resizeEvent);
    32113205}
    32123206
    32133207void Node::setOnresize(PassRefPtr<EventListener> eventListener)
    32143208{
    3215     setInlineEventListenerForType(eventNames().resizeEvent, eventListener);
     3209    setInlineEventListener(eventNames().resizeEvent, eventListener);
    32163210}
    32173211
    32183212EventListener* Node::onscroll() const
    32193213{
    3220     return inlineEventListenerForType(eventNames().scrollEvent);
     3214    return getInlineEventListener(eventNames().scrollEvent);
    32213215}
    32223216
    32233217void Node::setOnscroll(PassRefPtr<EventListener> eventListener)
    32243218{
    3225     setInlineEventListenerForType(eventNames().scrollEvent, eventListener);
     3219    setInlineEventListener(eventNames().scrollEvent, eventListener);
    32263220}
    32273221
    32283222EventListener* Node::onsearch() const
    32293223{
    3230     return inlineEventListenerForType(eventNames().searchEvent);
     3224    return getInlineEventListener(eventNames().searchEvent);
    32313225}
    32323226
    32333227void Node::setOnsearch(PassRefPtr<EventListener> eventListener)
    32343228{
    3235     setInlineEventListenerForType(eventNames().searchEvent, eventListener);
     3229    setInlineEventListener(eventNames().searchEvent, eventListener);
    32363230}
    32373231
    32383232EventListener* Node::onselect() const
    32393233{
    3240     return inlineEventListenerForType(eventNames().selectEvent);
     3234    return getInlineEventListener(eventNames().selectEvent);
    32413235}
    32423236
    32433237void Node::setOnselect(PassRefPtr<EventListener> eventListener)
    32443238{
    3245     setInlineEventListenerForType(eventNames().selectEvent, eventListener);
     3239    setInlineEventListener(eventNames().selectEvent, eventListener);
    32463240}
    32473241
    32483242EventListener* Node::onselectstart() const
    32493243{
    3250     return inlineEventListenerForType(eventNames().selectstartEvent);
     3244    return getInlineEventListener(eventNames().selectstartEvent);
    32513245}
    32523246
    32533247void Node::setOnselectstart(PassRefPtr<EventListener> eventListener)
    32543248{
    3255     setInlineEventListenerForType(eventNames().selectstartEvent, eventListener);
     3249    setInlineEventListener(eventNames().selectstartEvent, eventListener);
    32563250}
    32573251
    32583252EventListener* Node::onsubmit() const
    32593253{
    3260     return inlineEventListenerForType(eventNames().submitEvent);
     3254    return getInlineEventListener(eventNames().submitEvent);
    32613255}
    32623256
    32633257void Node::setOnsubmit(PassRefPtr<EventListener> eventListener)
    32643258{
    3265     setInlineEventListenerForType(eventNames().submitEvent, eventListener);
     3259    setInlineEventListener(eventNames().submitEvent, eventListener);
    32663260}
    32673261
    32683262EventListener* Node::onunload() const
    32693263{
    3270     return inlineEventListenerForType(eventNames().unloadEvent);
     3264    return getInlineEventListener(eventNames().unloadEvent);
    32713265}
    32723266
    32733267void Node::setOnunload(PassRefPtr<EventListener> eventListener)
    32743268{
    3275     setInlineEventListenerForType(eventNames().unloadEvent, eventListener);
     3269    setInlineEventListener(eventNames().unloadEvent, eventListener);
    32763270}
    32773271

  • trunk/WebCore/dom/Node.h

    r42446 r42633  
    516516    virtual ScriptExecutionContext* scriptExecutionContext() const;
    517517
     518    // Used for standard DOM addEventListener / removeEventListener APIs.
    518519    virtual void addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
    519520    virtual void removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
     521
     522    // Used for legacy "onEvent" property APIs.
     523    void setInlineEventListener(const AtomicString& eventType, PassRefPtr<EventListener>);
     524    void clearInlineEventListener(const AtomicString& eventType);
     525    EventListener* getInlineEventListener(const AtomicString& eventType) const;
     526
    520527    virtual bool dispatchEvent(PassRefPtr<Event>, ExceptionCode&);
     528    bool dispatchEvent(const AtomicString& eventType, bool canBubble, bool cancelable);
     529
    521530    void removeAllEventListeners() { if (hasRareData()) removeAllEventListenersSlowCase(); }
    522 
    523     void setInlineEventListenerForType(const AtomicString& eventType, PassRefPtr<EventListener>);
    524     void setInlineEventListenerForTypeAndAttribute(const AtomicString& eventType, Attribute*);
    525     void removeInlineEventListenerForType(const AtomicString& eventType);
    526     bool dispatchEventForType(const AtomicString& eventType, bool canBubble, bool cancelable);
    527     EventListener* inlineEventListenerForType(const AtomicString& eventType) const;
    528531
    529532    void dispatchSubtreeModifiedEvent();

  • trunk/WebCore/editing/ReplaceSelectionCommand.cpp

    r42549 r42633  
    125125    Node* shadowAncestorNode = editableRoot->shadowAncestorNode();
    126126   
    127     if (!editableRoot->inlineEventListenerForType(eventNames().webkitBeforeTextInsertedEvent) &&
     127    if (!editableRoot->getInlineEventListener(eventNames().webkitBeforeTextInsertedEvent) &&
    128128        // FIXME: Remove these checks once textareas and textfields actually register an event handler.
    129129        !(shadowAncestorNode && shadowAncestorNode->renderer() && shadowAncestorNode->renderer()->isTextControl()) &&

  • trunk/WebCore/html/HTMLBodyElement.cpp

    r42424 r42633  
    3737#include "HTMLFrameElementBase.h"
    3838#include "HTMLNames.h"
     39#include "JSLazyEventListener.h"
    3940
    4041namespace WebCore {
    … …  
    133134            document()->recalcStyle(Force);
    134135    } else if (attr->name() == onloadAttr)
    135         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().loadEvent, attr);
     136        setWindowInlineEventListener(eventNames().loadEvent, createInlineEventListener(document()->frame(), attr));
    136137    else if (attr->name() == onbeforeunloadAttr)
    137         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().beforeunloadEvent, attr);
     138        setWindowInlineEventListener(eventNames().beforeunloadEvent, createInlineEventListener(document()->frame(), attr));
    138139    else if (attr->name() == onunloadAttr)
    139         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().unloadEvent, attr);
     140        setWindowInlineEventListener(eventNames().unloadEvent, createInlineEventListener(document()->frame(), attr));
    140141    else if (attr->name() == onblurAttr)
    141         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().blurEvent, attr);
     142        setWindowInlineEventListener(eventNames().blurEvent, createInlineEventListener(document()->frame(), attr));
    142143    else if (attr->name() == onfocusAttr)
    143         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().focusEvent, attr);
     144        setWindowInlineEventListener(eventNames().focusEvent, createInlineEventListener(document()->frame(), attr));
    144145    else if (attr->name() == onresizeAttr)
    145         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().resizeEvent, attr);
     146        setWindowInlineEventListener(eventNames().resizeEvent, createInlineEventListener(document()->frame(), attr));
    146147    else if (attr->name() == onscrollAttr)
    147         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().scrollEvent, attr);
     148        setWindowInlineEventListener(eventNames().scrollEvent, createInlineEventListener(document()->frame(), attr));
    148149    else if (attr->name() == onstorageAttr) {
    149150        // The HTML5 spec currently specifies that storage events are fired only at the body element of
    150151        // an HTMLDocument, which is why the onstorage attribute differs from the ones before it.
    151152        // The spec might change on this, and then so should we!
    152         setInlineEventListenerForTypeAndAttribute(eventNames().storageEvent, attr);
     153        setInlineEventListener(eventNames().storageEvent, createInlineEventListener(document()->frame(), attr));
    153154    } else
    154155        HTMLElement::parseMappedAttribute(attr);

  • trunk/WebCore/html/HTMLButtonElement.cpp

    r39601 r42633  
    3131#include "HTMLFormElement.h"
    3232#include "HTMLNames.h"
     33#include "JSLazyEventListener.h"
    3334#include "KeyboardEvent.h"
    3435#include "RenderButton.h"
    … …  
    9091        // See http://bugs.webkit.org/show_bug.cgi?id=12071
    9192    } else if (attr->name() == onfocusAttr) {
    92         setInlineEventListenerForTypeAndAttribute(eventNames().focusEvent, attr);
     93        setInlineEventListener(eventNames().focusEvent, createInlineEventListener(this, attr));
    9394    } else if (attr->name() == onblurAttr) {
    94         setInlineEventListenerForTypeAndAttribute(eventNames().blurEvent, attr);
     95        setInlineEventListener(eventNames().blurEvent, createInlineEventListener(this, attr));
    9596    } else
    9697        HTMLFormControlElement::parseMappedAttribute(attr);

  • trunk/WebCore/html/HTMLElement.cpp

    r42377 r42633  
    3737#include "HTMLFormElement.h"
    3838#include "HTMLNames.h"
    39 #include "HTMLTokenizer.h" // parseHTMLDocumentFragment
     39#include "HTMLTokenizer.h"
     40#include "JSLazyEventListener.h"
    4041#include "RenderWordBreak.h"
    4142#include "Settings.h"
    … …  
    142143// standard events
    143144    else if (attr->name() == onclickAttr) {
    144         setInlineEventListenerForTypeAndAttribute(eventNames().clickEvent, attr);
     145        setInlineEventListener(eventNames().clickEvent, createInlineEventListener(this, attr));
    145146    } else if (attr->name() == oncontextmenuAttr) {
    146         setInlineEventListenerForTypeAndAttribute(eventNames().contextmenuEvent, attr);
     147        setInlineEventListener(eventNames().contextmenuEvent, createInlineEventListener(this, attr));
    147148    } else if (attr->name() == ondblclickAttr) {
    148         setInlineEventListenerForTypeAndAttribute(eventNames().dblclickEvent, attr);
     149        setInlineEventListener(eventNames().dblclickEvent, createInlineEventListener(this, attr));
    149150    } else if (attr->name() == onmousedownAttr) {
    150         setInlineEventListenerForTypeAndAttribute(eventNames().mousedownEvent, attr);
     151        setInlineEventListener(eventNames().mousedownEvent, createInlineEventListener(this, attr));
    151152    } else if (attr->name() == onmousemoveAttr) {
    152         setInlineEventListenerForTypeAndAttribute(eventNames().mousemoveEvent, attr);
     153        setInlineEventListener(eventNames().mousemoveEvent, createInlineEventListener(this, attr));
    153154    } else if (attr->name() == onmouseoutAttr) {
    154         setInlineEventListenerForTypeAndAttribute(eventNames().mouseoutEvent, attr);
     155        setInlineEventListener(eventNames().mouseoutEvent, createInlineEventListener(this, attr));
    155156    } else if (attr->name() == onmouseoverAttr) {
    156         setInlineEventListenerForTypeAndAttribute(eventNames().mouseoverEvent, attr);
     157        setInlineEventListener(eventNames().mouseoverEvent, createInlineEventListener(this, attr));
    157158    } else if (attr->name() == onmouseupAttr) {
    158         setInlineEventListenerForTypeAndAttribute(eventNames().mouseupEvent, attr);
     159        setInlineEventListener(eventNames().mouseupEvent, createInlineEventListener(this, attr));
    159160    } else if (attr->name() == onmousewheelAttr) {
    160         setInlineEventListenerForTypeAndAttribute(eventNames().mousewheelEvent, attr);
     161        setInlineEventListener(eventNames().mousewheelEvent, createInlineEventListener(this, attr));
    161162    } else if (attr->name() == onfocusAttr) {
    162         setInlineEventListenerForTypeAndAttribute(eventNames().focusEvent, attr);
     163        setInlineEventListener(eventNames().focusEvent, createInlineEventListener(this, attr));
    163164    } else if (attr->name() == onblurAttr) {
    164         setInlineEventListenerForTypeAndAttribute(eventNames().blurEvent, attr);
     165        setInlineEventListener(eventNames().blurEvent, createInlineEventListener(this, attr));
    165166    } else if (attr->name() == onkeydownAttr) {
    166         setInlineEventListenerForTypeAndAttribute(eventNames().keydownEvent, attr);
     167        setInlineEventListener(eventNames().keydownEvent, createInlineEventListener(this, attr));
    167168    } else if (attr->name() == onkeypressAttr) {
    168         setInlineEventListenerForTypeAndAttribute(eventNames().keypressEvent, attr);
     169        setInlineEventListener(eventNames().keypressEvent, createInlineEventListener(this, attr));
    169170    } else if (attr->name() == onkeyupAttr) {
    170         setInlineEventListenerForTypeAndAttribute(eventNames().keyupEvent, attr);
     171        setInlineEventListener(eventNames().keyupEvent, createInlineEventListener(this, attr));
    171172    } else if (attr->name() == onscrollAttr) {
    172         setInlineEventListenerForTypeAndAttribute(eventNames().scrollEvent, attr);
     173        setInlineEventListener(eventNames().scrollEvent, createInlineEventListener(this, attr));
    173174    } else if (attr->name() == onbeforecutAttr) {
    174         setInlineEventListenerForTypeAndAttribute(eventNames().beforecutEvent, attr);
     175        setInlineEventListener(eventNames().beforecutEvent, createInlineEventListener(this, attr));
    175176    } else if (attr->name() == oncutAttr) {
    176         setInlineEventListenerForTypeAndAttribute(eventNames().cutEvent, attr);
     177        setInlineEventListener(eventNames().cutEvent, createInlineEventListener(this, attr));
    177178    } else if (attr->name() == onbeforecopyAttr) {
    178         setInlineEventListenerForTypeAndAttribute(eventNames().beforecopyEvent, attr);
     179        setInlineEventListener(eventNames().beforecopyEvent, createInlineEventListener(this, attr));
    179180    } else if (attr->name() == oncopyAttr) {
    180         setInlineEventListenerForTypeAndAttribute(eventNames().copyEvent, attr);
     181        setInlineEventListener(eventNames().copyEvent, createInlineEventListener(this, attr));
    181182    } else if (attr->name() == onbeforepasteAttr) {
    182         setInlineEventListenerForTypeAndAttribute(eventNames().beforepasteEvent, attr);
     183        setInlineEventListener(eventNames().beforepasteEvent, createInlineEventListener(this, attr));
    183184    } else if (attr->name() == onpasteAttr) {
    184         setInlineEventListenerForTypeAndAttribute(eventNames().pasteEvent, attr);
     185        setInlineEventListener(eventNames().pasteEvent, createInlineEventListener(this, attr));
    185186    } else if (attr->name() == ondragenterAttr) {
    186         setInlineEventListenerForTypeAndAttribute(eventNames().dragenterEvent, attr);
     187        setInlineEventListener(eventNames().dragenterEvent, createInlineEventListener(this, attr));
    187188    } else if (attr->name() == ondragoverAttr) {
    188         setInlineEventListenerForTypeAndAttribute(eventNames().dragoverEvent, attr);
     189        setInlineEventListener(eventNames().dragoverEvent, createInlineEventListener(this, attr));
    189190    } else if (attr->name() == ondragleaveAttr) {
    190         setInlineEventListenerForTypeAndAttribute(eventNames().dragleaveEvent, attr);
     191        setInlineEventListener(eventNames().dragleaveEvent, createInlineEventListener(this, attr));
    191192    } else if (attr->name() == ondropAttr) {
    192         setInlineEventListenerForTypeAndAttribute(eventNames().dropEvent, attr);
     193        setInlineEventListener(eventNames().dropEvent, createInlineEventListener(this, attr));
    193194    } else if (attr->name() == ondragstartAttr) {
    194         setInlineEventListenerForTypeAndAttribute(eventNames().dragstartEvent, attr);
     195        setInlineEventListener(eventNames().dragstartEvent, createInlineEventListener(this, attr));
    195196    } else if (attr->name() == ondragAttr) {
    196         setInlineEventListenerForTypeAndAttribute(eventNames().dragEvent, attr);
     197        setInlineEventListener(eventNames().dragEvent, createInlineEventListener(this, attr));
    197198    } else if (attr->name() == ondragendAttr) {
    198         setInlineEventListenerForTypeAndAttribute(eventNames().dragendEvent, attr);
     199        setInlineEventListener(eventNames().dragendEvent, createInlineEventListener(this, attr));
    199200    } else if (attr->name() == onselectstartAttr) {
    200         setInlineEventListenerForTypeAndAttribute(eventNames().selectstartEvent, attr);
     201        setInlineEventListener(eventNames().selectstartEvent, createInlineEventListener(this, attr));
    201202    } else if (attr->name() == onsubmitAttr) {
    202         setInlineEventListenerForTypeAndAttribute(eventNames().submitEvent, attr);
     203        setInlineEventListener(eventNames().submitEvent, createInlineEventListener(this, attr));
    203204    } else if (attr->name() == onerrorAttr) {
    204         setInlineEventListenerForTypeAndAttribute(eventNames().errorEvent, attr);
     205        setInlineEventListener(eventNames().errorEvent, createInlineEventListener(this, attr));
    205206    } else if (attr->name() == onwebkitanimationstartAttr) {
    206         setInlineEventListenerForTypeAndAttribute(eventNames().webkitAnimationStartEvent, attr);
     207        setInlineEventListener(eventNames().webkitAnimationStartEvent, createInlineEventListener(this, attr));
    207208    } else if (attr->name() == onwebkitanimationiterationAttr) {
    208         setInlineEventListenerForTypeAndAttribute(eventNames().webkitAnimationIterationEvent, attr);
     209        setInlineEventListener(eventNames().webkitAnimationIterationEvent, createInlineEventListener(this, attr));
    209210    } else if (attr->name() == onwebkitanimationendAttr) {
    210         setInlineEventListenerForTypeAndAttribute(eventNames().webkitAnimationEndEvent, attr);
     211        setInlineEventListener(eventNames().webkitAnimationEndEvent, createInlineEventListener(this, attr));
    211212    } else if (attr->name() == onwebkittransitionendAttr) {
    212         setInlineEventListenerForTypeAndAttribute(eventNames().webkitTransitionEndEvent, attr);
     213        setInlineEventListener(eventNames().webkitTransitionEndEvent, createInlineEventListener(this, attr));
    213214    }
    214215}

  • trunk/WebCore/html/HTMLFormControlElement.cpp

    r42377 r42633  
    165165void HTMLFormControlElement::onChange()
    166166{
    167     dispatchEventForType(eventNames().changeEvent, true, false);
     167    dispatchEvent(eventNames().changeEvent, true, false);
    168168}
    169169

  • trunk/WebCore/html/HTMLFormElement.cpp

    r42586 r42633  
    4343#include "HTMLInputElement.h"
    4444#include "HTMLNames.h"
     45#include "JSLazyEventListener.h"
    4546#include "MIMETypeRegistry.h"
    4647#include "Page.h"
    … …  
    298299    m_doingsubmit = false;
    299300
    300     if (dispatchEventForType(eventNames().submitEvent, true, true) && !m_doingsubmit)
     301    if (dispatchEvent(eventNames().submitEvent, true, true) && !m_doingsubmit)
    301302        m_doingsubmit = true;
    302303
    … …  
    418419    // ### DOM2 labels this event as not cancelable, however
    419420    // common browsers( sick! ) allow it be cancelled.
    420     if ( !dispatchEventForType(eventNames().resetEvent,true, true) ) {
     421    if ( !dispatchEvent(eventNames().resetEvent,true, true) ) {
    421422        m_inreset = false;
    422423        return;
    … …  
    452453            document()->unregisterForDocumentActivationCallbacks(this);
    453454    } else if (attr->name() == onsubmitAttr)
    454         setInlineEventListenerForTypeAndAttribute(eventNames().submitEvent, attr);
     455        setInlineEventListener(eventNames().submitEvent, createInlineEventListener(this, attr));
    455456    else if (attr->name() == onresetAttr)
    456         setInlineEventListenerForTypeAndAttribute(eventNames().resetEvent, attr);
     457        setInlineEventListener(eventNames().resetEvent, createInlineEventListener(this, attr));
    457458    else if (attr->name() == nameAttr) {
    458459        const AtomicString& newName = attr->value();

  • trunk/WebCore/html/HTMLFrameElementBase.cpp

    r42192 r42633  
    3535#include "HTMLFrameSetElement.h"
    3636#include "HTMLNames.h"
     37#include "JSLazyEventListener.h"
    3738#include "KURL.h"
    3839#include "Page.h"
    … …  
    141142            contentFrame()->setInViewSourceMode(viewSourceMode());
    142143    } else if (attr->name() == onloadAttr) {
    143         setInlineEventListenerForTypeAndAttribute(eventNames().loadEvent, attr);
     144        setInlineEventListener(eventNames().loadEvent, createInlineEventListener(this, attr));
    144145    } else if (attr->name() == onbeforeunloadAttr) {
    145146        // FIXME: should <frame> elements have beforeunload handlers?
    146         setInlineEventListenerForTypeAndAttribute(eventNames().beforeunloadEvent, attr);
     147        setInlineEventListener(eventNames().beforeunloadEvent, createInlineEventListener(this, attr));
    147148    } else
    148149        HTMLFrameOwnerElement::parseMappedAttribute(attr);

  • trunk/WebCore/html/HTMLFrameSetElement.cpp

    r42377 r42633  
    3030#include "EventNames.h"
    3131#include "HTMLNames.h"
     32#include "JSLazyEventListener.h"
    3233#include "Length.h"
    3334#include "Length.h"
    … …  
    126127        }
    127128    } else if (attr->name() == onloadAttr) {
    128         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().loadEvent, attr);
     129        setWindowInlineEventListener(eventNames().loadEvent, createInlineEventListener(document()->frame(), attr));
    129130    } else if (attr->name() == onbeforeunloadAttr) {
    130         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().beforeunloadEvent, attr);
     131        setWindowInlineEventListener(eventNames().beforeunloadEvent, createInlineEventListener(document()->frame(), attr));
    131132    } else if (attr->name() == onunloadAttr) {
    132         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().unloadEvent, attr);
     133        setWindowInlineEventListener(eventNames().unloadEvent, createInlineEventListener(document()->frame(), attr));
    133134    } else
    134135        HTMLElement::parseMappedAttribute(attr);

  • trunk/WebCore/html/HTMLImageElement.cpp

    r40638 r42633  
    3131#include "HTMLFormElement.h"
    3232#include "HTMLNames.h"
     33#include "JSLazyEventListener.h"
    3334#include "RenderImage.h"
    3435
    … …  
    114115        ismap = true;
    115116    else if (attrName == onabortAttr)
    116         setInlineEventListenerForTypeAndAttribute(eventNames().abortEvent, attr);
     117        setInlineEventListener(eventNames().abortEvent, createInlineEventListener(this, attr));
    117118    else if (attrName == onloadAttr)
    118         setInlineEventListenerForTypeAndAttribute(eventNames().loadEvent, attr);
     119        setInlineEventListener(eventNames().loadEvent, createInlineEventListener(this, attr));
    119120    else if (attrName == compositeAttr) {
    120121        if (!parseCompositeOperator(attr->value(), m_compositeOperator))

  • trunk/WebCore/html/HTMLImageLoader.cpp

    r42189 r42633  
    4646    if (!errorOccurred && image()->httpStatusCodeErrorOccurred())
    4747        errorOccurred = element()->hasTagName(HTMLNames::objectTag); // An <object> considers a 404 to be an error and should fire onerror.
    48     element()->dispatchEventForType(errorOccurred ? eventNames().errorEvent : eventNames().loadEvent, false, false);
     48    element()->dispatchEvent(errorOccurred ? eventNames().errorEvent : eventNames().loadEvent, false, false);
    4949}
    5050

  • trunk/WebCore/html/HTMLInputElement.cpp

    r42377 r42633  
    2727#include "HTMLInputElement.h"
    2828
     29#include "CSSPropertyNames.h"
    2930#include "ChromeClient.h"
    30 #include "CSSPropertyNames.h"
    3131#include "Document.h"
    3232#include "Editor.h"
    … …  
    4242#include "HTMLImageLoader.h"
    4343#include "HTMLNames.h"
     44#include "JSLazyEventListener.h"
    4445#include "KeyboardEvent.h"
    4546#include "LocalizedStrings.h"
    … …  
    588589            addCSSLength(attr, CSSPropertyHeight, attr->value());
    589590    } else if (attr->name() == onfocusAttr) {
    590         setInlineEventListenerForTypeAndAttribute(eventNames().focusEvent, attr);
     591        setInlineEventListener(eventNames().focusEvent, createInlineEventListener(this, attr));
    591592    } else if (attr->name() == onblurAttr) {
    592         setInlineEventListenerForTypeAndAttribute(eventNames().blurEvent, attr);
     593        setInlineEventListener(eventNames().blurEvent, createInlineEventListener(this, attr));
    593594    } else if (attr->name() == onselectAttr) {
    594         setInlineEventListenerForTypeAndAttribute(eventNames().selectEvent, attr);
     595        setInlineEventListener(eventNames().selectEvent, createInlineEventListener(this, attr));
    595596    } else if (attr->name() == onchangeAttr) {
    596         setInlineEventListenerForTypeAndAttribute(eventNames().changeEvent, attr);
     597        setInlineEventListener(eventNames().changeEvent, createInlineEventListener(this, attr));
    597598    } else if (attr->name() == oninputAttr) {
    598         setInlineEventListenerForTypeAndAttribute(eventNames().inputEvent, attr);
     599        setInlineEventListener(eventNames().inputEvent, createInlineEventListener(this, attr));
    599600    }
    600601    // Search field and slider attributes all just cause updateFromElement to be called through style
    601602    // recalcing.
    602603    else if (attr->name() == onsearchAttr) {
    603         setInlineEventListenerForTypeAndAttribute(eventNames().searchEvent, attr);
     604        setInlineEventListener(eventNames().searchEvent, createInlineEventListener(this, attr));
    604605    } else if (attr->name() == resultsAttr) {
    605606        int oldResults = m_maxResults;
    … …  
    15171518    if (renderer())
    15181519        static_cast<RenderTextControlSingleLine*>(renderer())->stopSearchEventTimer();
    1519     dispatchEventForType(eventNames().searchEvent, true, false);
     1520    dispatchEvent(eventNames().searchEvent, true, false);
    15201521}
    15211522

  • trunk/WebCore/html/HTMLMediaElement.cpp

    r42619 r42633  
    411411            m_player->seek(0);
    412412        }
    413         dispatchEventForType(eventNames().emptiedEvent, false, true);
     413        dispatchEvent(eventNames().emptiedEvent, false, true);
    414414    }
    415415   

  • trunk/WebCore/html/HTMLObjectElement.cpp

    r42377 r42633  
    3333#include "HTMLImageLoader.h"
    3434#include "HTMLNames.h"
     35#include "JSLazyEventListener.h"
    3536#include "MIMETypeRegistry.h"
    3637#include "RenderImage.h"
    … …  
    4041#include "Settings.h"
    4142#include "Text.h"
    42 
    4343
    4444namespace WebCore {
    … …  
    9696          m_needWidgetUpdate = true;
    9797    } else if (attr->name() == onloadAttr) {
    98         setInlineEventListenerForTypeAndAttribute(eventNames().loadEvent, attr);
     98        setInlineEventListener(eventNames().loadEvent, createInlineEventListener(this, attr));
    9999    } else if (attr->name() == nameAttr) {
    100100        const AtomicString& newName = attr->value();

  • trunk/WebCore/html/HTMLScriptElement.cpp

    r39441 r42633  
    2727#include "EventNames.h"
    2828#include "HTMLNames.h"
     29#include "JSLazyEventListener.h"
    2930#include "Text.h"
    3031
    … …  
    6869        handleSourceAttribute(m_data, attr->value());
    6970    else if (attrName == onloadAttr)
    70         setInlineEventListenerForTypeAndAttribute(eventNames().loadEvent, attr);
     71        setInlineEventListener(eventNames().loadEvent, createInlineEventListener(this, attr));
    7172    else
    7273        HTMLElement::parseMappedAttribute(attr);
    … …  
    216217    m_data.setHaveFiredLoadEvent(true);
    217218
    218     dispatchEventForType(eventNames().loadEvent, false, false);
     219    dispatchEvent(eventNames().loadEvent, false, false);
    219220}
    220221
    221222void HTMLScriptElement::dispatchErrorEvent()
    222223{
    223     dispatchEventForType(eventNames().errorEvent, true, false);
    224 }
    225 
    226 }
     224    dispatchEvent(eventNames().errorEvent, true, false);
     225}
     226
     227}

  • trunk/WebCore/html/HTMLSelectElement.cpp

    r42377 r42633  
    4343#include "HTMLOptionElement.h"
    4444#include "HTMLOptionsCollection.h"
     45#include "JSLazyEventListener.h"
    4546#include "KeyboardEvent.h"
    4647#include "MouseEvent.h"
    … …  
    327328        // See http://bugs.webkit.org/show_bug.cgi?id=12072
    328329    } else if (attr->name() == onfocusAttr) {
    329         setInlineEventListenerForTypeAndAttribute(eventNames().focusEvent, attr);
     330        setInlineEventListener(eventNames().focusEvent, createInlineEventListener(this, attr));
    330331    } else if (attr->name() == onblurAttr) {
    331         setInlineEventListenerForTypeAndAttribute(eventNames().blurEvent, attr);
     332        setInlineEventListener(eventNames().blurEvent, createInlineEventListener(this, attr));
    332333    } else if (attr->name() == onchangeAttr) {
    333         setInlineEventListenerForTypeAndAttribute(eventNames().changeEvent, attr);
     334        setInlineEventListener(eventNames().changeEvent, createInlineEventListener(this, attr));
    334335    } else
    335336        HTMLFormControlElementWithState::parseMappedAttribute(attr);

  • trunk/WebCore/html/HTMLTextAreaElement.cpp

    r42377 r42633  
    3535#include "Frame.h"
    3636#include "HTMLNames.h"
     37#include "JSLazyEventListener.h"
    3738#include "Page.h"
    3839#include "RenderStyle.h"
    … …  
    180181        // See http://bugs.webkit.org/show_bug.cgi?id=7075
    181182    } else if (attr->name() == onfocusAttr)
    182         setInlineEventListenerForTypeAndAttribute(eventNames().focusEvent, attr);
     183        setInlineEventListener(eventNames().focusEvent, createInlineEventListener(this, attr));
    183184    else if (attr->name() == onblurAttr)
    184         setInlineEventListenerForTypeAndAttribute(eventNames().blurEvent, attr);
     185        setInlineEventListener(eventNames().blurEvent, createInlineEventListener(this, attr));
    185186    else if (attr->name() == onselectAttr)
    186         setInlineEventListenerForTypeAndAttribute(eventNames().selectEvent, attr);
     187        setInlineEventListener(eventNames().selectEvent, createInlineEventListener(this, attr));
    187188    else if (attr->name() == onchangeAttr)
    188         setInlineEventListenerForTypeAndAttribute(eventNames().changeEvent, attr);
     189        setInlineEventListener(eventNames().changeEvent, createInlineEventListener(this, attr));
    189190    else
    190191        HTMLFormControlElementWithState::parseMappedAttribute(attr);

  • trunk/WebCore/html/HTMLTokenizer.cpp

    r42589 r42633  
    19871987
    19881988        if (errorOccurred)
    1989             n->dispatchEventForType(eventNames().errorEvent, true, false);
     1989            n->dispatchEvent(eventNames().errorEvent, true, false);
    19901990        else {
    19911991            if (static_cast<HTMLScriptElement*>(n.get())->shouldExecuteAsJavaScript())
    19921992                m_state = scriptExecution(sourceCode, m_state);
    1993             n->dispatchEventForType(eventNames().loadEvent, false, false);
     1993            n->dispatchEvent(eventNames().loadEvent, false, false);
    19941994        }
    19951995

  • trunk/WebCore/page/AccessibilityRenderObject.cpp

    r42590 r42633  
    574574    // FIXME: Do the continuation search like anchorElement does
    575575    for (Element* element = static_cast<Element*>(node); element; element = element->parentElement()) {
    576         if (element->inlineEventListenerForType(eventNames().clickEvent) || element->inlineEventListenerForType(eventNames().mousedownEvent) || element->inlineEventListenerForType(eventNames().mouseupEvent))
     576        if (element->getInlineEventListener(eventNames().clickEvent) || element->getInlineEventListener(eventNames().mousedownEvent) || element->getInlineEventListener(eventNames().mouseupEvent))
    577577            return element;
    578578    }

  • trunk/WebCore/page/DOMWindow.cpp

    r42593 r42633  
    10691069}
    10701070
    1071 void DOMWindow::setInlineEventListenerForType(const AtomicString& eventType, PassRefPtr<EventListener> eventListener)
    1072 {
    1073     removeInlineEventListenerForType(eventType);
    1074     if (eventListener)
    1075         addEventListener(eventType, eventListener, false);
    1076 }
    1077 
    1078 void DOMWindow::removeInlineEventListenerForType(const AtomicString& eventType)
     1071void DOMWindow::setInlineEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
     1072{
     1073    clearInlineEventListener(eventType);
     1074    if (listener)
     1075        addEventListener(eventType, listener, false);
     1076}
     1077
     1078void DOMWindow::clearInlineEventListener(const AtomicString& eventType)
    10791079{
    10801080    size_t size = m_eventListeners.size();
    … …  
    10931093}
    10941094
    1095 EventListener* DOMWindow::inlineEventListenerForType(const AtomicString& eventType) const
     1095EventListener* DOMWindow::getInlineEventListener(const AtomicString& eventType) const
    10961096{
    10971097    size_t size = m_eventListeners.size();
    … …  
    11301130EventListener* DOMWindow::onabort() const
    11311131{
    1132     return inlineEventListenerForType(eventNames().abortEvent);
     1132    return getInlineEventListener(eventNames().abortEvent);
    11331133}
    11341134
    11351135void DOMWindow::setOnabort(PassRefPtr<EventListener> eventListener)
    11361136{
    1137     setInlineEventListenerForType(eventNames().abortEvent, eventListener);
     1137    setInlineEventListener(eventNames().abortEvent, eventListener);
    11381138}
    11391139
    11401140EventListener* DOMWindow::onblur() const
    11411141{
    1142     return inlineEventListenerForType(eventNames().blurEvent);
     1142    return getInlineEventListener(eventNames().blurEvent);
    11431143}
    11441144
    11451145void DOMWindow::setOnblur(PassRefPtr<EventListener> eventListener)
    11461146{
    1147     setInlineEventListenerForType(eventNames().blurEvent, eventListener);
     1147    setInlineEventListener(eventNames().blurEvent, eventListener);
    11481148}
    11491149
    11501150EventListener* DOMWindow::onchange() const
    11511151{
    1152     return inlineEventListenerForType(eventNames().changeEvent);
     1152    return getInlineEventListener(eventNames().changeEvent);
    11531153}
    11541154
    11551155void DOMWindow::setOnchange(PassRefPtr<EventListener> eventListener)
    11561156{
    1157     setInlineEventListenerForType(eventNames().changeEvent, eventListener);
     1157    setInlineEventListener(eventNames().changeEvent, eventListener);
    11581158}
    11591159
    11601160EventListener* DOMWindow::onclick() const
    11611161{
    1162     return inlineEventListenerForType(eventNames().clickEvent);
     1162    return getInlineEventListener(eventNames().clickEvent);
    11631163}
    11641164
    11651165void DOMWindow::setOnclick(PassRefPtr<EventListener> eventListener)
    11661166{
    1167     setInlineEventListenerForType(eventNames().clickEvent, eventListener);
     1167    setInlineEventListener(eventNames().clickEvent, eventListener);
    11681168}
    11691169
    11701170EventListener* DOMWindow::ondblclick() const
    11711171{
    1172     return inlineEventListenerForType(eventNames().dblclickEvent);
     1172    return getInlineEventListener(eventNames().dblclickEvent);
    11731173}
    11741174
    11751175void DOMWindow::setOndblclick(PassRefPtr<EventListener> eventListener)
    11761176{
    1177     setInlineEventListenerForType(eventNames().dblclickEvent, eventListener);
     1177    setInlineEventListener(eventNames().dblclickEvent, eventListener);
    11781178}
    11791179
    11801180EventListener* DOMWindow::onerror() const
    11811181{
    1182     return inlineEventListenerForType(eventNames().errorEvent);
     1182    return getInlineEventListener(eventNames().errorEvent);
    11831183}
    11841184
    11851185void DOMWindow::setOnerror(PassRefPtr<EventListener> eventListener)
    11861186{
    1187     setInlineEventListenerForType(eventNames().errorEvent, eventListener);
     1187    setInlineEventListener(eventNames().errorEvent, eventListener);
    11881188}
    11891189
    11901190EventListener* DOMWindow::onfocus() const
    11911191{
    1192     return inlineEventListenerForType(eventNames().focusEvent);
     1192    return getInlineEventListener(eventNames().focusEvent);
    11931193}
    11941194
    11951195void DOMWindow::setOnfocus(PassRefPtr<EventListener> eventListener)
    11961196{
    1197     setInlineEventListenerForType(eventNames().focusEvent, eventListener);
     1197    setInlineEventListener(eventNames().focusEvent, eventListener);
    11981198}
    11991199
    12001200EventListener* DOMWindow::onkeydown() const
    12011201{
    1202     return inlineEventListenerForType(eventNames().keydownEvent);
     1202    return getInlineEventListener(eventNames().keydownEvent);
    12031203}
    12041204
    12051205void DOMWindow::setOnkeydown(PassRefPtr<EventListener> eventListener)
    12061206{
    1207     setInlineEventListenerForType(eventNames().keydownEvent, eventListener);
     1207    setInlineEventListener(eventNames().keydownEvent, eventListener);
    12081208}
    12091209
    12101210EventListener* DOMWindow::onkeypress() const
    12111211{
    1212     return inlineEventListenerForType(eventNames().keypressEvent);
     1212    return getInlineEventListener(eventNames().keypressEvent);
    12131213}
    12141214
    12151215void DOMWindow::setOnkeypress(PassRefPtr<EventListener> eventListener)
    12161216{
    1217     setInlineEventListenerForType(eventNames().keypressEvent, eventListener);
     1217    setInlineEventListener(eventNames().keypressEvent, eventListener);
    12181218}
    12191219
    12201220EventListener* DOMWindow::onkeyup() const
    12211221{
    1222     return inlineEventListenerForType(eventNames().keyupEvent);
     1222    return getInlineEventListener(eventNames().keyupEvent);
    12231223}
    12241224
    12251225void DOMWindow::setOnkeyup(PassRefPtr<EventListener> eventListener)
    12261226{
    1227     setInlineEventListenerForType(eventNames().keyupEvent, eventListener);
     1227    setInlineEventListener(eventNames().keyupEvent, eventListener);
    12281228}
    12291229
    12301230EventListener* DOMWindow::onload() const
    12311231{
    1232     return inlineEventListenerForType(eventNames().loadEvent);
     1232    return getInlineEventListener(eventNames().loadEvent);
    12331233}
    12341234
    12351235void DOMWindow::setOnload(PassRefPtr<EventListener> eventListener)
    12361236{
    1237     setInlineEventListenerForType(eventNames().loadEvent, eventListener);
     1237    setInlineEventListener(eventNames().loadEvent, eventListener);
    12381238}
    12391239
    12401240EventListener* DOMWindow::onmousedown() const
    12411241{
    1242     return inlineEventListenerForType(eventNames().mousedownEvent);
     1242    return getInlineEventListener(eventNames().mousedownEvent);
    12431243}
    12441244
    12451245void DOMWindow::setOnmousedown(PassRefPtr<EventListener> eventListener)
    12461246{
    1247     setInlineEventListenerForType(eventNames().mousedownEvent, eventListener);
     1247    setInlineEventListener(eventNames().mousedownEvent, eventListener);
    12481248}
    12491249
    12501250EventListener* DOMWindow::onmousemove() const
    12511251{
    1252     return inlineEventListenerForType(eventNames().mousemoveEvent);
     1252    return getInlineEventListener(eventNames().mousemoveEvent);
    12531253}
    12541254
    12551255void DOMWindow::setOnmousemove(PassRefPtr<EventListener> eventListener)
    12561256{
    1257     setInlineEventListenerForType(eventNames().mousemoveEvent, eventListener);
     1257    setInlineEventListener(eventNames().mousemoveEvent, eventListener);
    12581258}
    12591259
    12601260EventListener* DOMWindow::onmouseout() const
    12611261{
    1262     return inlineEventListenerForType(eventNames().mouseoutEvent);
     1262    return getInlineEventListener(eventNames().mouseoutEvent);
    12631263}
    12641264
    12651265void DOMWindow::setOnmouseout(PassRefPtr<EventListener> eventListener)
    12661266{
    1267     setInlineEventListenerForType(eventNames().mouseoutEvent, eventListener);
     1267    setInlineEventListener(eventNames().mouseoutEvent, eventListener);
    12681268}
    12691269
    12701270EventListener* DOMWindow::onmouseover() const
    12711271{
    1272     return inlineEventListenerForType(eventNames().mouseoverEvent);
     1272    return getInlineEventListener(eventNames().mouseoverEvent);
    12731273}
    12741274
    12751275void DOMWindow::setOnmouseover(PassRefPtr<EventListener> eventListener)
    12761276{
    1277     setInlineEventListenerForType(eventNames().mouseoverEvent, eventListener);
     1277    setInlineEventListener(eventNames().mouseoverEvent, eventListener);
    12781278}
    12791279
    12801280EventListener* DOMWindow::onmouseup() const
    12811281{
    1282     return inlineEventListenerForType(eventNames().mouseupEvent);
     1282    return getInlineEventListener(eventNames().mouseupEvent);
    12831283}
    12841284
    12851285void DOMWindow::setOnmouseup(PassRefPtr<EventListener> eventListener)
    12861286{
    1287     setInlineEventListenerForType(eventNames().mouseupEvent, eventListener);
     1287    setInlineEventListener(eventNames().mouseupEvent, eventListener);
    12881288}
    12891289
    12901290EventListener* DOMWindow::onmousewheel() const
    12911291{
    1292     return inlineEventListenerForType(eventNames().mousewheelEvent);
     1292    return getInlineEventListener(eventNames().mousewheelEvent);
    12931293}
    12941294
    12951295void DOMWindow::setOnmousewheel(PassRefPtr<EventListener> eventListener)
    12961296{
    1297     setInlineEventListenerForType(eventNames().mousewheelEvent, eventListener);
     1297    setInlineEventListener(eventNames().mousewheelEvent, eventListener);
    12981298}
    12991299
    13001300EventListener* DOMWindow::onreset() const
    13011301{
    1302     return inlineEventListenerForType(eventNames().resetEvent);
     1302    return getInlineEventListener(eventNames().resetEvent);
    13031303}
    13041304
    13051305void DOMWindow::setOnreset(PassRefPtr<EventListener> eventListener)
    13061306{
    1307     setInlineEventListenerForType(eventNames().resetEvent, eventListener);
     1307    setInlineEventListener(eventNames().resetEvent, eventListener);
    13081308}
    13091309
    13101310EventListener* DOMWindow::onresize() const
    13111311{
    1312     return inlineEventListenerForType(eventNames().resizeEvent);
     1312    return getInlineEventListener(eventNames().resizeEvent);
    13131313}
    13141314
    13151315void DOMWindow::setOnresize(PassRefPtr<EventListener> eventListener)
    13161316{
    1317     setInlineEventListenerForType(eventNames().resizeEvent, eventListener);
     1317    setInlineEventListener(eventNames().resizeEvent, eventListener);
    13181318}
    13191319
    13201320EventListener* DOMWindow::onscroll() const
    13211321{
    1322     return inlineEventListenerForType(eventNames().scrollEvent);
     1322    return getInlineEventListener(eventNames().scrollEvent);
    13231323}
    13241324
    13251325void DOMWindow::setOnscroll(PassRefPtr<EventListener> eventListener)
    13261326{
    1327     setInlineEventListenerForType(eventNames().scrollEvent, eventListener);
     1327    setInlineEventListener(eventNames().scrollEvent, eventListener);
    13281328}
    13291329
    13301330EventListener* DOMWindow::onsearch() const
    13311331{
    1332     return inlineEventListenerForType(eventNames().searchEvent);
     1332    return getInlineEventListener(eventNames().searchEvent);
    13331333}
    13341334
    13351335void DOMWindow::setOnsearch(PassRefPtr<EventListener> eventListener)
    13361336{
    1337     setInlineEventListenerForType(eventNames().searchEvent, eventListener);
     1337    setInlineEventListener(eventNames().searchEvent, eventListener);
    13381338}
    13391339
    13401340EventListener* DOMWindow::onselect() const
    13411341{
    1342     return inlineEventListenerForType(eventNames().selectEvent);
     1342    return getInlineEventListener(eventNames().selectEvent);
    13431343}
    13441344
    13451345void DOMWindow::setOnselect(PassRefPtr<EventListener> eventListener)
    13461346{
    1347     setInlineEventListenerForType(eventNames().selectEvent, eventListener);
     1347    setInlineEventListener(eventNames().selectEvent, eventListener);
    13481348}
    13491349
    13501350EventListener* DOMWindow::onsubmit() const
    13511351{
    1352     return inlineEventListenerForType(eventNames().submitEvent);
     1352    return getInlineEventListener(eventNames().submitEvent);
    13531353}
    13541354
    13551355void DOMWindow::setOnsubmit(PassRefPtr<EventListener> eventListener)
    13561356{
    1357     setInlineEventListenerForType(eventNames().submitEvent, eventListener);
     1357    setInlineEventListener(eventNames().submitEvent, eventListener);
    13581358}
    13591359
    13601360EventListener* DOMWindow::onunload() const
    13611361{
    1362     return inlineEventListenerForType(eventNames().unloadEvent);
     1362    return getInlineEventListener(eventNames().unloadEvent);
    13631363}
    13641364
    13651365void DOMWindow::setOnunload(PassRefPtr<EventListener> eventListener)
    13661366{
    1367     setInlineEventListenerForType(eventNames().unloadEvent, eventListener);
     1367    setInlineEventListener(eventNames().unloadEvent, eventListener);
    13681368}
    13691369
    13701370EventListener* DOMWindow::onbeforeunload() const
    13711371{
    1372     return inlineEventListenerForType(eventNames().beforeunloadEvent);
     1372    return getInlineEventListener(eventNames().beforeunloadEvent);
    13731373}
    13741374
    13751375void DOMWindow::setOnbeforeunload(PassRefPtr<EventListener> eventListener)
    13761376{
    1377     setInlineEventListenerForType(eventNames().beforeunloadEvent, eventListener);
     1377    setInlineEventListener(eventNames().beforeunloadEvent, eventListener);
    13781378}
    13791379
    13801380EventListener* DOMWindow::onwebkitanimationstart() const
    13811381{
    1382     return inlineEventListenerForType(eventNames().webkitAnimationStartEvent);
     1382    return getInlineEventListener(eventNames().webkitAnimationStartEvent);
    13831383}
    13841384
    13851385void DOMWindow::setOnwebkitanimationstart(PassRefPtr<EventListener> eventListener)
    13861386{
    1387     setInlineEventListenerForType(eventNames().webkitAnimationStartEvent, eventListener);
     1387    setInlineEventListener(eventNames().webkitAnimationStartEvent, eventListener);
    13881388}
    13891389
    13901390EventListener* DOMWindow::onwebkitanimationiteration() const
    13911391{
    1392     return inlineEventListenerForType(eventNames().webkitAnimationIterationEvent);
     1392    return getInlineEventListener(eventNames().webkitAnimationIterationEvent);
    13931393}
    13941394
    13951395void DOMWindow::setOnwebkitanimationiteration(PassRefPtr<EventListener> eventListener)
    13961396{
    1397     setInlineEventListenerForType(eventNames().webkitAnimationIterationEvent, eventListener);
     1397    setInlineEventListener(eventNames().webkitAnimationIterationEvent, eventListener);
    13981398}
    13991399
    14001400EventListener* DOMWindow::onwebkitanimationend() const
    14011401{
    1402     return inlineEventListenerForType(eventNames().webkitAnimationEndEvent);
     1402    return getInlineEventListener(eventNames().webkitAnimationEndEvent);
    14031403}
    14041404
    14051405void DOMWindow::setOnwebkitanimationend(PassRefPtr<EventListener> eventListener)
    14061406{
    1407     setInlineEventListenerForType(eventNames().webkitAnimationEndEvent, eventListener);
     1407    setInlineEventListener(eventNames().webkitAnimationEndEvent, eventListener);
    14081408}
    14091409
    14101410EventListener* DOMWindow::onwebkittransitionend() const
    14111411{
    1412     return inlineEventListenerForType(eventNames().webkitTransitionEndEvent);
     1412    return getInlineEventListener(eventNames().webkitTransitionEndEvent);
    14131413}
    14141414
    14151415void DOMWindow::setOnwebkittransitionend(PassRefPtr<EventListener> eventListener)
    14161416{
    1417     setInlineEventListenerForType(eventNames().webkitTransitionEndEvent, eventListener);
     1417    setInlineEventListener(eventNames().webkitTransitionEndEvent, eventListener);
    14181418}
    14191419

  • trunk/WebCore/page/DOMWindow.h

    r42545 r42633  
    205205        void handleEvent(Event*, bool useCapture);
    206206
     207        // Used for standard DOM addEventListener / removeEventListener APIs.
    207208        void addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
    208209        void removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
     210
     211        // Used for legacy "onEvent" property APIs.
     212        void setInlineEventListener(const AtomicString& eventType, PassRefPtr<EventListener>);
     213        void clearInlineEventListener(const AtomicString& eventType);
     214        EventListener* getInlineEventListener(const AtomicString& eventType) const;
     215
     216        const RegisteredEventListenerVector& eventListeners() const { return m_eventListeners; }
    209217        bool hasEventListener(const AtomicString& eventType);
    210218        void removeAllEventListeners();
    211         const RegisteredEventListenerVector& eventListeners() const { return m_eventListeners; }
    212 
    213         void setInlineEventListenerForType(const AtomicString& eventType, PassRefPtr<EventListener>);
    214219       
    215220        EventListener* onabort() const;
    … …  
    294299#endif
    295300
    296         void removeInlineEventListenerForType(const AtomicString& eventType);
    297         EventListener* inlineEventListenerForType(const AtomicString& eventType) const;
    298 
    299301    private:
    300302        DOMWindow(Frame*);

  • trunk/WebCore/page/EventHandler.cpp

    r42460 r42633  
    17771777    for (RenderObject* curr = node->renderer(); curr; curr = curr->parent()) {
    17781778        if (Node* node = curr->node())
    1779             return node->dispatchEventForType(eventNames().selectstartEvent, true, true);
     1779            return node->dispatchEvent(eventNames().selectstartEvent, true, true);
    17801780    }
    17811781
    … …  
    17901790    for (RenderObject* curr = node->renderer(); curr; curr = curr->parent()) {
    17911791        if (Node* node = curr->node())
    1792             return node->dispatchEventForType(eventNames().selectstartEvent, true, true);
     1792            return node->dispatchEvent(eventNames().selectstartEvent, true, true);
    17931793    }
    17941794
    … …  
    23762376        return;
    23772377    v->setWasScrolledByUser(true);
    2378     m_frame->document()->dispatchEventForType(eventNames().scrollEvent, true, false);
     2378    m_frame->document()->dispatchEvent(eventNames().scrollEvent, true, false);
    23792379}
    23802380

  • trunk/WebCore/page/Page.cpp

    r42084 r42633  
    100100            eventTarget = document;
    101101       
    102         eventTarget->dispatchEventForType(eventName, false, false);
     102        eventTarget->dispatchEvent(eventName, false, false);
    103103    }
    104104}

  • trunk/WebCore/rendering/RenderListBox.cpp

    r41233 r42633  
    528528        repaint();
    529529        // Fire the scroll DOM event.
    530         node()->dispatchEventForType(eventNames().scrollEvent, false, false);
     530        node()->dispatchEvent(eventNames().scrollEvent, false, false);
    531531    }
    532532}

  • trunk/WebCore/rendering/RenderTextControl.cpp

    r41792 r42633  
    517517    if (Frame* frame = document()->frame()) {
    518518        if (frame->selection()->isRange() && userTriggered)
    519             node()->dispatchEventForType(eventNames().selectEvent, true, false);
     519            node()->dispatchEvent(eventNames().selectEvent, true, false);
    520520    }
    521521}

  • trunk/WebCore/svg/SVGElement.cpp

    r39818 r42633  
    3434#include "FrameView.h"
    3535#include "HTMLNames.h"
     36#include "JSLazyEventListener.h"
    3637#include "PlatformString.h"
    3738#include "RegisteredEventListener.h"
    … …  
    151152    // standard events
    152153    if (attr->name() == onloadAttr)
    153         setInlineEventListenerForTypeAndAttribute(eventNames().loadEvent, attr);
     154        setInlineEventListener(eventNames().loadEvent, createInlineEventListener(this, attr));
    154155    else if (attr->name() == onclickAttr)
    155         setInlineEventListenerForTypeAndAttribute(eventNames().clickEvent, attr);
     156        setInlineEventListener(eventNames().clickEvent, createInlineEventListener(this, attr));
    156157    else if (attr->name() == onmousedownAttr)
    157         setInlineEventListenerForTypeAndAttribute(eventNames().mousedownEvent, attr);
     158        setInlineEventListener(eventNames().mousedownEvent, createInlineEventListener(this, attr));
    158159    else if (attr->name() == onmousemoveAttr)
    159         setInlineEventListenerForTypeAndAttribute(eventNames().mousemoveEvent, attr);
     160        setInlineEventListener(eventNames().mousemoveEvent, createInlineEventListener(this, attr));
    160161    else if (attr->name() == onmouseoutAttr)
    161         setInlineEventListenerForTypeAndAttribute(eventNames().mouseoutEvent, attr);
     162        setInlineEventListener(eventNames().mouseoutEvent, createInlineEventListener(this, attr));
    162163    else if (attr->name() == onmouseoverAttr)
    163         setInlineEventListenerForTypeAndAttribute(eventNames().mouseoverEvent, attr);
     164        setInlineEventListener(eventNames().mouseoverEvent, createInlineEventListener(this, attr));
    164165    else if (attr->name() == onmouseupAttr)
    165         setInlineEventListenerForTypeAndAttribute(eventNames().mouseupEvent, attr);
     166        setInlineEventListener(eventNames().mouseupEvent, createInlineEventListener(this, attr));
    166167    else if (attr->name() == SVGNames::onfocusinAttr)
    167         setInlineEventListenerForTypeAndAttribute(eventNames().DOMFocusInEvent, attr);
     168        setInlineEventListener(eventNames().DOMFocusInEvent, createInlineEventListener(this, attr));
    168169    else if (attr->name() == SVGNames::onfocusoutAttr)
    169         setInlineEventListenerForTypeAndAttribute(eventNames().DOMFocusOutEvent, attr);
     170        setInlineEventListener(eventNames().DOMFocusOutEvent, createInlineEventListener(this, attr));
    170171    else if (attr->name() == SVGNames::onactivateAttr)
    171         setInlineEventListenerForTypeAndAttribute(eventNames().DOMActivateEvent, attr);
     172        setInlineEventListener(eventNames().DOMActivateEvent, createInlineEventListener(this, attr));
    172173    else
    173174        StyledElement::parseMappedAttribute(attr);

  • trunk/WebCore/svg/SVGElementInstance.cpp

    r42377 r42633  
    175175EventListener* SVGElementInstance::onabort() const
    176176{
    177     return correspondingElement()->inlineEventListenerForType(eventNames().abortEvent);
     177    return correspondingElement()->getInlineEventListener(eventNames().abortEvent);
    178178}
    179179
    180180void SVGElementInstance::setOnabort(PassRefPtr<EventListener> eventListener)
    181181{
    182     correspondingElement()->setInlineEventListenerForType(eventNames().abortEvent, eventListener);
     182    correspondingElement()->setInlineEventListener(eventNames().abortEvent, eventListener);
    183183}
    184184
    185185EventListener* SVGElementInstance::onblur() const
    186186{
    187     return correspondingElement()->inlineEventListenerForType(eventNames().blurEvent);
     187    return correspondingElement()->getInlineEventListener(eventNames().blurEvent);
    188188}
    189189
    190190void SVGElementInstance::setOnblur(PassRefPtr<EventListener> eventListener)
    191191{
    192     correspondingElement()->setInlineEventListenerForType(eventNames().blurEvent, eventListener);
     192    correspondingElement()->setInlineEventListener(eventNames().blurEvent, eventListener);
    193193}
    194194
    195195EventListener* SVGElementInstance::onchange() const
    196196{
    197     return correspondingElement()->inlineEventListenerForType(eventNames().changeEvent);
     197    return correspondingElement()->getInlineEventListener(eventNames().changeEvent);
    198198}
    199199
    200200void SVGElementInstance::setOnchange(PassRefPtr<EventListener> eventListener)
    201201{
    202     correspondingElement()->setInlineEventListenerForType(eventNames().changeEvent, eventListener);
     202    correspondingElement()->setInlineEventListener(eventNames().changeEvent, eventListener);
    203203}
    204204
    205205EventListener* SVGElementInstance::onclick() const
    206206{
    207     return correspondingElement()->inlineEventListenerForType(eventNames().clickEvent);
     207    return correspondingElement()->getInlineEventListener(eventNames().clickEvent);
    208208}
    209209
    210210void SVGElementInstance::setOnclick(PassRefPtr<EventListener> eventListener)
    211211{
    212     correspondingElement()->setInlineEventListenerForType(eventNames().clickEvent, eventListener);
     212    correspondingElement()->setInlineEventListener(eventNames().clickEvent, eventListener);
    213213}
    214214
    215215EventListener* SVGElementInstance::oncontextmenu() const
    216216{
    217     return correspondingElement()->inlineEventListenerForType(eventNames().contextmenuEvent);
     217    return correspondingElement()->getInlineEventListener(eventNames().contextmenuEvent);
    218218}
    219219
    220220void SVGElementInstance::setOncontextmenu(PassRefPtr<EventListener> eventListener)
    221221{
    222     correspondingElement()->setInlineEventListenerForType(eventNames().contextmenuEvent, eventListener);
     222    correspondingElement()->setInlineEventListener(eventNames().contextmenuEvent, eventListener);
    223223}
    224224
    225225EventListener* SVGElementInstance::ondblclick() const
    226226{
    227     return correspondingElement()->inlineEventListenerForType(eventNames().dblclickEvent);
     227    return correspondingElement()->getInlineEventListener(eventNames().dblclickEvent);
    228228}
    229229
    230230void SVGElementInstance::setOndblclick(PassRefPtr<EventListener> eventListener)
    231231{
    232     correspondingElement()->setInlineEventListenerForType(eventNames().dblclickEvent, eventListener);
     232    correspondingElement()->setInlineEventListener(eventNames().dblclickEvent, eventListener);
    233233}
    234234
    235235EventListener* SVGElementInstance::onerror() const
    236236{
    237     return correspondingElement()->inlineEventListenerForType(eventNames().errorEvent);
     237    return correspondingElement()->getInlineEventListener(eventNames().errorEvent);
    238238}
    239239
    240240void SVGElementInstance::setOnerror(PassRefPtr<EventListener> eventListener)
    241241{
    242     correspondingElement()->setInlineEventListenerForType(eventNames().errorEvent, eventListener);
     242    correspondingElement()->setInlineEventListener(eventNames().errorEvent, eventListener);
    243243}
    244244
    245245EventListener* SVGElementInstance::onfocus() const
    246246{
    247     return correspondingElement()->inlineEventListenerForType(eventNames().focusEvent);
     247    return correspondingElement()->getInlineEventListener(eventNames().focusEvent);
    248248}
    249249
    250250void SVGElementInstance::setOnfocus(PassRefPtr<EventListener> eventListener)
    251251{
    252     correspondingElement()->setInlineEventListenerForType(eventNames().focusEvent, eventListener);
     252    correspondingElement()->setInlineEventListener(eventNames().focusEvent, eventListener);
    253253}
    254254
    255255EventListener* SVGElementInstance::oninput() const
    256256{
    257     return correspondingElement()->inlineEventListenerForType(eventNames().inputEvent);
     257    return correspondingElement()->getInlineEventListener(eventNames().inputEvent);
    258258}
    259259
    260260void SVGElementInstance::setOninput(PassRefPtr<EventListener> eventListener)
    261261{
    262     correspondingElement()->setInlineEventListenerForType(eventNames().inputEvent, eventListener);
     262    correspondingElement()->setInlineEventListener(eventNames().inputEvent, eventListener);
    263263}
    264264
    265265EventListener* SVGElementInstance::onkeydown() const
    266266{
    267     return correspondingElement()->inlineEventListenerForType(eventNames().keydownEvent);
     267    return correspondingElement()->getInlineEventListener(eventNames().keydownEvent);
    268268}
    269269
    270270void SVGElementInstance::setOnkeydown(PassRefPtr<EventListener> eventListener)
    271271{
    272     correspondingElement()->setInlineEventListenerForType(eventNames().keydownEvent, eventListener);
     272    correspondingElement()->setInlineEventListener(eventNames().keydownEvent, eventListener);
    273273}
    274274
    275275EventListener* SVGElementInstance::onkeypress() const
    276276{
    277     return correspondingElement()->inlineEventListenerForType(eventNames().keypressEvent);
     277    return correspondingElement()->getInlineEventListener(eventNames().keypressEvent);
    278278}
    279279
    280280void SVGElementInstance::setOnkeypress(PassRefPtr<EventListener> eventListener)
    281281{
    282     correspondingElement()->setInlineEventListenerForType(eventNames().keypressEvent, eventListener);
     282    correspondingElement()->setInlineEventListener(eventNames().keypressEvent, eventListener);
    283283}
    284284
    285285EventListener* SVGElementInstance::onkeyup() const
    286286{
    287     return correspondingElement()->inlineEventListenerForType(eventNames().keyupEvent);
     287    return correspondingElement()->getInlineEventListener(eventNames().keyupEvent);
    288288}
    289289
    290290void SVGElementInstance::setOnkeyup(PassRefPtr<EventListener> eventListener)
    291291{
    292     correspondingElement()->setInlineEventListenerForType(eventNames().keyupEvent, eventListener);
     292    correspondingElement()->setInlineEventListener(eventNames().keyupEvent, eventListener);
    293293}
    294294
    295295EventListener* SVGElementInstance::onload() const
    296296{
    297     return correspondingElement()->inlineEventListenerForType(eventNames().loadEvent);
     297    return correspondingElement()->getInlineEventListener(eventNames().loadEvent);
    298298}
    299299
    300300void SVGElementInstance::setOnload(PassRefPtr<EventListener> eventListener)
    301301{
    302     correspondingElement()->setInlineEventListenerForType(eventNames().loadEvent, eventListener);
     302    correspondingElement()->setInlineEventListener(eventNames().loadEvent, eventListener);
    303303}
    304304
    305305EventListener* SVGElementInstance::onmousedown() const
    306306{
    307     return correspondingElement()->inlineEventListenerForType(eventNames().mousedownEvent);
     307    return correspondingElement()->getInlineEventListener(eventNames().mousedownEvent);
    308308}
    309309
    310310void SVGElementInstance::setOnmousedown(PassRefPtr<EventListener> eventListener)
    311311{
    312     correspondingElement()->setInlineEventListenerForType(eventNames().mousedownEvent, eventListener);
     312    correspondingElement()->setInlineEventListener(eventNames().mousedownEvent, eventListener);
    313313}
    314314
    315315EventListener* SVGElementInstance::onmousemove() const
    316316{
    317     return correspondingElement()->inlineEventListenerForType(eventNames().mousemoveEvent);
     317    return correspondingElement()->getInlineEventListener(eventNames().mousemoveEvent);
    318318}
    319319
    320320void SVGElementInstance::setOnmousemove(PassRefPtr<EventListener> eventListener)
    321321{
    322     correspondingElement()->setInlineEventListenerForType(eventNames().mousemoveEvent, eventListener);
     322    correspondingElement()->setInlineEventListener(eventNames().mousemoveEvent, eventListener);
    323323}
    324324
    325325EventListener* SVGElementInstance::onmouseout() const
    326326{
    327     return correspondingElement()->inlineEventListenerForType(eventNames().mouseoutEvent);
     327    return correspondingElement()->getInlineEventListener(eventNames().mouseoutEvent);
    328328}
    329329
    330330void SVGElementInstance::setOnmouseout(PassRefPtr<EventListener> eventListener)
    331331{
    332     correspondingElement()->setInlineEventListenerForType(eventNames().mouseoutEvent, eventListener);
     332    correspondingElement()->setInlineEventListener(eventNames().mouseoutEvent, eventListener);
    333333}
    334334
    335335EventListener* SVGElementInstance::onmouseover() const
    336336{
    337     return correspondingElement()->inlineEventListenerForType(eventNames().mouseoverEvent);
     337    return correspondingElement()->getInlineEventListener(eventNames().mouseoverEvent);
    338338}
    339339
    340340void SVGElementInstance::setOnmouseover(PassRefPtr<EventListener> eventListener)
    341341{
    342     correspondingElement()->setInlineEventListenerForType(eventNames().mouseoverEvent, eventListener);
     342    correspondingElement()->setInlineEventListener(eventNames().mouseoverEvent, eventListener);
    343343}
    344344
    345345EventListener* SVGElementInstance::onmouseup() const
    346346{
    347     return correspondingElement()->inlineEventListenerForType(eventNames().mouseupEvent);
     347    return correspondingElement()->getInlineEventListener(eventNames().mouseupEvent);
    348348}
    349349
    350350void SVGElementInstance::setOnmouseup(PassRefPtr<EventListener> eventListener)
    351351{
    352     correspondingElement()->setInlineEventListenerForType(eventNames().mouseupEvent, eventListener);
     352    correspondingElement()->setInlineEventListener(eventNames().mouseupEvent, eventListener);
    353353}
    354354
    355355EventListener* SVGElementInstance::onmousewheel() const
    356356{
    357     return correspondingElement()->inlineEventListenerForType(eventNames().mousewheelEvent);
     357    return correspondingElement()->getInlineEventListener(eventNames().mousewheelEvent);
    358358}
    359359
    360360void SVGElementInstance::setOnmousewheel(PassRefPtr<EventListener> eventListener)
    361361{
    362     correspondingElement()->setInlineEventListenerForType(eventNames().mousewheelEvent, eventListener);
     362    correspondingElement()->setInlineEventListener(eventNames().mousewheelEvent, eventListener);
    363363}
    364364
    365365EventListener* SVGElementInstance::onbeforecut() const
    366366{
    367     return correspondingElement()->inlineEventListenerForType(eventNames().beforecutEvent);
     367    return correspondingElement()->getInlineEventListener(eventNames().beforecutEvent);
    368368}
    369369
    370370void SVGElementInstance::setOnbeforecut(PassRefPtr<EventListener> eventListener)
    371371{
    372     correspondingElement()->setInlineEventListenerForType(eventNames().beforecutEvent, eventListener);
     372    correspondingElement()->setInlineEventListener(eventNames().beforecutEvent, eventListener);
    373373}
    374374
    375375EventListener* SVGElementInstance::oncut() const
    376376{
    377     return correspondingElement()->inlineEventListenerForType(eventNames().cutEvent);
     377    return correspondingElement()->getInlineEventListener(eventNames().cutEvent);
    378378}
    379379
    380380void SVGElementInstance::setOncut(PassRefPtr<EventListener> eventListener)
    381381{
    382     correspondingElement()->setInlineEventListenerForType(eventNames().cutEvent, eventListener);
     382    correspondingElement()->setInlineEventListener(eventNames().cutEvent, eventListener);
    383383}
    384384
    385385EventListener* SVGElementInstance::onbeforecopy() const
    386386{
    387     return correspondingElement()->inlineEventListenerForType(eventNames().beforecopyEvent);
     387    return correspondingElement()->getInlineEventListener(eventNames().beforecopyEvent);
    388388}
    389389
    390390void SVGElementInstance::setOnbeforecopy(PassRefPtr<EventListener> eventListener)
    391391{
    392     correspondingElement()->setInlineEventListenerForType(eventNames().beforecopyEvent, eventListener);
     392    correspondingElement()->setInlineEventListener(eventNames().beforecopyEvent, eventListener);
    393393}
    394394
    395395EventListener* SVGElementInstance::oncopy() const
    396396{
    397     return correspondingElement()->inlineEventListenerForType(eventNames().copyEvent);
     397    return correspondingElement()->getInlineEventListener(eventNames().copyEvent);
    398398}
    399399
    400400void SVGElementInstance::setOncopy(PassRefPtr<EventListener> eventListener)
    401401{
    402     correspondingElement()->setInlineEventListenerForType(eventNames().copyEvent, eventListener);
     402    correspondingElement()->setInlineEventListener(eventNames().copyEvent, eventListener);
    403403}
    404404
    405405EventListener* SVGElementInstance::onbeforepaste() const
    406406{
    407     return correspondingElement()->inlineEventListenerForType(eventNames().beforepasteEvent);
     407    return correspondingElement()->getInlineEventListener(eventNames().beforepasteEvent);
    408408}
    409409
    410410void SVGElementInstance::setOnbeforepaste(PassRefPtr<EventListener> eventListener)
    411411{
    412     correspondingElement()->setInlineEventListenerForType(eventNames().beforepasteEvent, eventListener);
     412    correspondingElement()->setInlineEventListener(eventNames().beforepasteEvent, eventListener);
    413413}
    414414
    415415EventListener* SVGElementInstance::onpaste() const
    416416{
    417     return correspondingElement()->inlineEventListenerForType(eventNames().pasteEvent);
     417    return correspondingElement()->getInlineEventListener(eventNames().pasteEvent);
    418418}
    419419
    420420void SVGElementInstance::setOnpaste(PassRefPtr<EventListener> eventListener)
    421421{
    422     correspondingElement()->setInlineEventListenerForType(eventNames().pasteEvent, eventListener);
     422    correspondingElement()->setInlineEventListener(eventNames().pasteEvent, eventListener);
    423423}
    424424
    425425EventListener* SVGElementInstance::ondragenter() const
    426426{
    427     return correspondingElement()->inlineEventListenerForType(eventNames().dragenterEvent);
     427    return correspondingElement()->getInlineEventListener(eventNames().dragenterEvent);
    428428}
    429429
    430430void SVGElementInstance::setOndragenter(PassRefPtr<EventListener> eventListener)
    431431{
    432     correspondingElement()->setInlineEventListenerForType(eventNames().dragenterEvent, eventListener);
     432    correspondingElement()->setInlineEventListener(eventNames().dragenterEvent, eventListener);
    433433}
    434434
    435435EventListener* SVGElementInstance::ondragover() const
    436436{
    437     return correspondingElement()->inlineEventListenerForType(eventNames().dragoverEvent);
     437    return correspondingElement()->getInlineEventListener(eventNames().dragoverEvent);
    438438}
    439439
    440440void SVGElementInstance::setOndragover(PassRefPtr<EventListener> eventListener)
    441441{
    442     correspondingElement()->setInlineEventListenerForType(eventNames().dragoverEvent, eventListener);
     442    correspondingElement()->setInlineEventListener(eventNames().dragoverEvent, eventListener);
    443443}
    444444
    445445EventListener* SVGElementInstance::ondragleave() const
    446446{
    447     return correspondingElement()->inlineEventListenerForType(eventNames().dragleaveEvent);
     447    return correspondingElement()->getInlineEventListener(eventNames().dragleaveEvent);
    448448}
    449449
    450450void SVGElementInstance::setOndragleave(PassRefPtr<EventListener> eventListener)
    451451{
    452     correspondingElement()->setInlineEventListenerForType(eventNames().dragleaveEvent, eventListener);
     452    correspondingElement()->setInlineEventListener(eventNames().dragleaveEvent, eventListener);
    453453}
    454454
    455455EventListener* SVGElementInstance::ondrop() const
    456456{
    457     return correspondingElement()->inlineEventListenerForType(eventNames().dropEvent);
     457    return correspondingElement()->getInlineEventListener(eventNames().dropEvent);
    458458}
    459459
    460460void SVGElementInstance::setOndrop(PassRefPtr<EventListener> eventListener)
    461461{
    462     correspondingElement()->setInlineEventListenerForType(eventNames().dropEvent, eventListener);
     462    correspondingElement()->setInlineEventListener(eventNames().dropEvent, eventListener);
    463463}
    464464
    465465EventListener* SVGElementInstance::ondragstart() const
    466466{
    467     return correspondingElement()->inlineEventListenerForType(eventNames().dragstartEvent);
     467    return correspondingElement()->getInlineEventListener(eventNames().dragstartEvent);
    468468}
    469469
    470470void SVGElementInstance::setOndragstart(PassRefPtr<EventListener> eventListener)
    471471{
    472     correspondingElement()->setInlineEventListenerForType(eventNames().dragstartEvent, eventListener);
     472    correspondingElement()->setInlineEventListener(eventNames().dragstartEvent, eventListener);
    473473}
    474474
    475475EventListener* SVGElementInstance::ondrag() const
    476476{
    477     return correspondingElement()->inlineEventListenerForType(eventNames().dragEvent);
     477    return correspondingElement()->getInlineEventListener(eventNames().dragEvent);
    478478}
    479479
    480480void SVGElementInstance::setOndrag(PassRefPtr<EventListener> eventListener)
    481481{
    482     correspondingElement()->setInlineEventListenerForType(eventNames().dragEvent, eventListener);
     482    correspondingElement()->setInlineEventListener(eventNames().dragEvent, eventListener);
    483483}
    484484
    485485EventListener* SVGElementInstance::ondragend() const
    486486{
    487     return correspondingElement()->inlineEventListenerForType(eventNames().dragendEvent);
     487    return correspondingElement()->getInlineEventListener(eventNames().dragendEvent);
    488488}
    489489
    490490void SVGElementInstance::setOndragend(PassRefPtr<EventListener> eventListener)
    491491{
    492     correspondingElement()->setInlineEventListenerForType(eventNames().dragendEvent, eventListener);
     492    correspondingElement()->setInlineEventListener(eventNames().dragendEvent, eventListener);
    493493}
    494494
    495495EventListener* SVGElementInstance::onreset() const
    496496{
    497     return correspondingElement()->inlineEventListenerForType(eventNames().resetEvent);
     497    return correspondingElement()->getInlineEventListener(eventNames().resetEvent);
    498498}
    499499
    500500void SVGElementInstance::setOnreset(PassRefPtr<EventListener> eventListener)
    501501{
    502     correspondingElement()->setInlineEventListenerForType(eventNames().resetEvent, eventListener);
     502    correspondingElement()->setInlineEventListener(eventNames().resetEvent, eventListener);
    503503}
    504504
    505505EventListener* SVGElementInstance::onresize() const
    506506{
    507     return correspondingElement()->inlineEventListenerForType(eventNames().resizeEvent);
     507    return correspondingElement()->getInlineEventListener(eventNames().resizeEvent);
    508508}
    509509
    510510void SVGElementInstance::setOnresize(PassRefPtr<EventListener> eventListener)
    511511{
    512     correspondingElement()->setInlineEventListenerForType(eventNames().resizeEvent, eventListener);
     512    correspondingElement()->setInlineEventListener(eventNames().resizeEvent, eventListener);
    513513}
    514514
    515515EventListener* SVGElementInstance::onscroll() const
    516516{
    517     return correspondingElement()->inlineEventListenerForType(eventNames().scrollEvent);
     517    return correspondingElement()->getInlineEventListener(eventNames().scrollEvent);
    518518}
    519519
    520520void SVGElementInstance::setOnscroll(PassRefPtr<EventListener> eventListener)
    521521{
    522     correspondingElement()->setInlineEventListenerForType(eventNames().scrollEvent, eventListener);
     522    correspondingElement()->setInlineEventListener(eventNames().scrollEvent, eventListener);
    523523}
    524524
    525525EventListener* SVGElementInstance::onsearch() const
    526526{
    527     return correspondingElement()->inlineEventListenerForType(eventNames().searchEvent);
     527    return correspondingElement()->getInlineEventListener(eventNames().searchEvent);
    528528}
    529529
    530530void SVGElementInstance::setOnsearch(PassRefPtr<EventListener> eventListener)
    531531{
    532     correspondingElement()->setInlineEventListenerForType(eventNames().searchEvent, eventListener);
     532    correspondingElement()->setInlineEventListener(eventNames().searchEvent, eventListener);
    533533}
    534534
    535535EventListener* SVGElementInstance::onselect() const
    536536{
    537     return correspondingElement()->inlineEventListenerForType(eventNames().selectEvent);
     537    return correspondingElement()->getInlineEventListener(eventNames().selectEvent);
    538538}
    539539
    540540void SVGElementInstance::setOnselect(PassRefPtr<EventListener> eventListener)
    541541{
    542     correspondingElement()->setInlineEventListenerForType(eventNames().selectEvent, eventListener);
     542    correspondingElement()->setInlineEventListener(eventNames().selectEvent, eventListener);
    543543}
    544544
    545545EventListener* SVGElementInstance::onselectstart() const
    546546{
    547     return correspondingElement()->inlineEventListenerForType(eventNames().selectstartEvent);
     547    return correspondingElement()->getInlineEventListener(eventNames().selectstartEvent);
    548548}
    549549
    550550void SVGElementInstance::setOnselectstart(PassRefPtr<EventListener> eventListener)
    551551{
    552     correspondingElement()->setInlineEventListenerForType(eventNames().selectstartEvent, eventListener);
     552    correspondingElement()->setInlineEventListener(eventNames().selectstartEvent, eventListener);
    553553}
    554554
    555555EventListener* SVGElementInstance::onsubmit() const
    556556{
    557     return correspondingElement()->inlineEventListenerForType(eventNames().submitEvent);
     557    return correspondingElement()->getInlineEventListener(eventNames().submitEvent);
    558558}
    559559
    560560void SVGElementInstance::setOnsubmit(PassRefPtr<EventListener> eventListener)
    561561{
    562     correspondingElement()->setInlineEventListenerForType(eventNames().submitEvent, eventListener);
     562    correspondingElement()->setInlineEventListener(eventNames().submitEvent, eventListener);
    563563}
    564564
    565565EventListener* SVGElementInstance::onunload() const
    566566{
    567     return correspondingElement()->inlineEventListenerForType(eventNames().unloadEvent);
     567    return correspondingElement()->getInlineEventListener(eventNames().unloadEvent);
    568568}
    569569
    570570void SVGElementInstance::setOnunload(PassRefPtr<EventListener> eventListener)
    571571{
    572     correspondingElement()->setInlineEventListenerForType(eventNames().unloadEvent, eventListener);
     572    correspondingElement()->setInlineEventListener(eventNames().unloadEvent, eventListener);
    573573}
    574574

  • trunk/WebCore/svg/SVGImageLoader.cpp

    r41766 r42633  
    4444{
    4545    if (image()->errorOccurred())
    46         element()->dispatchEventForType(eventNames().errorEvent, false, false);
     46        element()->dispatchEvent(eventNames().errorEvent, false, false);
    4747    else {
    4848        SVGImageElement* imageElement = static_cast<SVGImageElement*>(element());

  • trunk/WebCore/svg/SVGSVGElement.cpp

    r42374 r42633  
    3535#include "Frame.h"
    3636#include "HTMLNames.h"
     37#include "JSLazyEventListener.h"
    3738#include "RenderSVGViewportContainer.h"
    3839#include "RenderSVGRoot.h"
    … …  
    221222        // Only handle events if we're the outermost <svg> element
    222223        if (attr->name() == onunloadAttr)
    223             document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().unloadEvent, attr);
     224            setWindowInlineEventListener(eventNames().unloadEvent, createInlineEventListener(document()->frame(), attr));
    224225        else if (attr->name() == onresizeAttr)
    225             document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().resizeEvent, attr);
     226            setWindowInlineEventListener(eventNames().resizeEvent, createInlineEventListener(document()->frame(), attr));
    226227        else if (attr->name() == onscrollAttr)
    227             document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().scrollEvent, attr);
     228            setWindowInlineEventListener(eventNames().scrollEvent, createInlineEventListener(document()->frame(), attr));
    228229        else if (attr->name() == SVGNames::onzoomAttr)
    229             document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().zoomEvent, attr);
     230            setWindowInlineEventListener(eventNames().zoomEvent, createInlineEventListener(document()->frame(), attr));
    230231        else
    231232            setListener = false;
    … …  
    236237
    237238    if (attr->name() == onabortAttr)
    238         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().abortEvent, attr);
     239        setWindowInlineEventListener(eventNames().abortEvent, createInlineEventListener(document()->frame(), attr));
    239240    else if (attr->name() == onerrorAttr)
    240         document()->setWindowInlineEventListenerForTypeAndAttribute(eventNames().errorEvent, attr);
     241        setWindowInlineEventListener(eventNames().errorEvent, createInlineEventListener(document()->frame(), attr));
    241242    else if (attr->name() == SVGNames::xAttr)
    242243        setXBaseValue(SVGLength(LengthModeWidth, attr->value()));

  • trunk/WebCore/svg/SVGScriptElement.cpp

    r39441 r42633  
    204204void SVGScriptElement::dispatchErrorEvent()
    205205{
    206     dispatchEventForType(eventNames().errorEvent, true, false);
     206    dispatchEvent(eventNames().errorEvent, true, false);
    207207}
    208208

  • trunk/WebCore/wml/WMLInputElement.cpp

    r42622 r42633  
    302302        RenderObject* r = renderer();
    303303        if (r && toRenderTextControl(r)->isEdited()) {
    304             dispatchEventForType(eventNames().changeEvent, true, false);
     304            dispatchEvent(eventNames().changeEvent, true, false);
    305305           
    306306            // Refetch the renderer since arbitrary JS code run during onchange can do anything, including destroying it.
Note: See TracChangeset for help on using the changeset viewer.