Changeset 155356 in webkit


Ignore:
Timestamp:
Sep 9, 2013 9:58:20 AM (11 years ago)
Author:
Darin Adler
Message:

Tighten up EventQueue classes a bit, less indirection and memory allocation
​https://bugs.webkit.org/show_bug.cgi?id=121016

Reviewed by Andreas Kling.

  • Modules/encryptedmedia/MediaKeySession.cpp:

(WebCore::MediaKeySession::MediaKeySession): Updated since event queue is now
a member rather than an OwnPtr.
(WebCore::MediaKeySession::close): Ditto.
(WebCore::MediaKeySession::keyRequestTimerFired): Ditto.
(WebCore::MediaKeySession::addKeyTimerFired): Ditto.

  • Modules/encryptedmedia/MediaKeySession.h: Ditto.
  • Modules/indexeddb/IDBDatabase.cpp:

(WebCore::IDBDatabase::closeConnection): Updated since ScriptExecutionContext's
eventQueue function now returns a reference rather than a pointer. Also, the
cancelEvent function takes a reference instead of a pointer.
(WebCore::IDBDatabase::enqueueEvent): Ditto.

  • Modules/indexeddb/IDBRequest.cpp:

(WebCore::IDBRequest::abort): Ditto.
(WebCore::IDBRequest::enqueueEvent): Ditto.

  • Modules/indexeddb/IDBTransaction.cpp:

(WebCore::IDBTransaction::enqueueEvent): Ditto.

  • Modules/mediasource/MediaSource.cpp:

(WebCore::MediaSource::MediaSource): Updated since event queue is now a
member rather than an OwnPtr. Also use initialization instead of assignment
to set up source buffers.
(WebCore::MediaSource::hasPendingActivity): Ditto.
(WebCore::MediaSource::stop): Ditto.
(WebCore::MediaSource::scheduleEvent): Ditto.

  • Modules/mediasource/MediaSource.h: Ditto.
  • Modules/mediasource/SourceBufferList.cpp:

(WebCore::SourceBufferList::SourceBufferList): Take references instead of
pointers.
(WebCore::SourceBufferList::length): Changed type to unsigned instead of
unsigned long. This is an IDL "unsigned long", which corresponds to "unsigned"
in our C++ DOM implementation.
(WebCore::SourceBufferList::createAndFireEvent): Updated since event queue is
now a reference.
(WebCore::SourceBufferList::scriptExecutionContext): Updated since script
execution context is now a reference.

  • Modules/mediasource/SourceBufferList.h: Ditto.
  • dom/Document.cpp:

(WebCore::Document::Document): Updated since event queue is now a member rather
than a RefPtr.
(WebCore::Document::detach): Ditto.
(WebCore::Document::enqueueWindowEvent): Ditto.
(WebCore::Document::enqueueDocumentEvent): Ditto.

  • dom/Document.h: Ditto.
  • dom/DocumentEventQueue.cpp: Renamed DocumentEventQueueTimer to just Timer and

made it a class member of DocumentEventQueue. Also changed it to use references
instead of pointers and removed unneeded ScriptExecutionContext argument.
(WebCore::DocumentEventQueue::DocumentEventQueue): Updated to take a document
reference instead of a script execution context pointer.
(WebCore::DocumentEventQueue::enqueueEvent): Wrote the assertions in a clearer
style and do the assertions even when the queue is closed.
(WebCore::DocumentEventQueue::enqueueOrDispatchScrollEvent): Removed the unneeded
ScrollEventTargetType argument, since the policy is specific to the document node.
Made the argument a reference instead of a PassRefPtr, and rewrote the function
to be more straightforward and readable.
(WebCore::DocumentEventQueue::cancelEvent): Use the return value recently added to
the remove function to avoid the need for use of iterators and a find/remove pair.
(WebCore::DocumentEventQueue::pendingEventTimerFired): Rewrote this to use the
recently added ListHashSet takeFirst function. Also protect the document instead
of protecting just this object during the dispatch. Can't really protect the
event queue since it's no longer separately reference counted.
(WebCore::DocumentEventQueue::dispatchEvent): Changed this to take a reference and
added a FIXME about some curious code in here that needs a "why" comment.

  • dom/DocumentEventQueue.h: Removed many unneeded includes, some unneeded forward

declarations, marked the class final, made it no longer derive from RefCounted,
removed ScrollEventTargetType and create, and did the other changes mentioned above.

  • dom/EventQueue.h: Got rid of many uneeded includes, changed the argument type

of cancelEvent to Event& and rewrote the comment for close.

  • dom/GenericEventQueue.cpp:

(WebCore::GenericEventQueue::GenericEventQueue): Updated to take a reference.
(WebCore::GenericEventQueue::enqueueEvent): Ditto.
(WebCore::GenericEventQueue::timerFired): Ditto.

  • dom/GenericEventQueue.h: Changed this class to no longer derive from EventQueue

since there was no value coming from that polymorphism. Removed all the virtual
keywords from the class. Switched from pointers to references. Removed the unused
cancelEvent function. Removed the create function since this is always used as a
data member, not a pointer on the heap.

  • dom/ScriptExecutionContext.h: Changed the return type of eventQueue to a reference.
  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::HTMLMediaElement): Updated since event queue is now a
member rather than an OwnPtr.
(WebCore::HTMLMediaElement::~HTMLMediaElement): Ditto.
(WebCore::HTMLMediaElement::scheduleEvent): Ditto.
(WebCore::HTMLMediaElement::updateActiveTextTrackCues): Ditto.
(WebCore::HTMLMediaElement::cancelPendingEventsAndCallbacks): Ditto.
(WebCore::HTMLMediaElement::mediaPlayerKeyAdded): Ditto.
(WebCore::HTMLMediaElement::mediaPlayerKeyError): Ditto.
(WebCore::HTMLMediaElement::mediaPlayerKeyMessage): Ditto.
(WebCore::HTMLMediaElement::mediaPlayerKeyNeeded): Ditto.
(WebCore::HTMLMediaElement::stop): Ditto.
(WebCore::HTMLMediaElement::hasPendingActivity): Ditto.

  • html/HTMLMediaElement.h: Ditto.
  • page/EventHandler.cpp:

(WebCore::EventHandler::sendScrollEvent): Updated to remove the now-uneeded
ScrollEventTargetType argument, and also to use references instead of pointers.

  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::scrollTo): Ditto.

  • rendering/RenderListBox.cpp:

(WebCore::RenderListBox::scrollTo): Ditto.

  • workers/WorkerEventQueue.cpp:

(WebCore::WorkerEventQueue::WorkerEventQueue): Updated to work with references
instead of pointers.
(WebCore::WorkerEventQueue::enqueueEvent): Ditto.
(WebCore::WorkerEventQueue::cancelEvent): Use the take function instead of a
get/remove pair, to eliminate double hashing.

  • workers/WorkerEventQueue.h: Removed unneeded includes, forward declarations,

the create function, and the private removeEvent function. Marked class final.

  • workers/WorkerGlobalScope.cpp:

