Changeset 89657 in webkit


Ignore:
Timestamp:
Jun 24, 2011 1:24:16 AM (13 years ago)
Author:
pfeldman@chromium.org
Message:

2011-06-24 David Grogan <dgrogan@chromium.org>

Reviewed by Pavel Feldman.

Web Inspector: [REGRESSION r86838] line numbers do not scroll when script paused
https://bugs.webkit.org/show_bug.cgi?id=61653

roll out r86838

No new tests - refactoring.

  • dom/Document.h:
  • dom/EventQueue.cpp: (WebCore::EventQueueTimer::EventQueueTimer): (WebCore::EventQueueTimer::fired): (WebCore::EventQueue::create): (WebCore::EventQueue::EventQueue): (WebCore::EventQueue::~EventQueue): (WebCore::EventQueue::enqueueEvent): (WebCore::EventQueue::cancelEvent): (WebCore::EventQueue::cancelQueuedEvents): (WebCore::EventQueue::pendingEventTimerFired): (WebCore::EventQueue::dispatchEvent):
  • dom/EventQueue.h:
Location:
trunk/Source/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r89655 r89657  
     12011-06-24  David Grogan  <dgrogan@chromium.org>
     2
     3        Reviewed by Pavel Feldman.
     4
     5        Web Inspector: [REGRESSION r86838] line numbers do not scroll when script paused
     6        https://bugs.webkit.org/show_bug.cgi?id=61653
     7
     8        roll out r86838
     9
     10        No new tests - refactoring.
     11
     12        * dom/Document.h:
     13        * dom/EventQueue.cpp:
     14        (WebCore::EventQueueTimer::EventQueueTimer):
     15        (WebCore::EventQueueTimer::fired):
     16        (WebCore::EventQueue::create):
     17        (WebCore::EventQueue::EventQueue):
     18        (WebCore::EventQueue::~EventQueue):
     19        (WebCore::EventQueue::enqueueEvent):
     20        (WebCore::EventQueue::cancelEvent):
     21        (WebCore::EventQueue::cancelQueuedEvents):
     22        (WebCore::EventQueue::pendingEventTimerFired):
     23        (WebCore::EventQueue::dispatchEvent):
     24        * dom/EventQueue.h:
     25
    1262011-06-24  Sheriff Bot  <webkit.review.bot@gmail.com>
    227
  • trunk/Source/WebCore/dom/Document.h

    r89598 r89657  
    13591359    bool m_usingGeolocation;
    13601360
    1361     OwnPtr<EventQueue> m_eventQueue;
     1361    RefPtr<EventQueue> m_eventQueue;
    13621362
    13631363    RefPtr<DocumentWeakReference> m_weakReference;
  • trunk/Source/WebCore/dom/EventQueue.cpp

    r88980 r89657  
    3434#include "RuntimeApplicationChecks.h"
    3535#include "ScriptExecutionContext.h"
     36#include "SuspendableTimer.h"
    3637
    3738namespace WebCore {
     
    4344}
    4445
    45 PassOwnPtr<EventQueue> EventQueue::create(ScriptExecutionContext* context)
     46class EventQueueTimer : public SuspendableTimer {
     47    WTF_MAKE_NONCOPYABLE(EventQueueTimer);
     48public:
     49    EventQueueTimer(EventQueue* eventQueue, ScriptExecutionContext* context)
     50        : SuspendableTimer(context)
     51        , m_eventQueue(eventQueue) { }
     52
     53private:
     54    virtual void fired() { m_eventQueue->pendingEventTimerFired(); }
     55    EventQueue* m_eventQueue;   
     56};
     57
     58PassRefPtr<EventQueue> EventQueue::create(ScriptExecutionContext* context)
    4659{
    47     return adoptPtr(new EventQueue(context));
     60    return adoptRef(new EventQueue(context));
    4861}
    4962
    5063EventQueue::EventQueue(ScriptExecutionContext* context)
    51     : m_scriptExecutionContext(context)
     64    : m_pendingEventTimer(adoptPtr(new EventQueueTimer(this, context)))
    5265{
    5366}
     
    5568EventQueue::~EventQueue()
    5669{
    57     cancelQueuedEvents();
    5870}
    5971
    60 class EventQueue::EventDispatcherTask : public ScriptExecutionContext::Task {
    61 public:
    62     static PassOwnPtr<EventDispatcherTask> create(PassRefPtr<Event> event, EventQueue* eventQueue)
    63     {
    64         return adoptPtr(new EventDispatcherTask(event, eventQueue));
    65     }
    66 
    67     void dispatchEvent(ScriptExecutionContext*, PassRefPtr<Event> event)
    68     {
    69         EventTarget* eventTarget = event->target();
    70         if (eventTarget->toDOMWindow())
    71             eventTarget->toDOMWindow()->dispatchEvent(event, 0);
    72         else
    73             eventTarget->dispatchEvent(event);
    74     }
    75 
    76     virtual void performTask(ScriptExecutionContext* context)
    77     {
    78         if (m_isCancelled)
    79             return;
    80         m_eventQueue->removeEvent(m_event.get());
    81         dispatchEvent(context, m_event);
    82     }
    83 
    84     void cancel()
    85     {
    86         m_isCancelled = true;
    87         m_event.clear();
    88     }
    89 
    90 private:
    91     EventDispatcherTask(PassRefPtr<Event> event, EventQueue* eventQueue)
    92         : m_event(event)
    93         , m_eventQueue(eventQueue)
    94         , m_isCancelled(false)
    95     {
    96     }
    97 
    98     RefPtr<Event> m_event;
    99     EventQueue* m_eventQueue;
    100     bool m_isCancelled;
    101 };
    102 
    103 void EventQueue::removeEvent(Event* event)
     72void EventQueue::enqueueEvent(PassRefPtr<Event> event)
    10473{
    105     if (Node* node = event->target()->toNode())
    106         m_nodesWithQueuedScrollEvents.remove(node);
    107     m_eventTaskMap.remove(event);
    108 }
    109 
    110 void EventQueue::enqueueEvent(PassRefPtr<Event> prpEvent)
    111 {
    112     RefPtr<Event> event = prpEvent;
    113     OwnPtr<EventDispatcherTask> task = EventDispatcherTask::create(event, this);
    114     m_eventTaskMap.add(event.release(), task.get());
    115     m_scriptExecutionContext->postTask(task.release());
     74    ASSERT(event->target());
     75    bool wasAdded = m_queuedEvents.add(event).second;
     76    ASSERT_UNUSED(wasAdded, wasAdded); // It should not have already been in the list.
     77   
     78    if (!m_pendingEventTimer->isActive())
     79        m_pendingEventTimer->startOneShot(0);
    11680}
    11781
     
    139103bool EventQueue::cancelEvent(Event* event)
    140104{
    141     EventDispatcherTask* task = m_eventTaskMap.get(event);
    142     if (!task)
    143         return false;
    144     task->cancel();
    145     removeEvent(event);
    146     return true;
     105    bool found = m_queuedEvents.contains(event);
     106    m_queuedEvents.remove(event);
     107    if (m_queuedEvents.isEmpty())
     108        m_pendingEventTimer->stop();
     109    return found;
    147110}
    148111
    149112void EventQueue::cancelQueuedEvents()
    150113{
    151     for (EventTaskMap::iterator it = m_eventTaskMap.begin(); it != m_eventTaskMap.end(); ++it) {
    152         EventDispatcherTask* task = it->second;
    153         task->cancel();
     114    m_pendingEventTimer->stop();
     115    m_queuedEvents.clear();
     116}
     117
     118void EventQueue::pendingEventTimerFired()
     119{
     120    ASSERT(!m_pendingEventTimer->isActive());
     121    ASSERT(!m_queuedEvents.isEmpty());
     122
     123    m_nodesWithQueuedScrollEvents.clear();
     124
     125    // Insert a marker for where we should stop.
     126    ASSERT(!m_queuedEvents.contains(0));
     127    bool wasAdded = m_queuedEvents.add(0).second;
     128    ASSERT_UNUSED(wasAdded, wasAdded); // It should not have already been in the list.
     129
     130    RefPtr<EventQueue> protector(this);
     131
     132    while (!m_queuedEvents.isEmpty()) {
     133        ListHashSet<RefPtr<Event> >::iterator iter = m_queuedEvents.begin();
     134        RefPtr<Event> event = *iter;
     135        m_queuedEvents.remove(iter);
     136        if (!event)
     137            break;
     138        dispatchEvent(event.get());
    154139    }
    155     m_eventTaskMap.clear();
    156     m_nodesWithQueuedScrollEvents.clear();
     140}
     141
     142void EventQueue::dispatchEvent(PassRefPtr<Event> event)
     143{
     144    EventTarget* eventTarget = event->target();
     145    if (eventTarget->toDOMWindow())
     146        eventTarget->toDOMWindow()->dispatchEvent(event, 0);
     147    else
     148        eventTarget->dispatchEvent(event);
    157149}
    158150
  • trunk/Source/WebCore/dom/EventQueue.h

    r86838 r89657  
    2828#define EventQueue_h
    2929
    30 #include <wtf/HashMap.h>
    3130#include <wtf/HashSet.h>
    32 #include <wtf/PassOwnPtr.h>
     31#include <wtf/ListHashSet.h>
     32#include <wtf/OwnPtr.h>
     33#include <wtf/RefCounted.h>
     34#include <wtf/RefPtr.h>
    3335
    3436namespace WebCore {
    3537
    3638class Event;
     39class EventQueueTimer;
    3740class Node;
    3841class ScriptExecutionContext;
    3942
    40 class EventQueue {
     43class EventQueue : public RefCounted<EventQueue> {
    4144public:
    4245    enum ScrollEventTargetType {
     
    4548    };
    4649
    47     static PassOwnPtr<EventQueue> create(ScriptExecutionContext*);
     50    static PassRefPtr<EventQueue> create(ScriptExecutionContext*);
    4851    ~EventQueue();
    4952
     
    5659    explicit EventQueue(ScriptExecutionContext*);
    5760
    58     void removeEvent(Event*);
     61    void pendingEventTimerFired();
     62    void dispatchEvent(PassRefPtr<Event>);
    5963
     64    OwnPtr<EventQueueTimer> m_pendingEventTimer;
     65    ListHashSet<RefPtr<Event> > m_queuedEvents;
    6066    HashSet<Node*> m_nodesWithQueuedScrollEvents;
    61     ScriptExecutionContext* m_scriptExecutionContext;
    62 
    63     class EventDispatcherTask;
    64     typedef HashMap<RefPtr<Event>, EventDispatcherTask*> EventTaskMap;
    65     EventTaskMap m_eventTaskMap;
     67   
     68    friend class EventQueueTimer;   
    6669};
    6770
Note: See TracChangeset for help on using the changeset viewer.