Remove WorkerEventQueue::EventDispatcherTask

third_party/WebKit/Source/core/workers/WorkerEventQueue.cpp

Index: third_party/WebKit/Source/core/workers/WorkerEventQueue.cpp
diff --git a/third_party/WebKit/Source/core/workers/WorkerEventQueue.cpp b/third_party/WebKit/Source/core/workers/WorkerEventQueue.cpp
index 0439a3da8f8fcef4204f908dba6beb191a900759..94e74bcd192020440692a57f4f8c735930a8daf0 100644
--- a/third_party/WebKit/Source/core/workers/WorkerEventQueue.cpp
+++ b/third_party/WebKit/Source/core/workers/WorkerEventQueue.cpp
@@ -30,7 +30,6 @@
 #include "core/dom/ExecutionContextTask.h"
 #include "core/events/Event.h"
 #include "core/inspector/InspectorInstrumentation.h"
-#include "wtf/PtrUtil.h"
 
 namespace blink {
 
@@ -47,98 +46,58 @@ WorkerEventQueue::WorkerEventQueue(ExecutionContext* context)
 
 WorkerEventQueue::~WorkerEventQueue()
 {
-    DCHECK(m_eventTaskMap.isEmpty());
+    DCHECK(m_pendingEvents.isEmpty());
 }
 
 DEFINE_TRACE(WorkerEventQueue)
 {
     visitor->trace(m_executionContext);
-    visitor->trace(m_eventTaskMap);
+    visitor->trace(m_pendingEvents);
     EventQueue::trace(visitor);
 }
 
-class WorkerEventQueue::EventDispatcherTask : public ExecutionContextTask {
-public:
-    static std::unique_ptr<EventDispatcherTask> create(Event* event, WorkerEventQueue* eventQueue)
-    {
-        return wrapUnique(new EventDispatcherTask(event, eventQueue));
-    }
-
-    ~EventDispatcherTask() override
-    {
-        if (m_event) {
-            InspectorInstrumentation::asyncTaskCanceled(m_event->target()->getExecutionContext(), m_event);
-            m_eventQueue->m_eventTaskMap.remove(m_event);
-        }
-    }
-
-    void dispatchEvent(ExecutionContext* context, Event* event)
-    {
-        InspectorInstrumentation::AsyncTask asyncTask(context, event);
-        event->target()->dispatchEvent(event);
-    }
-
-    virtual void performTask(ExecutionContext* context)
-    {
-        if (m_isCancelled)
-            return;
-
-        m_eventQueue->m_eventTaskMap.remove(m_event.get());
-        dispatchEvent(context, m_event);
-        m_event.clear();
-    }
-
-    void cancel()
-    {
-        m_isCancelled = true;
-        m_event.clear();
-    }
-
-private:
-    EventDispatcherTask(Event* event, WorkerEventQueue* eventQueue)
-        : m_event(event)
-        , m_eventQueue(eventQueue)
-        , m_isCancelled(false)
-    {
-    }
-
-    Persistent<Event> m_event;
-    Persistent<WorkerEventQueue> m_eventQueue;
-    bool m_isCancelled;
-};
-
 bool WorkerEventQueue::enqueueEvent(Event* event)
 {
     if (m_isClosed)
         return false;
     InspectorInstrumentation::asyncTaskScheduled(event->target()->getExecutionContext(), event->type(), event);
-    std::unique_ptr<EventDispatcherTask> task = EventDispatcherTask::create(event, this);
-    m_eventTaskMap.add(event, task.get());
-    m_executionContext->postTask(BLINK_FROM_HERE, std::move(task));
+    m_pendingEvents.add(event);
+    m_executionContext->postTask(BLINK_FROM_HERE, createSameThreadTask(&WorkerEventQueue::dispatchEvent, wrapPersistent(this), wrapWeakPersistent(event)));
     return true;
 }
 
 bool WorkerEventQueue::cancelEvent(Event* event)
 {
-    EventDispatcherTask* task = m_eventTaskMap.get(event);
-    if (!task)
+    if (!removeEvent(event))
         return false;
-    task->cancel();
     InspectorInstrumentation::asyncTaskCanceled(event->target()->getExecutionContext(), event);
-    m_eventTaskMap.remove(event);
     return true;
 }
 
 void WorkerEventQueue::close()
 {
     m_isClosed = true;
-    for (const auto& entry : m_eventTaskMap) {
-        Event* event = entry.key.get();
-        EventDispatcherTask* task = entry.value;
+    for (const auto& event : m_pendingEvents)
         InspectorInstrumentation::asyncTaskCanceled(event->target()->getExecutionContext(), event);
-        task->cancel();
-    }
-    m_eventTaskMap.clear();
+    m_pendingEvents.clear();
+}
+
+bool WorkerEventQueue::removeEvent(Event* event)
+{
+    auto found = m_pendingEvents.find(event);
+    if (found == m_pendingEvents.end())
+        return false;
+    m_pendingEvents.remove(found);
+    return true;
+}
+
+void WorkerEventQueue::dispatchEvent(Event* event, ExecutionContext* executionContext)
+{
+    if (!event || !removeEvent(event))
+        return;
+
+    InspectorInstrumentation::AsyncTask asyncTask(executionContext, event);
+    event->target()->dispatchEvent(event);
 }
 
 } // namespace blink