(WebCore::WorkerGlobalScope::WorkerGlobalScope): Updated since eventQueue is
now a data member.
(WebCore::WorkerGlobalScope::eventQueue): Ditto.

  • workers/WorkerGlobalScope.h: Made m_eventQueue a queue instead of a pointer

to a queue. Also made the eventQueue function private and final.

Location:
trunk/Source/WebCore
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r155354 r155356  
     12013-09-08  Darin Adler  <darin@apple.com>
     2
     3        Tighten up EventQueue classes a bit, less indirection and memory allocation
     4        https://bugs.webkit.org/show_bug.cgi?id=121016
     5
     6        Reviewed by Andreas Kling.
     7
     8        * Modules/encryptedmedia/MediaKeySession.cpp:
     9        (WebCore::MediaKeySession::MediaKeySession): Updated since event queue is now
     10        a member rather than an OwnPtr.
     11        (WebCore::MediaKeySession::close): Ditto.
     12        (WebCore::MediaKeySession::keyRequestTimerFired): Ditto.
     13        (WebCore::MediaKeySession::addKeyTimerFired): Ditto.
     14        * Modules/encryptedmedia/MediaKeySession.h: Ditto.
     15
     16        * Modules/indexeddb/IDBDatabase.cpp:
     17        (WebCore::IDBDatabase::closeConnection): Updated since ScriptExecutionContext's
     18        eventQueue function now returns a reference rather than a pointer. Also, the
     19        cancelEvent function takes a reference instead of a pointer.
     20        (WebCore::IDBDatabase::enqueueEvent): Ditto.
     21        * Modules/indexeddb/IDBRequest.cpp:
     22        (WebCore::IDBRequest::abort): Ditto.
     23        (WebCore::IDBRequest::enqueueEvent): Ditto.
     24        * Modules/indexeddb/IDBTransaction.cpp:
     25        (WebCore::IDBTransaction::enqueueEvent): Ditto.
     26
     27        * Modules/mediasource/MediaSource.cpp:
     28        (WebCore::MediaSource::MediaSource): Updated since event queue is now a
     29        member rather than an OwnPtr. Also use initialization instead of assignment
     30        to set up source buffers.
     31        (WebCore::MediaSource::hasPendingActivity): Ditto.
     32        (WebCore::MediaSource::stop): Ditto.
     33        (WebCore::MediaSource::scheduleEvent): Ditto.
     34        * Modules/mediasource/MediaSource.h: Ditto.
     35
     36        * Modules/mediasource/SourceBufferList.cpp:
     37        (WebCore::SourceBufferList::SourceBufferList): Take references instead of
     38        pointers.
     39        (WebCore::SourceBufferList::length): Changed type to unsigned instead of
     40        unsigned long. This is an IDL "unsigned long", which corresponds to "unsigned"
     41        in our C++ DOM implementation.
     42        (WebCore::SourceBufferList::createAndFireEvent): Updated since event queue is
     43        now a reference.
     44        (WebCore::SourceBufferList::scriptExecutionContext): Updated since script
     45        execution context is now a reference.
     46        * Modules/mediasource/SourceBufferList.h: Ditto.
     47
     48        * dom/Document.cpp:
     49        (WebCore::Document::Document): Updated since event queue is now a member rather
     50        than a RefPtr.
     51        (WebCore::Document::detach): Ditto.
     52        (WebCore::Document::enqueueWindowEvent): Ditto.
     53        (WebCore::Document::enqueueDocumentEvent): Ditto.
     54        * dom/Document.h: Ditto.
     55
     56        * dom/DocumentEventQueue.cpp: Renamed DocumentEventQueueTimer to just Timer and
     57        made it a class member of DocumentEventQueue. Also changed it to use references
     58        instead of pointers and removed unneeded ScriptExecutionContext argument.
     59        (WebCore::DocumentEventQueue::DocumentEventQueue): Updated to take a document
     60        reference instead of a script execution context pointer.
     61        (WebCore::DocumentEventQueue::enqueueEvent): Wrote the assertions in a clearer
     62        style and do the assertions even when the queue is closed.
     63        (WebCore::DocumentEventQueue::enqueueOrDispatchScrollEvent): Removed the unneeded
     64        ScrollEventTargetType argument, since the policy is specific to the document node.
     65        Made the argument a reference instead of a PassRefPtr, and rewrote the function
     66        to be more straightforward and readable.
     67        (WebCore::DocumentEventQueue::cancelEvent): Use the return value recently added to
     68        the remove function to avoid the need for use of iterators and a find/remove pair.
     69        (WebCore::DocumentEventQueue::pendingEventTimerFired): Rewrote this to use the
     70        recently added ListHashSet takeFirst function. Also protect the document instead
     71        of protecting just this object during the dispatch. Can't really protect the
     72        event queue since it's no longer separately reference counted.
     73        (WebCore::DocumentEventQueue::dispatchEvent): Changed this to take a reference and
     74        added a FIXME about some curious code in here that needs a "why" comment.
     75        * dom/DocumentEventQueue.h: Removed many unneeded includes, some unneeded forward
     76        declarations, marked the class final, made it no longer derive from RefCounted,
     77        removed ScrollEventTargetType and create, and did the other changes mentioned above.
     78
     79        * dom/EventQueue.h: Got rid of many uneeded includes, changed the argument type
     80        of cancelEvent to Event& and rewrote the comment for close.
     81
     82        * dom/GenericEventQueue.cpp:
     83        (WebCore::GenericEventQueue::GenericEventQueue): Updated to take a reference.
     84        (WebCore::GenericEventQueue::enqueueEvent): Ditto.
     85        (WebCore::GenericEventQueue::timerFired): Ditto.
     86        * dom/GenericEventQueue.h: Changed this class to no longer derive from EventQueue
     87        since there was no value coming from that polymorphism. Removed all the virtual
     88        keywords from the class. Switched from pointers to references. Removed the unused
     89        cancelEvent function. Removed the create function since this is always used as a
     90        data member, not a pointer on the heap.
     91
     92        * dom/ScriptExecutionContext.h: Changed the return type of eventQueue to a reference.
     93
     94        * html/HTMLMediaElement.cpp:
     95        (WebCore::HTMLMediaElement::HTMLMediaElement): Updated since event queue is now a
     96        member rather than an OwnPtr.
     97        (WebCore::HTMLMediaElement::~HTMLMediaElement): Ditto.
     98        (WebCore::HTMLMediaElement::scheduleEvent): Ditto.
     99        (WebCore::HTMLMediaElement::updateActiveTextTrackCues): Ditto.
     100        (WebCore::HTMLMediaElement::cancelPendingEventsAndCallbacks): Ditto.
     101        (WebCore::HTMLMediaElement::mediaPlayerKeyAdded): Ditto.
     102        (WebCore::HTMLMediaElement::mediaPlayerKeyError): Ditto.
     103        (WebCore::HTMLMediaElement::mediaPlayerKeyMessage): Ditto.
     104        (WebCore::HTMLMediaElement::mediaPlayerKeyNeeded): Ditto.
     105        (WebCore::HTMLMediaElement::stop): Ditto.
     106        (WebCore::HTMLMediaElement::hasPendingActivity): Ditto.
     107        * html/HTMLMediaElement.h: Ditto.
     108
     109        * page/EventHandler.cpp:
     110        (WebCore::EventHandler::sendScrollEvent): Updated to remove the now-uneeded
     111        ScrollEventTargetType argument, and also to use references instead of pointers.
     112        * rendering/RenderLayer.cpp:
     113        (WebCore::RenderLayer::scrollTo): Ditto.
     114        * rendering/RenderListBox.cpp:
     115        (WebCore::RenderListBox::scrollTo): Ditto.
     116
     117        * workers/WorkerEventQueue.cpp:
     118        (WebCore::WorkerEventQueue::WorkerEventQueue): Updated to work with references
     119        instead of pointers.
     120        (WebCore::WorkerEventQueue::enqueueEvent): Ditto.
     121        (WebCore::WorkerEventQueue::cancelEvent): Use the take function instead of a
     122        get/remove pair, to eliminate double hashing.
     123        * workers/WorkerEventQueue.h: Removed unneeded includes, forward declarations,
     124        the create function, and the private removeEvent function. Marked class final.
     125
     126        * workers/WorkerGlobalScope.cpp:
     127        (WebCore::WorkerGlobalScope::WorkerGlobalScope): Updated since eventQueue is
     128        now a data member.
     129        (WebCore::WorkerGlobalScope::eventQueue): Ditto.
     130        * workers/WorkerGlobalScope.h: Made m_eventQueue a queue instead of a pointer
     131        to a queue. Also made the eventQueue function private and final.
     132
    11332013-09-09  Hans Muller  <hmuller@adobe.com>
    2134

  • trunk/Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp

    r142918 r155356  
    4747    , m_keys(keys)
    4848    , m_keySystem(keySystem)
    49     , m_asyncEventQueue(GenericEventQueue::create(this))
     49    , m_asyncEventQueue(*this)
    5050    , m_session(keys->cdm()->createSession())
    5151    , m_keyRequestTimer(this, &MediaKeySession::keyRequestTimerFired)
    … …  
    6969        m_session->releaseKeys();
    7070    m_session = 0;
    71     m_asyncEventQueue->cancelAllEvents();
     71    m_asyncEventQueue.cancelAllEvents();
    7272}
    7373
    … …  
    118118            RefPtr<Event> event = Event::create(eventNames().webkitkeyerrorEvent, false, false);
    119119            event->setTarget(this);
    120             m_asyncEventQueue->enqueueEvent(event.release());
     120            m_asyncEventQueue.enqueueEvent(event.release());
    121121
    122122            // 3.4. Abort the task.
    … …  
    135135        RefPtr<MediaKeyMessageEvent> event = MediaKeyMessageEvent::create(eventNames().webkitkeymessageEvent, init);
    136136        event->setTarget(this);
    137         m_asyncEventQueue->enqueueEvent(event);
     137        m_asyncEventQueue.enqueueEvent(event.release());
    138138    }
    139139}
    … …  
    189189            RefPtr<MediaKeyMessageEvent> event = MediaKeyMessageEvent::create(eventNames().webkitkeymessageEvent, init);
    190190            event->setTarget(this);
    191             m_asyncEventQueue->enqueueEvent(event);
     191            m_asyncEventQueue.enqueueEvent(event.release());
    192192        }
    193193
    … …  
    196196            RefPtr<Event> keyaddedEvent = Event::create(eventNames().webkitkeyaddedEvent, false, false);
    197197            keyaddedEvent->setTarget(this);
    198             m_asyncEventQueue->enqueueEvent(keyaddedEvent);
     198            m_asyncEventQueue.enqueueEvent(keyaddedEvent.release());
    199199        }
    200200
    … …  
    212212            RefPtr<Event> keyerrorEvent = Event::create(eventNames().webkitkeyerrorEvent, false, false);
    213213            keyerrorEvent->setTarget(this);
    214             m_asyncEventQueue->enqueueEvent(keyerrorEvent.release());
     214            m_asyncEventQueue.enqueueEvent(keyerrorEvent.release());
    215215           
    216216            // 2.8.4. Abort the task.

  • trunk/Source/WebCore/Modules/encryptedmedia/MediaKeySession.h

    r153926 r155356  
    8585    String m_sessionId;
    8686    RefPtr<MediaKeyError> m_error;
    87     OwnPtr<GenericEventQueue> m_asyncEventQueue;
     87    GenericEventQueue m_asyncEventQueue;
    8888    OwnPtr<CDMSession> m_session;
    8989

  • trunk/Source/WebCore/Modules/indexeddb/IDBDatabase.cpp

    r153926 r155356  
    293293        return;
    294294
    295     EventQueue* eventQueue = scriptExecutionContext()->eventQueue();
     295    EventQueue& eventQueue = scriptExecutionContext()->eventQueue();
    296296    // Remove any pending versionchange events scheduled to fire on this
    297297    // connection. They would have been scheduled by the backend when another
    … …  
    299299    // closed before they could fire.
    300300    for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
    301         bool removed = eventQueue->cancelEvent(m_enqueuedEvents[i].get());
     301        bool removed = eventQueue.cancelEvent(*m_enqueuedEvents[i]);
    302302        ASSERT_UNUSED(removed, removed);
    303303    }
    … …  
    321321    ASSERT(!m_contextStopped);
    322322    ASSERT(scriptExecutionContext());
    323     EventQueue* eventQueue = scriptExecutionContext()->eventQueue();
    324323    event->setTarget(this);
    325     eventQueue->enqueueEvent(event.get());
     324    scriptExecutionContext()->eventQueue().enqueueEvent(event.get());
    326325    m_enqueuedEvents.append(event);
    327326}

  • trunk/Source/WebCore/Modules/indexeddb/IDBRequest.cpp

    r153926 r155356  
    172172    RefPtr<IDBRequest> self(this);
    173173
    174     EventQueue* eventQueue = scriptExecutionContext()->eventQueue();
     174    EventQueue& eventQueue = scriptExecutionContext()->eventQueue();
    175175    for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
    176         bool removed = eventQueue->cancelEvent(m_enqueuedEvents[i].get());
     176        bool removed = eventQueue.cancelEvent(*m_enqueuedEvents[i]);
    177177        ASSERT_UNUSED(removed, removed);
    178178    }
    … …  
    553553    ASSERT_WITH_MESSAGE(m_readyState == PENDING || m_didFireUpgradeNeededEvent, "When queueing event %s, m_readyState was %d", event->type().string().utf8().data(), m_readyState);
    554554
    555     EventQueue* eventQueue = scriptExecutionContext()->eventQueue();
    556555    event->setTarget(this);
    557556
    558     if (eventQueue->enqueueEvent(event.get()))
     557    if (scriptExecutionContext()->eventQueue().enqueueEvent(event.get()))
    559558        m_enqueuedEvents.append(event);
    560559}

  • trunk/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp

    r153926 r155356  
    433433        return;
    434434
    435     EventQueue* eventQueue = scriptExecutionContext()->eventQueue();
    436435    event->setTarget(this);
    437     eventQueue->enqueueEvent(event);
     436    scriptExecutionContext()->eventQueue().enqueueEvent(event);
    438437}
    439438

  • trunk/Source/WebCore/Modules/mediasource/MediaSource.cpp

    r153926 r155356  
    5353    : ActiveDOMObject(context)
    5454    , m_readyState(closedKeyword())
    55     , m_asyncEventQueue(GenericEventQueue::create(this))
    56 {
    57     m_sourceBuffers = SourceBufferList::create(scriptExecutionContext(), m_asyncEventQueue.get());
    58     m_activeSourceBuffers = SourceBufferList::create(scriptExecutionContext(), m_asyncEventQueue.get());
     55    , m_asyncEventQueue(*this)
     56    , m_sourceBuffers(SourceBufferList::create(scriptExecutionContext(), m_asyncEventQueue))
     57    , m_activeSourceBuffers(SourceBufferList::create(scriptExecutionContext(), m_asyncEventQueue))
     58{
    5959}
    6060
    … …  
    303303bool MediaSource::hasPendingActivity() const
    304304{
    305     return m_private || m_asyncEventQueue->hasPendingEvents()
    306         || ActiveDOMObject::hasPendingActivity();
     305    return m_private || m_asyncEventQueue.hasPendingEvents() || ActiveDOMObject::hasPendingActivity();
    307306}
    308307
    … …  
    310309{
    311310    m_private.clear();
    312     m_asyncEventQueue->cancelAllEvents();
     311    m_asyncEventQueue.cancelAllEvents();
    313312}
    314313
    … …  
    325324void MediaSource::scheduleEvent(const AtomicString& eventName)
    326325{
    327     ASSERT(m_asyncEventQueue);
    328 
    329326    RefPtr<Event> event = Event::create(eventName, false, false);
    330327    event->setTarget(this);
    331 
    332     m_asyncEventQueue->enqueueEvent(event.release());
     328    m_asyncEventQueue.enqueueEvent(event.release());
    333329}
    334330

  • trunk/Source/WebCore/Modules/mediasource/MediaSource.h

    r153926 r155356  
    9595    OwnPtr<MediaSourcePrivate> m_private;
    9696
     97    GenericEventQueue m_asyncEventQueue;
    9798    RefPtr<SourceBufferList> m_sourceBuffers;
    9899    RefPtr<SourceBufferList> m_activeSourceBuffers;
    99     OwnPtr<GenericEventQueue> m_asyncEventQueue;
    100100};
    101101

  • trunk/Source/WebCore/Modules/mediasource/SourceBufferList.cpp

    r153926 r155356  
    4040namespace WebCore {
    4141
    42 SourceBufferList::SourceBufferList(ScriptExecutionContext* context,
    43                                    GenericEventQueue* asyncEventQueue)
     42SourceBufferList::SourceBufferList(ScriptExecutionContext& context, GenericEventQueue& asyncEventQueue)
    4443    : m_scriptExecutionContext(context)
    4544    , m_asyncEventQueue(asyncEventQueue)
    … …  
    4746}
    4847
    49 unsigned long SourceBufferList::length() const
     48unsigned SourceBufferList::length() const
    5049{
    5150    return m_list.size();
    … …  
    8786void SourceBufferList::createAndFireEvent(const AtomicString& eventName)
    8887{
    89     ASSERT(m_asyncEventQueue);
    90 
    9188    RefPtr<Event> event = Event::create(eventName, false, false);
    9289    event->setTarget(this);
    93 
    94     m_asyncEventQueue->enqueueEvent(event.release());
     90    m_asyncEventQueue.enqueueEvent(event.release());
    9591}
    9692
    … …  
    10298ScriptExecutionContext* SourceBufferList::scriptExecutionContext() const
    10399{
    104     return m_scriptExecutionContext;
     100    return &m_scriptExecutionContext;
    105101}
    106102

  • trunk/Source/WebCore/Modules/mediasource/SourceBufferList.h

    r153926 r155356  
    4545class SourceBufferList : public RefCounted<SourceBufferList>, public EventTarget {
    4646public:
    47     static PassRefPtr<SourceBufferList> create(ScriptExecutionContext* context, GenericEventQueue* asyncEventQueue)
     47    static PassRefPtr<SourceBufferList> create(ScriptExecutionContext& context, GenericEventQueue& asyncEventQueue)
    4848    {
    4949        return adoptRef(new SourceBufferList(context, asyncEventQueue));
    … …  
    5151    virtual ~SourceBufferList() { }
    5252
    53     unsigned long length() const;
     53    unsigned length() const;
    5454    SourceBuffer* item(unsigned index) const;
    5555
    … …  
    7878
    7979    EventTargetData m_eventTargetData;
    80     ScriptExecutionContext* m_scriptExecutionContext;
    81     GenericEventQueue* m_asyncEventQueue;
     80    ScriptExecutionContext& m_scriptExecutionContext;
     81    GenericEventQueue& m_asyncEventQueue;
    8282
    8383    Vector<RefPtr<SourceBuffer> > m_list;

  • trunk/Source/WebCore/dom/Document.cpp

    r155351 r155356  
    449449    , m_isSrcdocDocument(false)
    450450    , m_renderView(0)
    451     , m_eventQueue(DocumentEventQueue::create(this))
     451    , m_eventQueue(*this)
    452452    , m_weakFactory(this)
    453453    , m_idAttributeName(idAttr)
    … …  
    20582058
    20592059    stopActiveDOMObjects();
    2060     m_eventQueue->close();
     2060    m_eventQueue.close();
    20612061#if ENABLE(FULLSCREEN_API)
    20622062    m_fullScreenChangeEventTargetQueue.clear();
    … …  
    36313631{
    36323632    event->setTarget(domWindow());
    3633     m_eventQueue->enqueueEvent(event);
     3633    m_eventQueue.enqueueEvent(event);
    36343634}
    36353635
    … …  
    36373637{
    36383638    event->setTarget(this);
    3639     m_eventQueue->enqueueEvent(event);
     3639    m_eventQueue.enqueueEvent(event);
    36403640}
    36413641

  • trunk/Source/WebCore/dom/Document.h

    r155344 r155356  
    10111011    void enqueueHashchangeEvent(const String& oldURL, const String& newURL);
    10121012    void enqueuePopstateEvent(PassRefPtr<SerializedScriptValue> stateObject);
    1013     virtual DocumentEventQueue* eventQueue() const { return m_eventQueue.get(); }
     1013    DocumentEventQueue& eventQueue() const { return m_eventQueue; }
    10141014
    10151015    void addMediaCanStartListener(MediaCanStartListener*);
    … …  
    14481448
    14491449    RenderView* m_renderView;
    1450     RefPtr<DocumentEventQueue> m_eventQueue;
     1450    mutable DocumentEventQueue m_eventQueue;
    14511451
    14521452    WeakPtrFactory<Document> m_weakFactory;

  • trunk/Source/WebCore/dom/DocumentEventQueue.cpp

    r154962 r155356  
    11/*
    22 * Copyright (C) 2010 Google Inc. All Rights Reserved.
     3 * Copyright (C) 2013 Apple Inc. All Rights Reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    3233#include "Event.h"
    3334#include "EventNames.h"
    34 #include "RuntimeApplicationChecks.h"
    35 #include "ScriptExecutionContext.h"
    3635#include "SuspendableTimer.h"
    3736#include <wtf/Ref.h>
    … …  
    3938namespace WebCore {
    4039   
    41 class DocumentEventQueueTimer FINAL : public SuspendableTimer {
     40class DocumentEventQueue::Timer FINAL : public SuspendableTimer {
    4241public:
    43     static PassOwnPtr<DocumentEventQueueTimer> create(DocumentEventQueue* eventQueue, ScriptExecutionContext* context)
     42    static PassOwnPtr<Timer> create(DocumentEventQueue& eventQueue)
    4443    {
    45         return adoptPtr(new DocumentEventQueueTimer(eventQueue, context));
     44        return adoptPtr(new Timer(eventQueue));
    4645    }
    4746
    4847private:
    49     DocumentEventQueueTimer(DocumentEventQueue* eventQueue, ScriptExecutionContext* context)
    50         : SuspendableTimer(context)
    51         , m_eventQueue(eventQueue) { }
     48    Timer(DocumentEventQueue& eventQueue)
     49        : SuspendableTimer(&eventQueue.m_document)
     50        , m_eventQueue(eventQueue)
     51    {
     52    }
    5253
    5354    virtual void fired() OVERRIDE
    5455    {
    5556        ASSERT(!isSuspended());
    56         m_eventQueue->pendingEventTimerFired();
     57        m_eventQueue.pendingEventTimerFired();
    5758    }
    5859
    59     DocumentEventQueue* m_eventQueue;
     60    DocumentEventQueue& m_eventQueue;
    6061};
    6162
    62 PassRefPtr<DocumentEventQueue> DocumentEventQueue::create(ScriptExecutionContext* context)
    63 {
    64     return adoptRef(new DocumentEventQueue(context));
    65 }
    66 
    67 DocumentEventQueue::DocumentEventQueue(ScriptExecutionContext* context)
    68     : m_pendingEventTimer(DocumentEventQueueTimer::create(this, context))
     63DocumentEventQueue::DocumentEventQueue(Document& document)
     64    : m_document(document)
     65    , m_pendingEventTimer(Timer::create(*this))
    6966    , m_isClosed(false)
    7067{
    … …  
    7875bool DocumentEventQueue::enqueueEvent(PassRefPtr<Event> event)
    7976{
     77    ASSERT(event->target());
     78    ASSERT(!m_queuedEvents.contains(event.get()));
     79
    8080    if (m_isClosed)
    8181        return false;
    8282
    83     ASSERT(event->target());
    84     bool wasAdded = m_queuedEvents.add(event).isNewEntry;
    85     ASSERT_UNUSED(wasAdded, wasAdded); // It should not have already been in the list.
    86    
     83    m_queuedEvents.add(event);
    8784    if (!m_pendingEventTimer->isActive())
    8885        m_pendingEventTimer->startOneShot(0);
    89 
    9086    return true;
    9187}
    9288
    93 void DocumentEventQueue::enqueueOrDispatchScrollEvent(PassRefPtr<Node> target, ScrollEventTargetType targetType)
     89void DocumentEventQueue::enqueueOrDispatchScrollEvent(Node& target)
    9490{
    95     if (!target->document().hasListenerType(Document::SCROLL_LISTENER))
     91    ASSERT(&target.document() == &m_document);
     92
     93    if (m_isClosed)
     94        return;
     95
     96    if (!m_document.hasListenerType(Document::SCROLL_LISTENER))
     97        return;
     98
     99    if (!m_nodesWithQueuedScrollEvents.add(&target).isNewEntry)
    96100        return;
    97101
    98102    // Per the W3C CSSOM View Module, scroll events fired at the document should bubble, others should not.
    99     bool canBubble = targetType == ScrollEventDocumentTarget;
    100     RefPtr<Event> scrollEvent = Event::create(eventNames().scrollEvent, canBubble, false /* non cancelleable */);
    101      
    102     if (!m_nodesWithQueuedScrollEvents.add(target.get()).isNewEntry)
    103         return;
     103    bool bubbles = target.isDocumentNode();
     104    bool cancelable = false;
    104105
    105     scrollEvent->setTarget(target);
     106    RefPtr<Event> scrollEvent = Event::create(eventNames().scrollEvent, bubbles, cancelable);
     107    scrollEvent->setTarget(&target);
    106108    enqueueEvent(scrollEvent.release());
    107109}
    108110
    109 bool DocumentEventQueue::cancelEvent(Event* event)
     111bool DocumentEventQueue::cancelEvent(Event& event)
    110112{
    111     ListHashSet<RefPtr<Event>, 16>::iterator it = m_queuedEvents.find(event);
    112     bool found = it != m_queuedEvents.end();
    113     if (found)
    114         m_queuedEvents.remove(it);
     113    bool found = m_queuedEvents.remove(&event);
    115114    if (m_queuedEvents.isEmpty())
    116115        m_pendingEventTimer->cancel();
    … …  
    133132
    134133    // Insert a marker for where we should stop.
    135     ASSERT(!m_queuedEvents.contains(0));
    136     bool wasAdded = m_queuedEvents.add(0).isNewEntry;
    137     ASSERT_UNUSED(wasAdded, wasAdded); // It should not have already been in the list.
     134    ASSERT(!m_queuedEvents.contains(nullptr));
     135    m_queuedEvents.add(nullptr);
    138136
    139     Ref<DocumentEventQueue> protect(*this);
     137    Ref<Document> protect(m_document);
    140138
    141139    while (!m_queuedEvents.isEmpty()) {
    142         ListHashSet<RefPtr<Event>, 16>::iterator iter = m_queuedEvents.begin();
    143         RefPtr<Event> event = *iter;
    144         m_queuedEvents.remove(iter);
     140        RefPtr<Event> event = m_queuedEvents.takeFirst();
    145141        if (!event)
    146142            break;
    147         dispatchEvent(event.get());
     143        dispatchEvent(*event);
    148144    }
    149145}
    150146
    151 void DocumentEventQueue::dispatchEvent(PassRefPtr<Event> event)
     147void DocumentEventQueue::dispatchEvent(Event& event)
    152148{
    153     EventTarget* eventTarget = event->target();
    154     if (eventTarget->toDOMWindow())
    155         eventTarget->toDOMWindow()->dispatchEvent(event, 0);
     149    // FIXME: Where did this special case for the DOM window come from?
     150    // Why do we have this special case here instead of a virtual function on EventTarget?
     151    EventTarget& eventTarget = *event.target();
     152    if (DOMWindow* window = eventTarget.toDOMWindow())
     153        window->dispatchEvent(&event, 0);
    156154    else
    157         eventTarget->dispatchEvent(event);
     155        eventTarget.dispatchEvent(&event);
    158156}
    159157

  • trunk/Source/WebCore/dom/DocumentEventQueue.h

    r148921 r155356  
    11/*
    22 * Copyright (C) 2010 Google Inc. All Rights Reserved.
     3 * Copyright (C) 2013 Apple Inc. All Rights Reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2930
    3031#include "EventQueue.h"
    31 #include <wtf/Forward.h>
    3232#include <wtf/HashSet.h>
    3333#include <wtf/ListHashSet.h>
    3434#include <wtf/OwnPtr.h>
    35 #include <wtf/RefCounted.h>
    36 #include <wtf/RefPtr.h>
    3735
    3836namespace WebCore {
    3937
     38class Document;
    4039class Event;
    41 class DocumentEventQueueTimer;
    4240class Node;
    43 class ScriptExecutionContext;
    4441
    45 class DocumentEventQueue : public RefCounted<DocumentEventQueue>, public EventQueue {
     42class DocumentEventQueue FINAL : public EventQueue {
    4643public:
    47     enum ScrollEventTargetType {
    48         ScrollEventDocumentTarget,
    49         ScrollEventElementTarget
    50     };
     44    explicit DocumentEventQueue(Document&);
     45    ~DocumentEventQueue();
    5146
    52     static PassRefPtr<DocumentEventQueue> create(ScriptExecutionContext*);
    53     virtual ~DocumentEventQueue();
    54 
    55     // EventQueue
    5647    virtual bool enqueueEvent(PassRefPtr<Event>) OVERRIDE;
    57     virtual bool cancelEvent(Event*) OVERRIDE;
     48    virtual bool cancelEvent(Event&) OVERRIDE;
    5849    virtual void close() OVERRIDE;
    5950
    60     void enqueueOrDispatchScrollEvent(PassRefPtr<Node>, ScrollEventTargetType);
     51    void enqueueOrDispatchScrollEvent(Node&);
    6152
    6253private:
    63     explicit DocumentEventQueue(ScriptExecutionContext*);
     54    void pendingEventTimerFired();
     55    void dispatchEvent(Event&);
    6456
    65     void pendingEventTimerFired();
    66     void dispatchEvent(PassRefPtr<Event>);
     57    class Timer;
    6758
    68     OwnPtr<DocumentEventQueueTimer> m_pendingEventTimer;
     59    Document& m_document;
     60    OwnPtr<Timer> m_pendingEventTimer;
    6961    ListHashSet<RefPtr<Event>, 16> m_queuedEvents;
    7062    HashSet<Node*> m_nodesWithQueuedScrollEvents;
    7163    bool m_isClosed;
    72 
    73     friend class DocumentEventQueueTimer;   
    7464};
    7565

  • trunk/Source/WebCore/dom/EventQueue.h

    r100959 r155356  
    2828#define EventQueue_h
    2929
    30 #include <wtf/HashMap.h>
    31 #include <wtf/HashSet.h>
    32 #include <wtf/PassOwnPtr.h>
     30#include <wtf/Forward.h>
    3331
    3432namespace WebCore {
    … …  
    4038    virtual ~EventQueue() { }
    4139    virtual bool enqueueEvent(PassRefPtr<Event>) = 0;
    42     virtual bool cancelEvent(Event*) = 0;
    43     // The accumulated and all the future events will be discarded, no events will be dispatched anymore.
    44     virtual void close() = 0;
     40    virtual bool cancelEvent(Event&) = 0;
     41    virtual void close() = 0; // Discard accumulated events and all future events. No events will be dispatched after this.
    4542};
    4643

  • trunk/Source/WebCore/dom/GenericEventQueue.cpp

    r151600 r155356  
    2525
    2626#include "config.h"
    27 
    2827#include "GenericEventQueue.h"
    2928
    3029#include "Event.h"
     30#include "EventTarget.h"
    3131
    3232namespace WebCore {
    3333
    34 PassOwnPtr<GenericEventQueue> GenericEventQueue::create(EventTarget* owner)
    35 {
    36     return adoptPtr(new GenericEventQueue(owner));
    37 }
    38 
    39 GenericEventQueue::GenericEventQueue(EventTarget* owner)
     34GenericEventQueue::GenericEventQueue(EventTarget& owner)
    4035    : m_owner(owner)
    4136    , m_timer(this, &GenericEventQueue::timerFired)
    … …  
    5348        return false;
    5449
    55     if (event->target() == m_owner)
     50    if (event->target() == &m_owner)
    5651        event->setTarget(0);
    5752
    … …  
    6459}
    6560
    66 bool GenericEventQueue::cancelEvent(Event* event)
    67 {
    68     bool found = m_pendingEvents.contains(event);
    69 
    70     if (found)
    71         m_pendingEvents.remove(m_pendingEvents.find(event));
    72 
    73     if (m_pendingEvents.isEmpty())
    74         m_timer.stop();
    75 
    76     return found;
    77 }
    78 
    7961void GenericEventQueue::timerFired(Timer<GenericEventQueue>*)
    8062{
    … …  
    8264    ASSERT(!m_pendingEvents.isEmpty());
    8365
    84     Vector<RefPtr<Event> > pendingEvents;
     66    Vector<RefPtr<Event>> pendingEvents;
    8567    m_pendingEvents.swap(pendingEvents);
    8668
    87     RefPtr<EventTarget> protect(m_owner);
     69    RefPtr<EventTarget> protect(&m_owner);
    8870    for (unsigned i = 0; i < pendingEvents.size(); ++i) {
    89         EventTarget* target = pendingEvents[i]->target() ? pendingEvents[i]->target() : m_owner;
    90         target->dispatchEvent(pendingEvents[i].release());
     71        EventTarget& target = pendingEvents[i]->target() ? *pendingEvents[i]->target() : m_owner;
     72        target.dispatchEvent(pendingEvents[i].release());
    9173    }
    9274}

  • trunk/Source/WebCore/dom/GenericEventQueue.h

    r128572 r155356  
    2727#define GenericEventQueue_h
    2828
    29 #include "EventQueue.h"
    30 #include "EventTarget.h"
    3129#include "Timer.h"
    32 #include <wtf/PassOwnPtr.h>
     30#include <wtf/Forward.h>
    3331#include <wtf/RefPtr.h>
    3432#include <wtf/Vector.h>
    … …  
    3634namespace WebCore {
    3735
    38 class GenericEventQueue : public EventQueue {
    39     WTF_MAKE_FAST_ALLOCATED;
     36class Event;
     37class EventTarget;
     38
     39class GenericEventQueue {
    4040public:
    41     explicit GenericEventQueue(EventTarget*);
    42     static PassOwnPtr<GenericEventQueue> create(EventTarget*);
    43     virtual ~GenericEventQueue();
     41    explicit GenericEventQueue(EventTarget&);
     42    ~GenericEventQueue();
    4443
    45     // EventQueue
    46     virtual bool enqueueEvent(PassRefPtr<Event>) OVERRIDE;
    47     virtual bool cancelEvent(Event*) OVERRIDE;
    48     virtual void close() OVERRIDE;
     44    bool enqueueEvent(PassRefPtr<Event>);
     45    void close();
    4946
    5047    void cancelAllEvents();
    … …  
    5451    void timerFired(Timer<GenericEventQueue>*);
    5552
    56     EventTarget* m_owner;
    57     Vector<RefPtr<Event> > m_pendingEvents;
     53    EventTarget& m_owner;
     54    Vector<RefPtr<Event>> m_pendingEvents;
    5855    Timer<GenericEventQueue> m_timer;
    59 
    6056    bool m_isClosed;
    6157};

  • trunk/Source/WebCore/dom/ScriptExecutionContext.h

    r155304 r155356  
    151151    virtual double timerAlignmentInterval() const;
    152152
    153     virtual EventQueue* eventQueue() const = 0;
     153    virtual EventQueue& eventQueue() const = 0;
    154154
    155155#if ENABLE(SQL_DATABASE)

  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r155277 r155356  
    259259    , m_playbackProgressTimer(this, &HTMLMediaElement::playbackProgressTimerFired)
    260260    , m_playedTimeRanges()
    261     , m_asyncEventQueue(GenericEventQueue::create(this))
     261    , m_asyncEventQueue(*this)
    262262    , m_playbackRate(1.0f)
    263263    , m_defaultPlaybackRate(1.0f)
    … …  
    353353    LOG(Media, "HTMLMediaElement::~HTMLMediaElement");
    354354
    355     m_asyncEventQueue->close();
     355    m_asyncEventQueue.close();
    356356
    357357    if (m_isWaitingUntilMediaCanStart)
    … …  
    705705    // will trigger an ASSERT if this element has been marked for deletion.
    706706
    707     m_asyncEventQueue->enqueueEvent(event.release());
     707    m_asyncEventQueue.enqueueEvent(event.release());
    708708}
    709709
    … …  
    13261326            event = Event::create(eventNames().enterEvent, false, false);
    13271327            event->setTarget(eventTasks[i].second);
    1328             m_asyncEventQueue->enqueueEvent(event.release());
     1328            m_asyncEventQueue.enqueueEvent(event.release());
    13291329
    13301330            event = Event::create(eventNames().exitEvent, false, false);
    13311331            event->setTarget(eventTasks[i].second);
    1332             m_asyncEventQueue->enqueueEvent(event.release());
     1332            m_asyncEventQueue.enqueueEvent(event.release());
    13331333        } else {
    13341334            if (eventTasks[i].first == eventTasks[i].second->startTime())
    … …  
    13381338
    13391339            event->setTarget(eventTasks[i].second);
    1340             m_asyncEventQueue->enqueueEvent(event.release());
     1340            m_asyncEventQueue.enqueueEvent(event.release());
    13411341        }
    13421342    }
    … …  
    13521352        event->setTarget(affectedTracks[i]);
    13531353
    1354         m_asyncEventQueue->enqueueEvent(event.release());
     1354        m_asyncEventQueue.enqueueEvent(event.release());
    13551355
    13561356        // ... if the text track has a corresponding track element, to then fire a
    … …  
    13621362            event->setTarget(trackElement);
    13631363           
    1364             m_asyncEventQueue->enqueueEvent(event.release());
     1364            m_asyncEventQueue.enqueueEvent(event.release());
    13651365        }
    13661366    }
    … …  
    16541654{
    16551655    LOG(Media, "HTMLMediaElement::cancelPendingEventsAndCallbacks");
    1656     m_asyncEventQueue->cancelAllEvents();
     1656    m_asyncEventQueue.cancelAllEvents();
    16571657
    16581658    auto sourceChildren = childrenOfType<HTMLSourceElement>(this);
    … …  
    19441944    RefPtr<Event> event = MediaKeyEvent::create(eventNames().webkitkeyaddedEvent, initializer);
    19451945    event->setTarget(this);
    1946     m_asyncEventQueue->enqueueEvent(event.release());
     1946    m_asyncEventQueue.enqueueEvent(event.release());
    19471947}
    19481948
    … …  
    19811981    RefPtr<Event> event = MediaKeyEvent::create(eventNames().webkitkeyerrorEvent, initializer);
    19821982    event->setTarget(this);
    1983     m_asyncEventQueue->enqueueEvent(event.release());
     1983    m_asyncEventQueue.enqueueEvent(event.release());
    19841984}
    19851985
    … …  
    19961996    RefPtr<Event> event = MediaKeyEvent::create(eventNames().webkitkeymessageEvent, initializer);
    19971997    event->setTarget(this);
    1998     m_asyncEventQueue->enqueueEvent(event.release());
     1998    m_asyncEventQueue.enqueueEvent(event.release());
    19991999}
    20002000
    … …  
    20162016    RefPtr<Event> event = MediaKeyEvent::create(eventNames().webkitneedkeyEvent, initializer);
    20172017    event->setTarget(this);
    2018     m_asyncEventQueue->enqueueEvent(event.release());
     2018    m_asyncEventQueue.enqueueEvent(event.release());
    20192019    return true;
    20202020}
    … …  
    20372037    RefPtr<Event> event = MediaKeyNeededEvent::create(eventNames().webkitneedkeyEvent, initializer);
    20382038    event->setTarget(this);
    2039     m_asyncEventQueue->enqueueEvent(event.release());
     2039    m_asyncEventQueue.enqueueEvent(event.release());
    20402040
    20412041    return true;
    … …  
    41804180    cancelPendingEventsAndCallbacks();
    41814181
    4182     m_asyncEventQueue->close();
     4182    m_asyncEventQueue.close();
    41834183
    41844184    // Once an active DOM object has been stopped it can not be restarted, so we can deallocate
    … …  
    42394239bool HTMLMediaElement::hasPendingActivity() const
    42404240{
    4241     return (hasAudio() && isPlaying()) || m_asyncEventQueue->hasPendingEvents();
     4241    return (hasAudio() && isPlaying()) || m_asyncEventQueue.hasPendingEvents();
    42424242}
    42434243

  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r154970 r155356  
    627627    Timer<HTMLMediaElement> m_playbackProgressTimer;
    628628    RefPtr<TimeRanges> m_playedTimeRanges;
    629     OwnPtr<GenericEventQueue> m_asyncEventQueue;
     629    GenericEventQueue m_asyncEventQueue;
    630630
    631631    double m_playbackRate;

  • trunk/Source/WebCore/page/EventHandler.cpp

    r155344 r155356  
    38673867    setFrameWasScrolledByUser();
    38683868    if (m_frame.view() && m_frame.document())
    3869         m_frame.document()->eventQueue()->enqueueOrDispatchScrollEvent(m_frame.document(), DocumentEventQueue::ScrollEventDocumentTarget);
     3869        m_frame.document()->eventQueue().enqueueOrDispatchScrollEvent(*m_frame.document());
    38703870}
    38713871

  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r155301 r155356  
    22642264    // Schedule the scroll DOM event.
    22652265    if (Node* node = renderer().node())
    2266         node->document().eventQueue()->enqueueOrDispatchScrollEvent(renderer().node(), DocumentEventQueue::ScrollEventElementTarget);
     2266        node->document().eventQueue().enqueueOrDispatchScrollEvent(*node);
    22672267
    22682268    InspectorInstrumentation::didScrollLayer(&frame);

  • trunk/Source/WebCore/rendering/RenderListBox.cpp

    r154877 r155356  
    646646    m_indexOffset = newOffset;
    647647    repaint();
    648     node()->document().eventQueue()->enqueueOrDispatchScrollEvent(node(), DocumentEventQueue::ScrollEventElementTarget);
     648    node()->document().eventQueue().enqueueOrDispatchScrollEvent(*node());
    649649}
    650650

  • trunk/Source/WebCore/workers/WorkerEventQueue.cpp

    r130612 r155356  
    3636namespace WebCore {
    3737
    38 PassOwnPtr<WorkerEventQueue> WorkerEventQueue::create(ScriptExecutionContext* context)
    39 {
    40     return adoptPtr(new WorkerEventQueue(context));
    41 }
    42 
    43 WorkerEventQueue::WorkerEventQueue(ScriptExecutionContext* context)
     38WorkerEventQueue::WorkerEventQueue(ScriptExecutionContext& context)
    4439    : m_scriptExecutionContext(context)
    4540    , m_isClosed(false)
    … …  
    5247}
    5348
    54 class WorkerEventQueue::EventDispatcherTask : public ScriptExecutionContext::Task {
     49class WorkerEventQueue::EventDispatcherTask FINAL : public ScriptExecutionContext::Task {
    5550public:
    56     static PassOwnPtr<EventDispatcherTask> create(PassRefPtr<Event> event, WorkerEventQueue* eventQueue)
     51    static PassOwnPtr<EventDispatcherTask> create(PassRefPtr<Event> event, WorkerEventQueue& eventQueue)
    5752    {
    5853        return adoptPtr(new EventDispatcherTask(event, eventQueue));
    … …  
    6257    {
    6358        if (m_event)
    64             m_eventQueue->removeEvent(m_event.get());
     59            m_eventQueue.m_eventTaskMap.remove(m_event.get());
    6560    }
    6661
    … …  
    7065    }
    7166
    72     virtual void performTask(ScriptExecutionContext* context)
     67    virtual void performTask(ScriptExecutionContext* context) OVERRIDE
    7368    {
    7469        if (m_isCancelled)
    7570            return;
    76         m_eventQueue->removeEvent(m_event.get());
     71        m_eventQueue.m_eventTaskMap.remove(m_event.get());
    7772        dispatchEvent(context, m_event);
    7873        m_event.clear();
    … …  
    8681
    8782private:
    88     EventDispatcherTask(PassRefPtr<Event> event, WorkerEventQueue* eventQueue)
     83    EventDispatcherTask(PassRefPtr<Event> event, WorkerEventQueue& eventQueue)
    8984        : m_event(event)
    9085        , m_eventQueue(eventQueue)
    … …  
    9489
    9590    RefPtr<Event> m_event;
    96     WorkerEventQueue* m_eventQueue;
     91    WorkerEventQueue& m_eventQueue;
    9792    bool m_isCancelled;
    9893};
    99 
    100 void WorkerEventQueue::removeEvent(Event* event)
    101 {
    102     m_eventTaskMap.remove(event);
    103 }
    10494
    10595bool WorkerEventQueue::enqueueEvent(PassRefPtr<Event> prpEvent)
    … …  
    10898        return false;
    10999    RefPtr<Event> event = prpEvent;
    110     OwnPtr<EventDispatcherTask> task = EventDispatcherTask::create(event, this);
     100    OwnPtr<EventDispatcherTask> task = EventDispatcherTask::create(event, *this);
    111101    m_eventTaskMap.add(event.release(), task.get());
    112     m_scriptExecutionContext->postTask(task.release());
     102    m_scriptExecutionContext.postTask(task.release());
    113103    return true;
    114104}
    115105
    116 bool WorkerEventQueue::cancelEvent(Event* event)
     106bool WorkerEventQueue::cancelEvent(Event& event)
    117107{
    118     EventDispatcherTask* task = m_eventTaskMap.get(event);
     108    EventDispatcherTask* task = m_eventTaskMap.take(&event);
    119109    if (!task)
    120110        return false;
    121111    task->cancel();
    122     removeEvent(event);
    123112    return true;
    124113}

  • trunk/Source/WebCore/workers/WorkerEventQueue.h

    r128572 r155356  
    3030#include "EventQueue.h"
    3131#include <wtf/HashMap.h>
    32 #include <wtf/HashSet.h>
    3332#include <wtf/PassOwnPtr.h>
    34 #include <wtf/RefCounted.h>
    3533
    3634namespace WebCore {
    3735
    38 class Event;
    39 class Node;
    4036class ScriptExecutionContext;
    4137
    42 class WorkerEventQueue : public EventQueue {
    43     WTF_MAKE_FAST_ALLOCATED;
     38class WorkerEventQueue FINAL : public EventQueue {
    4439public:
    45 
    46     static PassOwnPtr<WorkerEventQueue> create(ScriptExecutionContext*);
     40    explicit WorkerEventQueue(ScriptExecutionContext&);
    4741    virtual ~WorkerEventQueue();
    4842
    49     // EventQueue
    5043    virtual bool enqueueEvent(PassRefPtr<Event>) OVERRIDE;
    51     virtual bool cancelEvent(Event*) OVERRIDE;
     44    virtual bool cancelEvent(Event&) OVERRIDE;
    5245    virtual void close() OVERRIDE;
    5346
    5447private:
    55     explicit WorkerEventQueue(ScriptExecutionContext*);
    56     void removeEvent(Event*);
    57 
    58     ScriptExecutionContext* m_scriptExecutionContext;
     48    ScriptExecutionContext& m_scriptExecutionContext;
    5949    bool m_isClosed;
    6050

  • trunk/Source/WebCore/workers/WorkerGlobalScope.cpp

    r155304 r155356  
    9595#endif
    9696    , m_closing(false)
    97     , m_eventQueue(WorkerEventQueue::create(this))
     97    , m_eventQueue(*this)
    9898    , m_topOrigin(topOrigin)
    9999{
    … …  
    366366}
    367367
    368 WorkerEventQueue* WorkerGlobalScope::eventQueue() const
    369 {
    370     return m_eventQueue.get();
     368WorkerEventQueue& WorkerGlobalScope::eventQueue() const
     369{
     370    return m_eventQueue;
    371371}
    372372

  • trunk/Source/WebCore/workers/WorkerGlobalScope.h

    r155304 r155356  
    105105        void clearInterval(int timeoutId);
    106106
    107         // ScriptExecutionContext
    108         virtual WorkerEventQueue* eventQueue() const OVERRIDE;
    109 
    110107        virtual bool isContextThread() const OVERRIDE;
    111108        virtual bool isJSExecutionForbidden() const OVERRIDE;
    … …  
    163160        virtual EventTarget* errorEventTarget() OVERRIDE;
    164161
     162        virtual WorkerEventQueue& eventQueue() const OVERRIDE FINAL;
     163
    165164        KURL m_url;
    166165        String m_userAgent;
    … …  
    181180        HashSet<Observer*> m_workerObservers;
    182181
    183         OwnPtr<WorkerEventQueue> m_eventQueue;
     182        mutable WorkerEventQueue m_eventQueue;
    184183
    185184        RefPtr<SecurityOrigin> m_topOrigin;
Note: See TracChangeset for help on using the changeset viewer.