Move text track active list management to CueTimeline

Source/core/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 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
@@ skipping 35 matching lines @@
 #include "core/html/HTMLSourceElement.h"
 #include "core/html/HTMLTrackElement.h"
 #include "core/html/MediaController.h"
 #include "core/html/MediaError.h"
 #include "core/html/MediaFragmentURIParser.h"
 #include "core/html/TimeRanges.h"
 #include "core/html/shadow/MediaControls.h"
 #include "core/html/track/AudioTrack.h"
 #include "core/html/track/AudioTrackList.h"
 #include "core/html/track/AutomaticTrackSelection.h"
+#include "core/html/track/CueTimeline.h"
 #include "core/html/track/InbandTextTrack.h"
-#include "core/html/track/TextTrackCueList.h"
 #include "core/html/track/TextTrackList.h"
 #include "core/html/track/VideoTrack.h"
 #include "core/html/track/VideoTrackList.h"
 #include "core/layout/compositing/LayerCompositor.h"
 #include "core/loader/FrameLoader.h"
 #include "core/rendering/RenderVideo.h"
 #include "core/rendering/RenderView.h"
 #include "platform/ContentType.h"
 #include "platform/Logging.h"
 #include "platform/MIMETypeFromURL.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebContentDecryptionModule.h"
 #include "public/platform/WebInbandTextTrack.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/MathExtras.h"
-#include "wtf/NonCopyingSort.h"
 #include "wtf/text/CString.h"
 #include <limits>
 
 #if ENABLE(WEB_AUDIO)
 #include "platform/audio/AudioSourceProvider.h"
 #include "platform/audio/AudioSourceProviderClient.h"
 #endif
 
 using blink::WebInbandTextTrack;
 using blink::WebMediaPlayer;
@@ skipping 53 matching lines @@
 
 static void removeElementFromDocumentMap(HTMLMediaElement* element, Document* document)
 {
     DocumentElementSetMap& map = documentToElementSetMap();
     WeakMediaElementSet set = map.take(document);
     set.remove(element);
     if (!set.isEmpty())
         map.add(document, set);
 }
 
