Remove WorkerEventQueue::EventDispatcherTask

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

 /*
  * Copyright (C) 2010 Google Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
 
 #include "core/workers/WorkerEventQueue.h"
 
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/events/Event.h"
 #include "core/inspector/InspectorInstrumentation.h"
-#include "wtf/PtrUtil.h"
 
 namespace blink {
 
 WorkerEventQueue* WorkerEventQueue::create(ExecutionContext* context)
 {
     return new WorkerEventQueue(context);
 }
 
 WorkerEventQueue::WorkerEventQueue(ExecutionContext* context)
     : m_executionContext(context)
     , m_isClosed(false)
 {
 }
 
 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