Add "change" and "removetrack" events to TextTrackList.

Source/core/html/track/TextTrackList.cpp

 /*
  * Copyright (C) 2011, 2012 Apple 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 "config.h"
 #include "core/html/track/TextTrackList.h"
 
 #include "bindings/v8/ExceptionStatePlaceholder.h"
+#include "core/events/GenericEventQueue.h"
 #include "core/events/ThreadLocalEventNames.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/track/InbandTextTrack.h"
 #include "core/html/track/LoadableTextTrack.h"
 #include "core/html/track/TextTrack.h"
 #include "core/html/track/TrackEvent.h"
 
 using namespace WebCore;
 
 TextTrackList::TextTrackList(HTMLMediaElement* owner)
     : m_owner(owner)
-    , m_pendingEventTimer(this, &TextTrackList::asyncEventTimerFired)
-    , m_dispatchingEvents(0)
+    , m_asyncEventQueue(GenericEventQueue::create(this))
 {
     ScriptWrappable::init(this);
 }
 
 TextTrackList::~TextTrackList()
 {
+    m_asyncEventQueue->close();
 }
 
 unsigned TextTrackList::length() const
 {
     return m_addTrackTracks.size() + m_elementTracks.size() + m_inbandTracks.size();
 }
 
 int TextTrackList::getTrackIndex(TextTrack *textTrack)
 {
     if (textTrack->trackType() == TextTrack::TrackElement)
@@ skipping 160 matching lines @@
 
     invalidateTrackIndexesAfterTrack(track);
 
     ASSERT(track->mediaElement() == m_owner);
     track->setMediaElement(0);
 
     tracks->remove(index);
 
     if (inbandTrack)
         inbandTrack->trackRemoved();
+
+    scheduleRemoveTrackEvent(track);
 }
 
 bool TextTrackList::contains(TextTrack* track) const
 {
     const Vector<RefPtr<TextTrack> >* tracks = 0;
 
     if (track->trackType() == TextTrack::TrackElement)
         tracks = &m_elementTracks;
     else if (track->trackType() == TextTrack::AddTrack)
         tracks = &m_addTrackTracks;
     else if (track->trackType() == TextTrack::InBand)
         tracks = &m_inbandTracks;
     else
         ASSERT_NOT_REACHED();
 
     return tracks->find(track) != kNotFound;
 }
 
 const AtomicString& TextTrackList::interfaceName() const
 {
     return EventTargetNames::TextTrackList;
 }
 
 ExecutionContext* TextTrackList::executionContext() const
 {
     ASSERT(m_owner);
     return m_owner->executionContext();
 }
 
+void TextTrackList::scheduleTrackEvent(const AtomicString& eventName, PassRefPtr<TextTrack> track)
+{
+    TrackEventInit initializer;
+    initializer.track = track;
+    initializer.bubbles = false;
+    initializer.cancelable = false;
+
+    m_asyncEventQueue->enqueueEvent(TrackEvent::create(eventName, initializer));
+}
+
 void TextTrackList::scheduleAddTrackEvent(PassRefPtr<TextTrack> track)
 {
     // 4.8.10.12.3 Sourcing out-of-band text tracks
     // 4.8.10.12.4 Text track API
     // ... then queue a task to fire an event with the name addtrack, that does not
     // bubble and is not cancelable, and that uses the TrackEvent interface, with
     // the track attribute initialized to the text track's TextTrack object, at
     // the media element's textTracks attribute's TextTrackList object.
+    scheduleTrackEvent(EventTypeNames::addtrack, track);
+}
 
-    RefPtr<TextTrack> trackRef = track;
-    TrackEventInit initializer;
-    initializer.track = trackRef;
+void TextTrackList::scheduleChangeEvent()
+{
+    // 4.8.10.12.1 Text track model
+    // Whenever a text track that is in a media element's list of text tracks
+    // has its text track mode change value, the user agent must run the
+    // following steps for the media element:
+    // ...
+    // Fire a simple event named change at the media element's textTracks
+    // attribute's TextTrackList object.
+
+    EventInit initializer;
     initializer.bubbles = false;
     initializer.cancelable = false;
 
-    m_pendingEvents.append(TrackEvent::create(EventTypeNames::addtrack, initializer));
-    if (!m_pendingEventTimer.isActive())
-        m_pendingEventTimer.startOneShot(0);
+    m_asyncEventQueue->enqueueEvent(Event::create(EventTypeNames::change, initializer));
 }
 
-void TextTrackList::asyncEventTimerFired(Timer<TextTrackList>*)
+void TextTrackList::scheduleRemoveTrackEvent(PassRefPtr<TextTrack> track)
 {
-    Vector<RefPtr<Event> > pendingEvents;
-
-    ++m_dispatchingEvents;
-    m_pendingEvents.swap(pendingEvents);
-    size_t count = pendingEvents.size();
-    for (size_t index = 0; index < count; ++index)
-        dispatchEvent(pendingEvents[index].release(), IGNORE_EXCEPTION);
-    --m_dispatchingEvents;
+    // 4.8.10.12.3 Sourcing out-of-band text tracks
+    // When a track element's parent element changes and the old parent was a
+    // media element, then the user agent must remove the track element's
+    // corresponding text track from the media element's list of text tracks,
+    // and then queue a task to fire a trusted event with the name removetrack,
+    // that does not bubble and is not cancelable, and that uses the TrackEvent
+    // interface, with the track attribute initialized to the text track's
+    // TextTrack object, at the media element's textTracks attribute's
+    // TextTrackList object.
+    scheduleTrackEvent(EventTypeNames::removetrack, track);
 }
 
 Node* TextTrackList::owner() const
 {
     return m_owner;
 }