-class TrackDisplayUpdateScope {
-    STACK_ALLOCATED();
-public:
-    TrackDisplayUpdateScope(HTMLMediaElement* mediaElement)
-    {
-        m_mediaElement = mediaElement;
-        m_mediaElement->beginIgnoringTrackDisplayUpdateRequests();
-    }
-    ~TrackDisplayUpdateScope()
-    {
-        ASSERT(m_mediaElement);
-        m_mediaElement->endIgnoringTrackDisplayUpdateRequests();
-    }
-
-private:
-    RawPtrWillBeMember<HTMLMediaElement> m_mediaElement;
-};
-
 class AudioSourceProviderClientLockScope {
     STACK_ALLOCATED();
 public:
 #if ENABLE(WEB_AUDIO)
     AudioSourceProviderClientLockScope(HTMLMediaElement& element)
         : m_client(element.audioSourceNode())
     {
         if (m_client)
             m_client->lock();
     }
@@ skipping 188 matching lines @@
     , m_havePreparedToPlay(false)
     , m_tracksAreReady(true)
     , m_haveVisibleTextTrack(false)
     , m_processingPreferenceChange(false)
     , m_remoteRoutesAvailable(false)
     , m_playingRemotely(false)
 #if ENABLE(OILPAN)
     , m_isFinalizing(false)
     , m_closeMediaSourceWhenFinalizing(false)
 #endif
-    , m_lastTextTrackUpdateTime(-1)
     , m_initialPlayWithoutUserGestures(false)
     , m_autoplayMediaCounted(false)
     , m_audioTracks(AudioTrackList::create(*this))
     , m_videoTracks(VideoTrackList::create(*this))
     , m_textTracks(nullptr)
-    , m_ignoreTrackDisplayUpdate(0)
 #if ENABLE(WEB_AUDIO)
     , m_audioSourceNode(nullptr)
 #endif
 {
     ASSERT(RuntimeEnabledFeatures::mediaEnabled());
 
     WTF_LOG(Media, "HTMLMediaElement::HTMLMediaElement(%p)", this);
 
     if (document.settings() && document.settings()->mediaPlaybackRequiresUserGesture())
         m_userGestureRequiredForPlay = true;
@@ skipping 416 matching lines @@
 
         // 4.8 - Set the initial playback position to 0.
         // FIXME: Make this less subtle. The position only becomes 0 because the ready state is HAVE_NOTHING.
         invalidateCachedTime();
 
         // 4.9 - Set the timeline offset to Not-a-Number (NaN).
         // 4.10 - Update the duration attribute to Not-a-Number (NaN).
 
 
         updateMediaController();
-        updateActiveTextTrackCues(0);
+        cueTimeline().updateActiveCues(0);
     }
 
     // 5 - Set the playbackRate attribute to the value of the defaultPlaybackRate attribute.
     setPlaybackRate(defaultPlaybackRate());
 
     // 6 - Set the error attribute to null and the autoplaying flag to true.
     m_error = nullptr;
     m_autoplaying = true;
 
     // 7 - Invoke the media element's resource selection algorithm.
@@ skipping 301 matching lines @@
 {
     if (m_mediaSource)
         return WebMediaPlayer::LoadTypeMediaSource;
 
     if (isMediaStreamURL(m_currentSrc.string()))
         return WebMediaPlayer::LoadTypeMediaStream;
 
     return WebMediaPlayer::LoadTypeURL;
 }
 
-static bool trackIndexCompare(TextTrack* a,
-                              TextTrack* b)
-{
-    return a->trackIndex() - b->trackIndex() < 0;
-}
-
-static bool eventTimeCueCompare(const std::pair<double, TextTrackCue*>& a,
-                                const std::pair<double, TextTrackCue*>& b)
-{
-    // 12 - Sort the tasks in events in ascending time order (tasks with earlier
-    // times first).
-    if (a.first != b.first)
-        return a.first - b.first < 0;
-
-    // If the cues belong to different text tracks, it doesn't make sense to
-    // compare the two tracks by the relative cue order, so return the relative
-    // track order.
-    if (a.second->track() != b.second->track())
-        return trackIndexCompare(a.second->track(), b.second->track());
-
-    // 12 - Further sort tasks in events that have the same time by the
-    // relative text track cue order of the text track cues associated
-    // with these tasks.
-    return a.second->cueIndex() - b.second->cueIndex() < 0;
-}
-
-
-void HTMLMediaElement::updateActiveTextTrackCues(double movieTime)
-{
-    // 4.8.10.8 Playing the media resource
-
-    //  If the current playback position changes while the steps are running,
-    //  then the user agent must wait for the steps to complete, and then must
-    //  immediately rerun the steps.
-    if (ignoreTrackDisplayUpdateRequests())
-        return;
-
-    // 1 - Let current cues be a list of cues, initialized to contain all the
-    // cues of all the hidden, showing, or showing by default text tracks of the
-    // media element (not the disabled ones) whose start times are less than or
-    // equal to the current playback position and whose end times are greater
-    // than the current playback position.
-    CueList currentCues;
-
-    // The user agent must synchronously unset [the text track cue active] flag
-    // whenever ... the media element's readyState is changed back to HAVE_NOTHING.
-    if (m_readyState != HAVE_NOTHING && m_player)
-        currentCues = m_cueTree.allOverlaps(m_cueTree.createInterval(movieTime, movieTime));
-
-    CueList previousCues;
-    CueList missedCues;
-
-    // 2 - Let other cues be a list of cues, initialized to contain all the cues
-    // of hidden, showing, and showing by default text tracks of the media
-    // element that are not present in current cues.
-    previousCues = m_currentlyActiveCues;
-
-    // 3 - Let last time be the current playback position at the time this
-    // algorithm was last run for this media element, if this is not the first
-    // time it has run.
-    double lastTime = m_lastTextTrackUpdateTime;
-
-    // 4 - If the current playback position has, since the last time this
-    // algorithm was run, only changed through its usual monotonic increase
-    // during normal playback, then let missed cues be the list of cues in other
-    // cues whose start times are greater than or equal to last time and whose
-    // end times are less than or equal to the current playback position.
-    // Otherwise, let missed cues be an empty list.
-    if (lastTime >= 0 && m_lastSeekTime < movieTime) {
-        CueList potentiallySkippedCues =
-            m_cueTree.allOverlaps(m_cueTree.createInterval(lastTime, movieTime));
-
-        for (CueInterval cue : potentiallySkippedCues) {
-            // Consider cues that may have been missed since the last seek time.
-            if (cue.low() > std::max(m_lastSeekTime, lastTime) && cue.high() < movieTime)
-                missedCues.append(cue);
-        }
-    }
-
-    m_lastTextTrackUpdateTime = movieTime;
-
-    // 5 - If the time was reached through the usual monotonic increase of the
-    // current playback position during normal playback, and if the user agent
-    // has not fired a timeupdate event at the element in the past 15 to 250ms
-    // and is not still running event handlers for such an event, then the user
-    // agent must queue a task to fire a simple event named timeupdate at the
-    // element. (In the other cases, such as explicit seeks, relevant events get
-    // fired as part of the overall process of changing the current playback
-    // position.)
-    if (!m_seeking && m_lastSeekTime < lastTime)
-        scheduleTimeupdateEvent(true);
-
-    // Explicitly cache vector sizes, as their content is constant from here.
-    size_t currentCuesSize = currentCues.size();
-    size_t missedCuesSize = missedCues.size();
-    size_t previousCuesSize = previousCues.size();
-
-    // 6 - If all of the cues in current cues have their text track cue active
-    // flag set, none of the cues in other cues have their text track cue active
-    // flag set, and missed cues is empty, then abort these steps.
-    bool activeSetChanged = missedCuesSize;
-
-    for (size_t i = 0; !activeSetChanged && i < previousCuesSize; ++i) {
-        if (!currentCues.contains(previousCues[i]) && previousCues[i].data()->isActive())
-            activeSetChanged = true;
-    }
-
-    for (CueInterval currentCue : currentCues) {
-        currentCue.data()->updateDisplayTree(movieTime);
-
-        if (!currentCue.data()->isActive())
-            activeSetChanged = true;
-    }
-
-    if (!activeSetChanged)
-        return;
-
-    // 7 - If the time was reached through the usual monotonic increase of the
-    // current playback position during normal playback, and there are cues in
-    // other cues that have their text track cue pause-on-exi flag set and that
-    // either have their text track cue active flag set or are also in missed
-    // cues, then immediately pause the media element.
-    for (size_t i = 0; !m_paused && i < previousCuesSize; ++i) {
-        if (previousCues[i].data()->pauseOnExit()
-            && previousCues[i].data()->isActive()
-            && !currentCues.contains(previousCues[i]))
-            pause();
-    }
-
-    for (size_t i = 0; !m_paused && i < missedCuesSize; ++i) {
-        if (missedCues[i].data()->pauseOnExit())
-            pause();
-    }
-
-    // 8 - Let events be a list of tasks, initially empty. Each task in this
-    // list will be associated with a text track, a text track cue, and a time,
-    // which are used to sort the list before the tasks are queued.
-    WillBeHeapVector<std::pair<double, RawPtrWillBeMember<TextTrackCue>>> eventTasks;
-
-    // 8 - Let affected tracks be a list of text tracks, initially empty.
-    WillBeHeapVector<RawPtrWillBeMember<TextTrack>> affectedTracks;
-
-    for (size_t i = 0; i < missedCuesSize; ++i) {
-        // 9 - For each text track cue in missed cues, prepare an event named enter
-        // for the TextTrackCue object with the text track cue start time.
-        eventTasks.append(std::make_pair(missedCues[i].data()->startTime(),
-                                         missedCues[i].data()));
-
-        // 10 - For each text track [...] in missed cues, prepare an event
-        // named exit for the TextTrackCue object with the  with the later of
-        // the text track cue end time and the text track cue start time.
-
-        // Note: An explicit task is added only if the cue is NOT a zero or
-        // negative length cue. Otherwise, the need for an exit event is
-        // checked when these tasks are actually queued below. This doesn't
-        // affect sorting events before dispatch either, because the exit
-        // event has the same time as the enter event.
-        if (missedCues[i].data()->startTime() < missedCues[i].data()->endTime())
-            eventTasks.append(std::make_pair(missedCues[i].data()->endTime(),
-                                             missedCues[i].data()));
-    }
-
-    for (size_t i = 0; i < previousCuesSize; ++i) {
-        // 10 - For each text track cue in other cues that has its text
-        // track cue active flag set prepare an event named exit for the
-        // TextTrackCue object with the text track cue end time.
-        if (!currentCues.contains(previousCues[i]))
-            eventTasks.append(std::make_pair(previousCues[i].data()->endTime(),
-                                             previousCues[i].data()));
-    }
-
-    for (size_t i = 0; i < currentCuesSize; ++i) {
-        // 11 - For each text track cue in current cues that does not have its
-        // text track cue active flag set, prepare an event named enter for the
-        // TextTrackCue object with the text track cue start time.
-        if (!previousCues.contains(currentCues[i]))
-            eventTasks.append(std::make_pair(currentCues[i].data()->startTime(),
-                                             currentCues[i].data()));
-    }
-
-    // 12 - Sort the tasks in events in ascending time order (tasks with earlier
-    // times first).
-    nonCopyingSort(eventTasks.begin(), eventTasks.end(), eventTimeCueCompare);
-
-    for (size_t i = 0; i < eventTasks.size(); ++i) {
-        if (!affectedTracks.contains(eventTasks[i].second->track()))
-            affectedTracks.append(eventTasks[i].second->track());
-
-        // 13 - Queue each task in events, in list order.
-        RefPtrWillBeRawPtr<Event> event = nullptr;
-
-        // Each event in eventTasks may be either an enterEvent or an exitEvent,
-        // depending on the time that is associated with the event. This
-        // correctly identifies the type of the event, if the startTime is
-        // less than the endTime in the cue.
-        if (eventTasks[i].second->startTime() >= eventTasks[i].second->endTime()) {
-            event = Event::create(EventTypeNames::enter);
-            event->setTarget(eventTasks[i].second);
-            m_asyncEventQueue->enqueueEvent(event.release());
-
-            event = Event::create(EventTypeNames::exit);
-            event->setTarget(eventTasks[i].second);
-            m_asyncEventQueue->enqueueEvent(event.release());
-        } else {
-            if (eventTasks[i].first == eventTasks[i].second->startTime())
-                event = Event::create(EventTypeNames::enter);
-            else
-                event = Event::create(EventTypeNames::exit);
-
-            event->setTarget(eventTasks[i].second);
-            m_asyncEventQueue->enqueueEvent(event.release());
-        }
-    }
-
-    // 14 - Sort affected tracks in the same order as the text tracks appear in
-    // the media element's list of text tracks, and remove duplicates.
-    nonCopyingSort(affectedTracks.begin(), affectedTracks.end(), trackIndexCompare);
-
-    // 15 - For each text track in affected tracks, in the list order, queue a
-    // task to fire a simple event named cuechange at the TextTrack object, and, ...
-    for (size_t i = 0; i < affectedTracks.size(); ++i) {
-        RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::cuechange);
-        event->setTarget(affectedTracks[i]);
-
-        m_asyncEventQueue->enqueueEvent(event.release());
-
-        // ... if the text track has a corresponding track element, to then fire a
-        // simple event named cuechange at the track element as well.
-        if (affectedTracks[i]->trackType() == TextTrack::TrackElement) {
-            RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::cuechange);
-            HTMLTrackElement* trackElement = static_cast<LoadableTextTrack*>(affectedTracks[i].get())->trackElement();
-            ASSERT(trackElement);
-            event->setTarget(trackElement);
-
-            m_asyncEventQueue->enqueueEvent(event.release());
-        }
-    }
-
-    // 16 - Set the text track cue active flag of all the cues in the current
-    // cues, and unset the text track cue active flag of all the cues in the
-    // other cues.
-    for (size_t i = 0; i < currentCuesSize; ++i)
-        currentCues[i].data()->setIsActive(true);
-
-    for (size_t i = 0; i < previousCuesSize; ++i) {
-        if (!currentCues.contains(previousCues[i]))
-            previousCues[i].data()->setIsActive(false);
-    }
-
-    // Update the current active cues.
-    m_currentlyActiveCues = currentCues;
-
-    if (activeSetChanged)
-        updateTextTrackDisplay();
-}
-
 bool HTMLMediaElement::textTracksAreReady() const
 {
     // 4.8.10.12.1 Text track model
     // ...
     // The text tracks of a media element are ready if all the text tracks whose mode was not
     // in the disabled state when the element's resource selection algorithm last started now
     // have a text track readiness state of loaded or failed to load.
     for (unsigned i = 0; i < m_textTracksWhenResourceSelectionBegan.size(); ++i) {
         if (m_textTracksWhenResourceSelectionBegan[i]->readinessState() == TextTrack::Loading
             || m_textTracksWhenResourceSelectionBegan[i]->readinessState() == TextTrack::NotLoaded)
@@ skipping 27 matching lines @@
         // run the following algorithm ...
 
         for (HTMLTrackElement* trackElement = Traversal<HTMLTrackElement>::firstChild(*this); trackElement; trackElement = Traversal<HTMLTrackElement>::nextSibling(*trackElement)) {
             if (trackElement->track() != track)
                 continue;
 
             // Mark this track as "configured" so configureTextTracks won't change the mode again.
             track->setHasBeenConfigured(true);
             if (track->mode() != TextTrack::disabledKeyword()) {
                 if (trackElement->readyState() == HTMLTrackElement::LOADED)
-                    textTrackAddCues(track, track->cues());
+                    cueTimeline().addCues(track, track->cues());
 
                 // If this is the first added track, create the list of text tracks.
                 if (!m_textTracks)
                     m_textTracks = TextTrackList::create(this);
             }
             break;
         }
     } else if (track->trackType() == TextTrack::AddTrack && track->mode() != TextTrack::disabledKeyword()) {
-        textTrackAddCues(track, track->cues());
+        cueTimeline().addCues(track, track->cues());
     }
 
     configureTextTrackDisplay(AssumeVisibleChange);
 
     ASSERT(textTracks()->contains(track));
     textTracks()->scheduleChangeEvent();
 }
 
 void HTMLMediaElement::textTrackKindChanged(TextTrack* track)
 {
     if (track->kind() != TextTrack::captionsKeyword() && track->kind() != TextTrack::subtitlesKeyword() && track->mode() == TextTrack::showingKeyword())
         track->setMode(TextTrack::hiddenKeyword());
 }
 
