Move text track active list management to CueTimeline

Source/core/html/HTMLMediaElement.h

 /*
  * 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 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef HTMLMediaElement_h
 #define HTMLMediaElement_h
 
 #include "core/dom/ActiveDOMObject.h"
 #include "core/events/GenericEventQueue.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/track/TextTrack.h"
-#include "core/html/track/TextTrackCue.h"
-#include "core/html/track/vtt/VTTCue.h"
-#include "platform/PODIntervalTree.h"
 #include "platform/Supplementable.h"
 #include "platform/graphics/media/MediaPlayer.h"
 #include "public/platform/WebMediaPlayerClient.h"
 #include "public/platform/WebMimeRegistry.h"
 
 namespace blink {
 class WebInbandTextTrack;
 class WebLayer;
 }
 
 namespace blink {
 
 #if ENABLE(WEB_AUDIO)
 class AudioSourceProvider;
 class AudioSourceProviderClient;
 #endif
 class AudioTrackList;
 class ContentType;
+class CueTimeline;
 class Event;
 class ExceptionState;
 class HTMLSourceElement;
 class HTMLTrackElement;
 class KURL;
 class MediaController;
 class MediaControls;
 class MediaError;
 class HTMLMediaSource;
 class TextTrackList;
 class TimeRanges;
 class URLRegistry;
 class VideoTrackList;
 
-typedef PODIntervalTree<double, TextTrackCue*> CueIntervalTree;
-typedef CueIntervalTree::IntervalType CueInterval;
-typedef Vector<CueInterval> CueList;
-
 // FIXME: The inheritance from MediaPlayerClient here should be private inheritance.
 // But it can't be until the Chromium WebMediaPlayerClientImpl class is fixed so it
 // no longer depends on typecasting a MediaPlayerClient to an HTMLMediaElement.
 
 class HTMLMediaElement : public HTMLElement, public WillBeHeapSupplementable<HTMLMediaElement>, public MediaPlayerClient, public ActiveDOMObject {
     DEFINE_WRAPPERTYPEINFO();
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(HTMLMediaElement);
 public:
     static blink::WebMimeRegistry::SupportsType supportsType(const ContentType&, const String& keySystem = String());
 
@@ skipping 89 matching lines @@
 
     AudioTrackList& audioTracks();
     void audioTrackChanged();
 
     VideoTrackList& videoTracks();
     void selectedVideoTrackChanged(blink::WebMediaPlayer::TrackId*);
 
     PassRefPtrWillBeRawPtr<TextTrack> addTextTrack(const AtomicString& kind, const AtomicString& label, const AtomicString& language, ExceptionState&);
 
     TextTrackList* textTracks();
-    CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
+    CueTimeline& cueTimeline();
 
     void addTextTrack(TextTrack*);
     void removeTextTrack(TextTrack*);
     void textTracksChanged();
     void notifyMediaPlayerOfTextTrackChanges();
 
     // Implements the "forget the media element's media-resource-specific tracks" algorithm in the HTML5 spec.
     void forgetResourceSpecificTracks();
 
     void didAddTrackElement(HTMLTrackElement*);
@@ skipping 11 matching lines @@
 
     void honorUserPreferencesForAutomaticTextTrackSelection();
 
     bool textTracksAreReady() const;
     enum VisibilityChangeAssumption {
         AssumeNoVisibleChange,
         AssumeVisibleChange
     };
     void configureTextTrackDisplay(VisibilityChangeAssumption);
     void updateTextTrackDisplay();
+    double lastSeekTime() const { return m_lastSeekTime; }
     void textTrackReadyStateChanged(TextTrack*);
 
     void textTrackKindChanged(TextTrack*);
     void textTrackModeChanged(TextTrack*);
-    void textTrackAddCues(TextTrack*, const TextTrackCueList*);
-    void textTrackRemoveCues(TextTrack*, const TextTrackCueList*);
-    void textTrackAddCue(TextTrack*, PassRefPtrWillBeRawPtr<TextTrackCue>);
-    void textTrackRemoveCue(TextTrack*, PassRefPtrWillBeRawPtr<TextTrackCue>);
 
     // EventTarget function.
     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
     // causes an ambiguity error at compile time. This class's constructor
     // ensures that both implementations return document, so return the result
     // of one of them here.
     using HTMLElement::executionContext;
 
     bool hasSingleSecurityOrigin() const { return !m_player || (webMediaPlayer() && webMediaPlayer()->hasSingleSecurityOrigin()); }
 
@@ skipping 29 matching lines @@
     bool isSafeToLoadURL(const KURL&, InvalidURLAction);
 
     // Checks to see if current media data is CORS-same-origin as the
     // specified origin.
     bool isMediaDataCORSSameOrigin(SecurityOrigin*) const;
 
     MediaController* controller() const;
     void setController(PassRefPtrWillBeRawPtr<MediaController>); // Resets the MediaGroup and sets the MediaController.
 
     void scheduleEvent(PassRefPtrWillBeRawPtr<Event>);
+    void scheduleTimeupdateEvent(bool periodicEvent);
 
     // Returns the "effective media volume" value as specified in the HTML5 spec.
     double effectiveMediaVolume() const;
 
 #if ENABLE(OILPAN)
     bool isFinalizing() const { return m_isFinalizing; }
 
     // Oilpan: finalization of the media element is observable from its
     // attached MediaSource; it entering a closed state.
     //
@@ skipping 18 matching lines @@
     virtual void attach(const AttachContext& = AttachContext()) override;
 
     virtual void didMoveToNewDocument(Document& oldDocument) override;
 
     enum DisplayMode { Unknown, Poster, Video };
     DisplayMode displayMode() const { return m_displayMode; }
     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
 
     void setControllerInternal(PassRefPtrWillBeRawPtr<MediaController>);
 
-    bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0; }
-    void beginIgnoringTrackDisplayUpdateRequests();
-    void endIgnoringTrackDisplayUpdateRequests();
-
 private:
     void createMediaPlayer();
 
     virtual bool alwaysCreateUserAgentShadowRoot() const override final { return true; }
     virtual bool areAuthorShadowsAllowed() const override final { return false; }
 
     virtual bool supportsFocus() const override final;
     virtual bool isMouseFocusable() const override final;
     virtual bool rendererIsNeeded(const LayoutStyle&) override;
     virtual LayoutObject* createRenderer(const LayoutStyle&) override;
@@ skipping 32 matching lines @@
     void playbackProgressTimerFired(Timer<HTMLMediaElement>*);
     void startPlaybackProgressTimer();
     void startProgressEventTimer();
     void stopPeriodicTimers();
 
     void seek(double time);
     void finishSeek();
     void checkIfSeekNeeded();
     void addPlayedRange(double start, double end);
 
-    void scheduleTimeupdateEvent(bool periodicEvent);
     void scheduleEvent(const AtomicString& eventName); // FIXME: Rename to scheduleNamedEvent for clarity.
 
     // loading
     void prepareForLoad();
     void loadInternal();
     void selectMediaResource();
     void loadResource(const KURL&, ContentType&, const String& keySystem);
     void startPlayerLoad();
     void setPlayerPreload();
     blink::WebMediaPlayer::LoadType loadType() const;
@@ skipping 14 matching lines @@
     void mediaLoadingFailed(blink::WebMediaPlayer::NetworkState);
 
     // deferred loading (preload=none)
     bool loadIsDeferred() const;
     void deferLoad();
     void cancelDeferredLoad();
     void startDeferredLoad();
     void executeDeferredLoad();
     void deferredLoadTimerFired(Timer<HTMLMediaElement>*);
 
-    void updateActiveTextTrackCues(double);
     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
 
     void markCaptionAndSubtitleTracksAsUnconfigured();
 
     // This does not check user gesture restrictions.
     void playInternal();
 
     void gesturelessInitialPlayHalted();
     void autoplayMediaEncountered();
     void allowVideoRendering();
@@ skipping 142 matching lines @@
 
     bool m_tracksAreReady : 1;
     bool m_haveVisibleTextTrack : 1;
     bool m_processingPreferenceChange : 1;
     bool m_remoteRoutesAvailable : 1;
     bool m_playingRemotely : 1;
 #if ENABLE(OILPAN)
     bool m_isFinalizing : 1;
     bool m_closeMediaSourceWhenFinalizing : 1;
 #endif
-    double m_lastTextTrackUpdateTime;
     bool m_initialPlayWithoutUserGestures : 1;
     bool m_autoplayMediaCounted : 1;
 
     RefPtrWillBeMember<AudioTrackList> m_audioTracks;
     RefPtrWillBeMember<VideoTrackList> m_videoTracks;
     RefPtrWillBeMember<TextTrackList> m_textTracks;
     WillBeHeapVector<RefPtrWillBeMember<TextTrack>> m_textTracksWhenResourceSelectionBegan;
 
-    CueIntervalTree m_cueTree;
-
-    CueList m_currentlyActiveCues;
-    int m_ignoreTrackDisplayUpdate;
+    OwnPtrWillBeMember<CueTimeline> m_cueTimeline;
 
 #if ENABLE(WEB_AUDIO)
     // This is a weak reference, since m_audioSourceNode holds a reference to us.
     // FIXME: Oilpan: Consider making this a strongly traced pointer with oilpan where strong cycles are not a problem.
     GC_PLUGIN_IGNORE("http://crbug.com/404577")
     RawPtrWillBeWeakMember<AudioSourceProviderClient> m_audioSourceNode;
 #endif
 
     friend class MediaController;
     RefPtrWillBeMember<MediaController> m_mediaController;
 
     friend class Internals;
     friend class TrackDisplayUpdateScope;
 
     static URLRegistry* s_mediaStreamRegistry;
 };
 
-#ifndef NDEBUG
-// Template specializations required by PodIntervalTree in debug mode.
-template <>
-struct ValueToString<double> {
-    static String string(const double value)
-    {
-        return String::number(value);
-    }
-};
-
-template <>
-struct ValueToString<TextTrackCue*> {
-    static String string(TextTrackCue* const& cue)
-    {
-        return cue->toString();
-    }
-};
-#endif
-
 inline bool isHTMLMediaElement(const HTMLElement& element)
 {
     return isHTMLAudioElement(element) || isHTMLVideoElement(element);
 }
 
 DEFINE_HTMLELEMENT_TYPE_CASTS_WITH_FUNCTION(HTMLMediaElement);
 
 } // namespace blink
 
 #endif // HTMLMediaElement_h