/*
 * 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
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "core/events/DOMWindowEventQueue.h"

#include "core/dom/TaskRunnerHelper.h"
#include "core/events/Event.h"
#include "core/frame/LocalDOMWindow.h"
#include "core/frame/SuspendableTimer.h"
#include "core/inspector/InspectorInstrumentation.h"

namespace blink {

class DOMWindowEventQueueTimer final
    : public GarbageCollectedFinalized<DOMWindowEventQueueTimer>,
      public SuspendableTimer {
  USING_GARBAGE_COLLECTED_MIXIN(DOMWindowEventQueueTimer);
  WTF_MAKE_NONCOPYABLE(DOMWindowEventQueueTimer);

 public:
  DOMWindowEventQueueTimer(DOMWindowEventQueue* eventQueue,
                           ExecutionContext* context)
      // This queue is unthrottled because throttling IndexedDB events may break
      // scenarios where several tabs, some of which are backgrounded, access
      // the same database concurrently.
      : SuspendableTimer(context, TaskType::Unthrottled),
        m_eventQueue(eventQueue) {}

  // Eager finalization is needed to promptly stop this timer object.
  // (see DOMTimer comment for more.)
  EAGERLY_FINALIZE();
  DEFINE_INLINE_VIRTUAL_TRACE() {
    visitor->trace(m_eventQueue);
    SuspendableTimer::trace(visitor);
  }

 private:
  virtual void fired() { m_eventQueue->pendingEventTimerFired(); }

  Member<DOMWindowEventQueue> m_eventQueue;
};

DOMWindowEventQueue* DOMWindowEventQueue::create(ExecutionContext* context) {
  return new DOMWindowEventQueue(context);
}

DOMWindowEventQueue::DOMWindowEventQueue(ExecutionContext* context)
    : m_pendingEventTimer(new DOMWindowEventQueueTimer(this, context)),
      m_isClosed(false) {
  m_pendingEventTimer->suspendIfNeeded();
}

DOMWindowEventQueue::~DOMWindowEventQueue() {}

DEFINE_TRACE(DOMWindowEventQueue) {
  visitor->trace(m_pendingEventTimer);
  visitor->trace(m_queuedEvents);
  EventQueue::trace(visitor);
}

bool DOMWindowEventQueue::enqueueEvent(Event* event) {
  if (m_isClosed)
    return false;

  DCHECK(event->target());
  InspectorInstrumentation::asyncTaskScheduled(
      event->target()->getExecutionContext(), event->type(), event);

  bool wasAdded = m_queuedEvents.add(event).isNewEntry;
  DCHECK(wasAdded);  // It should not have already been in the list.

  if (!m_pendingEventTimer->isActive())
    m_pendingEventTimer->startOneShot(0, BLINK_FROM_HERE);

  return true;
}

bool DOMWindowEventQueue::cancelEvent(Event* event) {
  HeapListHashSet<Member<Event>, 16>::iterator it = m_queuedEvents.find(event);
  bool found = it != m_queuedEvents.end();
  if (found) {
    InspectorInstrumentation::asyncTaskCanceled(
        event->target()->getExecutionContext(), event);
    m_queuedEvents.remove(it);
  }
  if (m_queuedEvents.isEmpty())
    m_pendingEventTimer->stop();
  return found;
}

void DOMWindowEventQueue::close() {
  m_isClosed = true;
  m_pendingEventTimer->stop();
  for (const auto& queuedEvent : m_queuedEvents) {
    if (queuedEvent)
      InspectorInstrumentation::asyncTaskCanceled(
          queuedEvent->target()->getExecutionContext(), queuedEvent);
  }
  m_queuedEvents.clear();
}

void DOMWindowEventQueue::pendingEventTimerFired() {
  DCHECK(!m_pendingEventTimer->isActive());
  DCHECK(!m_queuedEvents.isEmpty());

  // Insert a marker for where we should stop.
  DCHECK(!m_queuedEvents.contains(nullptr));
  bool wasAdded = m_queuedEvents.add(nullptr).isNewEntry;
  DCHECK(wasAdded);  // It should not have already been in the list.

  while (!m_queuedEvents.isEmpty()) {
    HeapListHashSet<Member<Event>, 16>::iterator iter = m_queuedEvents.begin();
    Event* event = *iter;
    m_queuedEvents.remove(iter);
    if (!event)
      break;
    dispatchEvent(event);
  }
}

void DOMWindowEventQueue::dispatchEvent(Event* event) {
  EventTarget* eventTarget = event->target();
  InspectorInstrumentation::AsyncTask asyncTask(
      eventTarget->getExecutionContext(), event);
  if (LocalDOMWindow* window = eventTarget->toLocalDOMWindow())
    window->dispatchEvent(event, nullptr);
  else
    eventTarget->dispatchEvent(event);
}

}  // namespace blink