-void HTMLMediaElement::beginIgnoringTrackDisplayUpdateRequests()
-{
-    ++m_ignoreTrackDisplayUpdate;
-}
-
-void HTMLMediaElement::endIgnoringTrackDisplayUpdateRequests()
-{
-    ASSERT(m_ignoreTrackDisplayUpdate);
-    --m_ignoreTrackDisplayUpdate;
-    if (!m_ignoreTrackDisplayUpdate && inActiveDocument())
-        updateActiveTextTrackCues(currentTime());
-}
-
-void HTMLMediaElement::textTrackAddCues(TextTrack* track, const TextTrackCueList* cues)
-{
-    WTF_LOG(Media, "HTMLMediaElement::textTrackAddCues(%p)", this);
-    ASSERT(track->mode() != TextTrack::disabledKeyword());
-
-    TrackDisplayUpdateScope scope(this);
-    for (size_t i = 0; i < cues->length(); ++i)
-        textTrackAddCue(cues->item(i)->track(), cues->item(i));
-}
-
-void HTMLMediaElement::textTrackRemoveCues(TextTrack*, const TextTrackCueList* cues)
-{
-    WTF_LOG(Media, "HTMLMediaElement::textTrackRemoveCues(%p)", this);
-
-    TrackDisplayUpdateScope scope(this);
-    for (size_t i = 0; i < cues->length(); ++i)
-        textTrackRemoveCue(cues->item(i)->track(), cues->item(i));
-}
-
-void HTMLMediaElement::textTrackAddCue(TextTrack* track, PassRefPtrWillBeRawPtr<TextTrackCue> cue)
-{
-    ASSERT(track->mode() != TextTrack::disabledKeyword());
-
-    // Negative duration cues need be treated in the interval tree as
-    // zero-length cues.
-    double endTime = std::max(cue->startTime(), cue->endTime());
-
-    CueInterval interval = m_cueTree.createInterval(cue->startTime(), endTime, cue.get());
-    if (!m_cueTree.contains(interval))
-        m_cueTree.add(interval);
-    updateActiveTextTrackCues(currentTime());
-}
-
-void HTMLMediaElement::textTrackRemoveCue(TextTrack*, PassRefPtrWillBeRawPtr<TextTrackCue> cue)
-{
-    // Negative duration cues need to be treated in the interval tree as
-    // zero-length cues.
-    double endTime = std::max(cue->startTime(), cue->endTime());
-
-    CueInterval interval = m_cueTree.createInterval(cue->startTime(), endTime, cue.get());
-    m_cueTree.remove(interval);
-
-    // Since the cue will be removed from the media element and likely the
-    // TextTrack might also be destructed, notifying the region of the cue
-    // removal shouldn't be done.
-    cue->notifyRegionWhenRemovingDisplayTree(false);
-
-    size_t index = m_currentlyActiveCues.find(interval);
-    if (index != kNotFound) {
-        m_currentlyActiveCues.remove(index);
-        cue->setIsActive(false);
-    }
-    cue->removeDisplayTree();
-    updateActiveTextTrackCues(currentTime());
-
-    cue->notifyRegionWhenRemovingDisplayTree(true);
-}
-
-
 bool HTMLMediaElement::isSafeToLoadURL(const KURL& url, InvalidURLAction actionIfInvalid)
 {
     if (!url.isValid()) {
         WTF_LOG(Media, "HTMLMediaElement::isSafeToLoadURL(%p, %s) -> FALSE because url is invalid", this, urlForLoggingMedia(url).utf8().data());
         return false;
     }
 
     LocalFrame* frame = document().frame();
     if (!frame || !document().securityOrigin()->canDisplay(url)) {
         if (actionIfInvalid == Complain)
@@ skipping 370 matching lines @@
     }
 
     if (shouldUpdateDisplayState) {
         updateDisplayState();
         if (hasMediaControls())
             mediaControls()->refreshClosedCaptionsButtonVisibility();
     }
 
     updatePlayState();
     updateMediaController();
-    updateActiveTextTrackCues(currentTime());
+    cueTimeline().updateActiveCues(currentTime());
 }
 
 void HTMLMediaElement::progressEventTimerFired(Timer<HTMLMediaElement>*)
 {
     ASSERT(m_player);
     if (m_networkState != NETWORK_LOADING)
         return;
 
     double time = WTF::currentTime();
     double timedelta = time - m_previousProgressTime;
@@ skipping 568 matching lines @@
 
     if (!m_seeking)
         scheduleTimeupdateEvent(true);
 
     if (!effectivePlaybackRate())
         return;
 
     if (!m_paused && hasMediaControls())
         mediaControls()->playbackProgressed();
 
-    updateActiveTextTrackCues(currentTime());
+    cueTimeline().updateActiveCues(currentTime());
 }
 
 void HTMLMediaElement::scheduleTimeupdateEvent(bool periodicEvent)
 {
     double now = WTF::currentTime();
     double movieTime = currentTime();
 
     bool haveNotRecentlyFiredTimeupdate = (now - m_lastTimeUpdateEventWallTime) >= maxTimeupdateEventFrequency;
     bool movieTimeHasProgressed = movieTime != m_lastTimeUpdateEventMovieTime;
 
@@ skipping 189 matching lines @@
 
 void HTMLMediaElement::addTextTrack(TextTrack* track)
 {
     textTracks()->append(track);
 
     textTracksChanged();
 }
 
 void HTMLMediaElement::removeTextTrack(TextTrack* track)
 {
-    TrackDisplayUpdateScope scope(this);
+    TrackDisplayUpdateScope scope(this->cueTimeline());
     m_textTracks->remove(track);
 
     textTracksChanged();
 }
 
 void HTMLMediaElement::forgetResourceSpecificTracks()
 {
     // Implements the "forget the media element's media-resource-specific tracks" algorithm.
     // The order is explicitly specified as text, then audio, and finally video. Also
     // 'removetrack' events should not be fired.
     if (m_textTracks) {
-        TrackDisplayUpdateScope scope(this);
+        TrackDisplayUpdateScope scope(this->cueTimeline());
         m_textTracks->removeAllInbandTracks();
         textTracksChanged();
     }
 
     m_audioTracks->removeAll();
     m_videoTracks->removeAll();
 
     m_audioTracksTimer.stop();
 }
 
@@ skipping 284 matching lines @@
         // inserted in a video or audio element will have no effect.
         m_currentSourceNode = nullptr;
         WTF_LOG(Media, "HTMLMediaElement::sourceRemoved(%p) - m_currentSourceNode set to 0", this);
     }
 }
 
 void HTMLMediaElement::mediaPlayerTimeChanged()
 {
     WTF_LOG(Media, "HTMLMediaElement::mediaPlayerTimeChanged(%p)", this);
 
-    updateActiveTextTrackCues(currentTime());
+    cueTimeline().updateActiveCues(currentTime());
 
     invalidateCachedTime();
 
     // 4.8.10.9 steps 12-14. Needed if no ReadyState change is associated with the seek.
     if (m_seeking && m_readyState >= HAVE_CURRENT_DATA && !webMediaPlayer()->seeking())
         finishSeek();
 
     // Always call scheduleTimeupdateEvent when the media engine reports a time discontinuity,
     // it will only queue a 'timeupdate' event if we haven't already posted one at the current
     // movie time.
@@ skipping 323 matching lines @@
     // 5 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
     // 6 - Abort the overall resource selection algorithm.
     m_currentSourceNode = nullptr;
 
     // Reset m_readyState since m_player is gone.
     m_readyState = HAVE_NOTHING;
     invalidateCachedTime();
     updateMediaController();
-    updateActiveTextTrackCues(0);
+    cueTimeline().updateActiveCues(0);
 }
 
 void HTMLMediaElement::clearMediaPlayerAndAudioSourceProviderClientWithoutLocking()
 {
 #if ENABLE(WEB_AUDIO)
     if (audioSourceProvider())
         audioSourceProvider()->setClient(0);
 #endif
     m_player.clear();
 }
