Source/WebCore/dom/GenericEventQueue.cpp

   1 /*
   2  * Copyright (C) 2012 Victor Carbune (victor@rosedu.org)
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "GenericEventQueue.h"
  28
  29 #include "Event.h"
  30 #include "EventTarget.h"
  31 #include "Timer.h"
  32 #include <wtf/MainThread.h>
  33 #include <wtf/NeverDestroyed.h>
  34
  35 namespace WebCore {
  36
  37 GenericEventQueue::GenericEventQueue(EventTarget& owner)
  38     : m_owner(owner)
  39     , m_weakPtrFactory(this)
  40     , m_isClosed(false)
  41 {
  42 }
  43
  44 GenericEventQueue::~GenericEventQueue()
  45 {
  46 }
  47
  48 void GenericEventQueue::enqueueEvent(RefPtr<Event>&& event)
  49 {
  50     if (m_isClosed)
  51         return;
  52
  53     if (event->target() == &m_owner)
  54         event->setTarget(nullptr);
  55
  56     m_pendingEvents.append(WTFMove(event));
  57
  58     if (m_isSuspended)
  59         return;
  60
  61     pendingQueues().append(m_weakPtrFactory.createWeakPtr());
  62     if (!sharedTimer().isActive())
  63         sharedTimer().startOneShot(0);
  64 }
  65
  66 Timer& GenericEventQueue::sharedTimer()
  67 {
  68     ASSERT(isMainThread());
  69     static NeverDestroyed<Timer> timer(GenericEventQueue::sharedTimerFired);
  70     return timer.get();
  71 }
  72
  73 void GenericEventQueue::sharedTimerFired()
  74 {
  75     ASSERT(!sharedTimer().isActive());
  76     ASSERT(!pendingQueues().isEmpty());
  77
  78     while (!pendingQueues().isEmpty()) {
  79         WeakPtr<GenericEventQueue> queue = pendingQueues().takeFirst();
  80         if (!queue)
  81             continue;
  82         queue->dispatchOneEvent();
  83     }
  84
  85     if (sharedTimer().isActive())
  86         sharedTimer().stop();
  87 }
  88
  89 Deque<WeakPtr<GenericEventQueue>>& GenericEventQueue::pendingQueues()
  90 {
  91     ASSERT(isMainThread());
  92     static NeverDestroyed<Deque<WeakPtr<GenericEventQueue>>> queues;
  93     return queues.get();
  94 }
  95
  96 void GenericEventQueue::dispatchOneEvent()
  97 {
  98     ASSERT(!m_pendingEvents.isEmpty());
  99
 100     Ref<EventTarget> protect(m_owner);
 101     RefPtr<Event> event = m_pendingEvents.takeFirst();
 102     EventTarget& target = event->target() ? *event->target() : m_owner;
 103     target.dispatchEvent(*event);
 104 }
 105
 106 void GenericEventQueue::close()
 107 {
 108     m_isClosed = true;
 109
 110     m_weakPtrFactory.revokeAll();
 111     m_pendingEvents.clear();
 112 }
 113
 114 void GenericEventQueue::cancelAllEvents()
 115 {
 116     m_weakPtrFactory.revokeAll();
 117     m_pendingEvents.clear();
 118 }
 119
 120 bool GenericEventQueue::hasPendingEvents() const
 121 {
 122     return !m_pendingEvents.isEmpty();
 123 }
 124
 125 void GenericEventQueue::suspend()
 126 {
 127     ASSERT(!m_isSuspended);
 128     m_isSuspended = true;
 129     m_weakPtrFactory.revokeAll();
 130 }
 131
 132 void GenericEventQueue::resume()
 133 {
 134     if (!m_isSuspended)
 135         return;
 136
 137     m_isSuspended = false;
 138
 139     if (m_pendingEvents.isEmpty())
 140         return;
 141
 142     for (unsigned i = 0; i < m_pendingEvents.size(); ++i)
 143         pendingQueues().append(m_weakPtrFactory.createWeakPtr());
 144
 145     if (!sharedTimer().isActive())
 146         sharedTimer().startOneShot(0);
 147 }
 148
 149 }