@@ skipping 278 matching lines @@
     }
 
     ensureMediaControls();
     mediaControls()->reset();
     if (shouldShowControls())
         mediaControls()->show();
     else
         mediaControls()->hide();
 }
 
+CueTimeline& HTMLMediaElement::cueTimeline()
+{
+    if (!m_cueTimeline)
+        m_cueTimeline = adoptPtrWillBeNoop(new CueTimeline(*this));
+    return *m_cueTimeline;
+}
+
 void HTMLMediaElement::configureTextTrackDisplay(VisibilityChangeAssumption assumption)
 {
     ASSERT(m_textTracks);
     WTF_LOG(Media, "HTMLMediaElement::configureTextTrackDisplay(%p)", this);
 
     if (m_processingPreferenceChange)
         return;
 
     bool haveVisibleTextTrack = false;
     for (unsigned i = 0; i < m_textTracks->length(); ++i) {
         if (m_textTracks->item(i)->mode() == TextTrack::showingKeyword()) {
             haveVisibleTextTrack = true;
             break;
         }
     }
 
     if (assumption == AssumeNoVisibleChange
         && m_haveVisibleTextTrack == haveVisibleTextTrack) {
-        updateActiveTextTrackCues(currentTime());
+        cueTimeline().updateActiveCues(currentTime());
         return;
     }
     m_haveVisibleTextTrack = haveVisibleTextTrack;
     m_closedCaptionsVisible = m_haveVisibleTextTrack;
 
     if (!m_haveVisibleTextTrack && !hasMediaControls())
         return;
 
     ensureMediaControls();
     mediaControls()->changedClosedCaptionsVisibility();
 
-    updateActiveTextTrackCues(currentTime());
+    cueTimeline().updateActiveCues(currentTime());
     updateTextTrackDisplay();
 }
 
 void* HTMLMediaElement::preDispatchEventHandler(Event* event)
 {
     if (event && event->type() == EventTypeNames::webkitfullscreenchange)
         configureMediaControls();
 
     return nullptr;
 }
@@ skipping 189 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_playedTimeRanges);
     visitor->trace(m_asyncEventQueue);
     visitor->trace(m_error);
     visitor->trace(m_currentSourceNode);
     visitor->trace(m_nextChildNodeToConsider);
     visitor->trace(m_mediaSource);
     visitor->trace(m_audioTracks);
     visitor->trace(m_videoTracks);
+    visitor->trace(m_cueTimeline);
     visitor->trace(m_textTracks);
     visitor->trace(m_textTracksWhenResourceSelectionBegan);
     visitor->trace(m_mediaController);
 #if ENABLE(WEB_AUDIO)
     visitor->registerWeakMembers<HTMLMediaElement, &HTMLMediaElement::clearWeakMembers>(this);
 #endif
     HeapSupplementable<HTMLMediaElement>::trace(visitor);
 #endif
     HTMLElement::trace(visitor);
     ActiveDOMObject::trace(visitor);
@@ skipping 29 matching lines @@
 
 #if ENABLE(WEB_AUDIO)
 void HTMLMediaElement::clearWeakMembers(Visitor* visitor)
 {
     if (!visitor->isAlive(m_audioSourceNode) && audioSourceProvider())
         audioSourceProvider()->setClient(nullptr);
 }
 #endif
 
 }