1/*
2 * Copyright (C) 2007-2014 Apple Inc. All rights reserved.
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#ifndef HTMLMediaElement_h
27#define HTMLMediaElement_h
28
29#if ENABLE(VIDEO)
30#include "HTMLElement.h"
31#include "ActiveDOMObject.h"
32#include "GenericEventQueue.h"
33#include "HTMLMediaSession.h"
34#include "MediaCanStartListener.h"
35#include "MediaControllerInterface.h"
36#include "MediaPlayer.h"
37
38#if ENABLE(VIDEO_TRACK)
39#include "AudioTrack.h"
40#include "CaptionUserPreferences.h"
41#include "PODIntervalTree.h"
42#include "TextTrack.h"
43#include "TextTrackCue.h"
44#include "VTTCue.h"
45#include "VideoTrack.h"
46#endif
47
48#if ENABLE(MEDIA_STREAM)
49#include "MediaStream.h"
50#endif
51
52
53namespace WebCore {
54
55#if ENABLE(WEB_AUDIO)
56class AudioSourceProvider;
57class MediaElementAudioSourceNode;
58#endif
59class DisplaySleepDisabler;
60class Event;
61class HTMLSourceElement;
62class HTMLTrackElement;
63class URL;
64class MediaController;
65class MediaControls;
66class MediaControlsHost;
67class MediaError;
68class PageActivityAssertionToken;
69class TimeRanges;
70#if ENABLE(ENCRYPTED_MEDIA_V2)
71class MediaKeys;
72#endif
73#if ENABLE(MEDIA_SOURCE)
74class MediaSource;
75class SourceBuffer;
76class VideoPlaybackQuality;
77#endif
78
79#if ENABLE(VIDEO_TRACK)
80class AudioTrackList;
81class AudioTrackPrivate;
82class InbandTextTrackPrivate;
83class TextTrackList;
84class VideoTrackList;
85class VideoTrackPrivate;
86
87typedef PODIntervalTree<double, TextTrackCue*> CueIntervalTree;
88typedef CueIntervalTree::IntervalType CueInterval;
89typedef Vector<CueInterval> CueList;
90#endif
91
92class HTMLMediaElement
93    : public HTMLElement
94    , private MediaPlayerClient, public MediaPlayerSupportsTypeClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface , public MediaSessionClient
95#if ENABLE(VIDEO_TRACK)
96    , private AudioTrackClient
97    , private TextTrackClient
98    , private VideoTrackClient
99#endif
100#if USE(PLATFORM_TEXT_TRACK_MENU)
101    , public PlatformTextTrackMenuClient
102#endif
103{
104public:
105    MediaPlayer* player() const { return m_player.get(); }
106
107    virtual bool isVideo() const { return false; }
108    virtual bool hasVideo() const override { return false; }
109    virtual bool hasAudio() const override;
110
111    void rewind(double timeDelta);
112    virtual void returnToRealtime() override;
113
114    // Eventually overloaded in HTMLVideoElement
115    virtual bool supportsFullscreen() const override { return false; };
116
117    virtual bool supportsSave() const;
118    virtual bool supportsScanning() const override;
119
120    virtual bool doesHaveAttribute(const AtomicString&, AtomicString* value = nullptr) const override;
121
122    PlatformMedia platformMedia() const;
123    PlatformLayer* platformLayer() const;
124#if PLATFORM(IOS)
125    void setVideoFullscreenLayer(PlatformLayer*);
126    void setVideoFullscreenFrame(FloatRect);
127    void setVideoFullscreenGravity(MediaPlayer::VideoGravity);
128#endif
129
130    enum DelayedActionType {
131        LoadMediaResource = 1 << 0,
132        ConfigureTextTracks = 1 << 1,
133        TextTrackChangesNotification = 1 << 2,
134        ConfigureTextTrackDisplay = 1 << 3,
135    };
136    void scheduleDelayedAction(DelayedActionType);
137
138    MediaPlayer::MovieLoadType movieLoadType() const;
139
140    bool inActiveDocument() const { return m_inActiveDocument; }
141
142// DOM API
143// error state
144    PassRefPtr<MediaError> error() const;
145
146    void setSrc(const String&);
147    const URL& currentSrc() const { return m_currentSrc; }
148
149#if ENABLE(MEDIA_STREAM)
150    MediaStream* srcObject() const { return m_mediaStreamSrcObject.get(); }
151    void setSrcObject(MediaStream*);
152#endif
153
154// network state
155    enum NetworkState { NETWORK_EMPTY, NETWORK_IDLE, NETWORK_LOADING, NETWORK_NO_SOURCE };
156    NetworkState networkState() const;
157
158    String preload() const;
159    void setPreload(const String&);
160
161    virtual PassRefPtr<TimeRanges> buffered() const override;
162    void load();
163    String canPlayType(const String& mimeType, const String& keySystem = String(), const URL& = URL()) const;
164
165// ready state
166    virtual ReadyState readyState() const override;
167    bool seeking() const;
168
169// playback state
170    virtual double currentTime() const override;
171    virtual void setCurrentTime(double) override;
172    virtual void setCurrentTime(double, ExceptionCode&);
173    virtual double duration() const override;
174    virtual bool paused() const override;
175    virtual double defaultPlaybackRate() const override;
176    virtual void setDefaultPlaybackRate(double) override;
177    virtual double playbackRate() const override;
178    virtual void setPlaybackRate(double) override;
179    void updatePlaybackRate();
180    bool webkitPreservesPitch() const;
181    void setWebkitPreservesPitch(bool);
182    virtual PassRefPtr<TimeRanges> played() override;
183    virtual PassRefPtr<TimeRanges> seekable() const override;
184    bool ended() const;
185    bool autoplay() const;
186    bool loop() const;
187    void setLoop(bool b);
188    virtual void play() override;
189    virtual void pause() override;
190    virtual void setShouldBufferData(bool) override;
191    void fastSeek(double);
192    double minFastReverseRate() const;
193    double maxFastForwardRate() const;
194
195// captions
196    bool webkitHasClosedCaptions() const;
197    bool webkitClosedCaptionsVisible() const;
198    void setWebkitClosedCaptionsVisible(bool);
199
200    virtual bool elementIsHidden() const override { return m_elementIsHidden; }
201
202#if ENABLE(MEDIA_STATISTICS)
203// Statistics
204    unsigned webkitAudioDecodedByteCount() const;
205    unsigned webkitVideoDecodedByteCount() const;
206#endif
207
208#if ENABLE(MEDIA_SOURCE)
209//  Media Source.
210    void closeMediaSource();
211    void incrementDroppedFrameCount() { ++m_droppedVideoFrames; }
212    size_t maximumSourceBufferSize(const SourceBuffer&) const;
213#endif
214
215#if ENABLE(ENCRYPTED_MEDIA)
216    void webkitGenerateKeyRequest(const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionCode&);
217    void webkitGenerateKeyRequest(const String& keySystem, ExceptionCode&);
218    void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initData, const String& sessionId, ExceptionCode&);
219    void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, ExceptionCode&);
220    void webkitCancelKeyRequest(const String& keySystem, const String& sessionId, ExceptionCode&);
221
222    DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyadded);
223    DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyerror);
224    DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeymessage);
225#endif
226#if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
227    DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitneedkey);
228#endif
229
230#if ENABLE(ENCRYPTED_MEDIA_V2)
231    MediaKeys* keys() const { return m_mediaKeys.get(); }
232    void setMediaKeys(MediaKeys*);
233#endif
234
235// controls
236    bool controls() const;
237    void setControls(bool);
238    virtual double volume() const override;
239    virtual void setVolume(double, ExceptionCode&) override;
240    virtual bool muted() const override;
241    virtual void setMuted(bool) override;
242
243    void togglePlayState();
244    virtual void beginScrubbing() override;
245    virtual void endScrubbing() override;
246
247    virtual void beginScanning(ScanDirection) override;
248    virtual void endScanning() override;
249    double nextScanRate();
250
251    virtual bool canPlay() const override;
252
253    double percentLoaded() const;
254
255    DEFINE_ATTRIBUTE_EVENT_LISTENER(emptied);
256    DEFINE_ATTRIBUTE_EVENT_LISTENER(loadedmetadata);
257    DEFINE_ATTRIBUTE_EVENT_LISTENER(loadeddata);
258    DEFINE_ATTRIBUTE_EVENT_LISTENER(canplay);
259    DEFINE_ATTRIBUTE_EVENT_LISTENER(canplaythrough);
260    DEFINE_ATTRIBUTE_EVENT_LISTENER(playing);
261    DEFINE_ATTRIBUTE_EVENT_LISTENER(ended);
262    DEFINE_ATTRIBUTE_EVENT_LISTENER(waiting);
263    DEFINE_ATTRIBUTE_EVENT_LISTENER(durationchange);
264    DEFINE_ATTRIBUTE_EVENT_LISTENER(timeupdate);
265    DEFINE_ATTRIBUTE_EVENT_LISTENER(play);
266    DEFINE_ATTRIBUTE_EVENT_LISTENER(pause);
267    DEFINE_ATTRIBUTE_EVENT_LISTENER(ratechange);
268    DEFINE_ATTRIBUTE_EVENT_LISTENER(volumechange);
269
270#if ENABLE(VIDEO_TRACK)
271    PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
272    PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, ExceptionCode& ec) { return addTextTrack(kind, label, emptyString(), ec); }
273    PassRefPtr<TextTrack> addTextTrack(const String& kind, ExceptionCode& ec) { return addTextTrack(kind, emptyString(), emptyString(), ec); }
274
275    AudioTrackList* audioTracks();
276    TextTrackList* textTracks();
277    VideoTrackList* videoTracks();
278
279    CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
280
281    void addAudioTrack(PassRefPtr<AudioTrack>);
282    void addTextTrack(PassRefPtr<TextTrack>);
283    void addVideoTrack(PassRefPtr<VideoTrack>);
284    void removeAudioTrack(AudioTrack*);
285    void removeTextTrack(TextTrack*, bool scheduleEvent = true);
286    void removeVideoTrack(VideoTrack*);
287    void forgetResourceSpecificTracks();
288    void closeCaptionTracksChanged();
289    void notifyMediaPlayerOfTextTrackChanges();
290
291    virtual void didAddTextTrack(HTMLTrackElement*);
292    virtual void didRemoveTextTrack(HTMLTrackElement*);
293
294    virtual void mediaPlayerDidAddAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
295    virtual void mediaPlayerDidAddTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
296    virtual void mediaPlayerDidAddVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
297    virtual void mediaPlayerDidRemoveAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
298    virtual void mediaPlayerDidRemoveTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
299    virtual void mediaPlayerDidRemoveVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
300
301#if ENABLE(AVF_CAPTIONS)
302    virtual Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources() override;
303#endif
304
305#if USE(PLATFORM_TEXT_TRACK_MENU)
306    virtual void setSelectedTextTrack(PassRefPtr<PlatformTextTrack>) override;
307    virtual Vector<RefPtr<PlatformTextTrack>> platformTextTracks() override;
308    PlatformTextTrackMenuInterface* platformTextTrackMenu();
309#endif
310
311    struct TrackGroup {
312        enum GroupKind { CaptionsAndSubtitles, Description, Chapter, Metadata, Other };
313
314        TrackGroup(GroupKind kind)
315            : visibleTrack(0)
316            , defaultTrack(0)
317            , kind(kind)
318            , hasSrcLang(false)
319        {
320        }
321
322        Vector<RefPtr<TextTrack>> tracks;
323        RefPtr<TextTrack> visibleTrack;
324        RefPtr<TextTrack> defaultTrack;
325        GroupKind kind;
326        bool hasSrcLang;
327    };
328
329    void configureTextTrackGroupForLanguage(const TrackGroup&) const;
330    void configureTextTracks();
331    void configureTextTrackGroup(const TrackGroup&);
332
333    void setSelectedTextTrack(TextTrack*);
334
335    bool textTracksAreReady() const;
336    enum TextTrackVisibilityCheckType { CheckTextTrackVisibility, AssumeTextTrackVisibilityChanged };
337    void configureTextTrackDisplay(TextTrackVisibilityCheckType checkType = CheckTextTrackVisibility);
338    void updateTextTrackDisplay();
339
340    // AudioTrackClient
341    virtual void audioTrackEnabledChanged(AudioTrack*) override;
342
343    // TextTrackClient
344    virtual void textTrackReadyStateChanged(TextTrack*);
345    virtual void textTrackKindChanged(TextTrack*) override;
346    virtual void textTrackModeChanged(TextTrack*) override;
347    virtual void textTrackAddCues(TextTrack*, const TextTrackCueList*) override;
348    virtual void textTrackRemoveCues(TextTrack*, const TextTrackCueList*) override;
349    virtual void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
350    virtual void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
351
352    // VideoTrackClient
353    virtual void videoTrackSelectedChanged(VideoTrack*) override;
354
355    bool requiresTextTrackRepresentation() const;
356    void setTextTrackRepresentation(TextTrackRepresentation*);
357    void syncTextTrackBounds();
358#endif
359
360#if ENABLE(IOS_AIRPLAY)
361    void webkitShowPlaybackTargetPicker();
362    bool webkitCurrentPlaybackTargetIsWireless() const;
363
364    virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture) override;
365    virtual bool removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture) override;
366
367    DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitcurrentplaybacktargetiswirelesschanged);
368    DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitplaybacktargetavailabilitychanged);
369#endif
370
371    // EventTarget function.
372    // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
373    // causes an ambiguity error at compile time. This class's constructor
374    // ensures that both implementations return document, so return the result
375    // of one of them here.
376    using HTMLElement::scriptExecutionContext;
377
378    bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
379
380    virtual bool isFullscreen() const override;
381    void toggleFullscreenState();
382    virtual void enterFullscreen() override;
383    void exitFullscreen();
384
385    virtual bool hasClosedCaptions() const override;
386    virtual bool closedCaptionsVisible() const override;
387    virtual void setClosedCaptionsVisible(bool) override;
388
389    MediaControls* mediaControls() const;
390
391    void sourceWasRemoved(HTMLSourceElement*);
392    void sourceWasAdded(HTMLSourceElement*);
393
394    virtual void privateBrowsingStateDidChange() override;
395
396    // Media cache management.
397    static void getSitesInMediaCache(Vector<String>&);
398    static void clearMediaCache();
399    static void clearMediaCacheForSite(const String&);
400    static void resetMediaEngines();
401
402    bool isPlaying() const { return m_playing; }
403
404    virtual bool hasPendingActivity() const override;
405
406#if ENABLE(WEB_AUDIO)
407    MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
408    void setAudioSourceNode(MediaElementAudioSourceNode*);
409
410    AudioSourceProvider* audioSourceProvider();
411#endif
412
413    enum InvalidURLAction { DoNothing, Complain };
414    bool isSafeToLoadURL(const URL&, InvalidURLAction);
415
416    const String& mediaGroup() const;
417    void setMediaGroup(const String&);
418
419    MediaController* controller() const;
420    void setController(PassRefPtr<MediaController>);
421
422    void enteredOrExitedFullscreen() { configureMediaControls(); }
423
424    unsigned long long fileSize() const;
425
426    void mediaLoadingFailed(MediaPlayer::NetworkState);
427    void mediaLoadingFailedFatally(MediaPlayer::NetworkState);
428
429#if ENABLE(MEDIA_SOURCE)
430    RefPtr<VideoPlaybackQuality> getVideoPlaybackQuality();
431#endif
432
433    MediaPlayer::Preload preloadValue() const { return m_preload; }
434    HTMLMediaSession& mediaSession() const { return *m_mediaSession; }
435
436#if ENABLE(MEDIA_CONTROLS_SCRIPT)
437    void pageScaleFactorChanged();
438#endif
439
440    MediaControlsHost* mediaControlsHost() { return m_mediaControlsHost.get(); }
441
442protected:
443    HTMLMediaElement(const QualifiedName&, Document&, bool);
444    virtual ~HTMLMediaElement();
445
446    virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;
447    virtual void finishParsingChildren() override;
448    virtual bool isURLAttribute(const Attribute&) const override;
449    virtual void willAttachRenderers() override;
450    virtual void didAttachRenderers() override;
451
452    virtual void didMoveToNewDocument(Document* oldDocument) override;
453
454    enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
455    DisplayMode displayMode() const { return m_displayMode; }
456    virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
457
458    virtual bool isMediaElement() const override { return true; }
459
460#if ENABLE(VIDEO_TRACK)
461    bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0 || !m_textTracks || !m_cueTree.size(); }
462    void beginIgnoringTrackDisplayUpdateRequests();
463    void endIgnoringTrackDisplayUpdateRequests();
464#endif
465
466    virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) override;
467
468#if ENABLE(MEDIA_CONTROLS_SCRIPT)
469    bool mediaControlsDependOnPageScaleFactor() const { return m_mediaControlsDependOnPageScaleFactor; }
470    void setMediaControlsDependOnPageScaleFactor(bool);
471#endif
472
473private:
474    void createMediaPlayer();
475
476    virtual bool alwaysCreateUserAgentShadowRoot() const override { return true; }
477
478    virtual bool hasCustomFocusLogic() const override;
479    virtual bool supportsFocus() const override;
480    virtual bool isMouseFocusable() const override;
481    virtual bool rendererIsNeeded(const RenderStyle&) override;
482    virtual bool childShouldCreateRenderer(const Node&) const override;
483    virtual InsertionNotificationRequest insertedInto(ContainerNode&) override;
484    virtual void removedFrom(ContainerNode&) override;
485    virtual void didRecalcStyle(Style::Change) override;
486
487    virtual void didBecomeFullscreenElement() override;
488    virtual void willStopBeingFullscreenElement() override;
489
490    // ActiveDOMObject functions.
491    virtual bool canSuspend() const override;
492    virtual void suspend(ReasonForSuspension) override;
493    virtual void resume() override;
494    virtual void stop() override;
495
496    virtual void mediaVolumeDidChange() override;
497
498    virtual void visibilityStateChanged() override;
499
500    virtual void updateDisplayState() { }
501
502    void setReadyState(MediaPlayer::ReadyState);
503    void setNetworkState(MediaPlayer::NetworkState);
504
505    double effectivePlaybackRate() const;
506
507    virtual Document* mediaPlayerOwningDocument() override;
508    virtual void mediaPlayerNetworkStateChanged(MediaPlayer*) override;
509    virtual void mediaPlayerReadyStateChanged(MediaPlayer*) override;
510    virtual void mediaPlayerTimeChanged(MediaPlayer*) override;
511    virtual void mediaPlayerVolumeChanged(MediaPlayer*) override;
512    virtual void mediaPlayerMuteChanged(MediaPlayer*) override;
513    virtual void mediaPlayerDurationChanged(MediaPlayer*) override;
514    virtual void mediaPlayerRateChanged(MediaPlayer*) override;
515    virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*) override;
516    virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*) override;
517    virtual void mediaPlayerResourceNotSupported(MediaPlayer*) override;
518    virtual void mediaPlayerRepaint(MediaPlayer*) override;
519    virtual void mediaPlayerSizeChanged(MediaPlayer*) override;
520    virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) override;
521    virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) override;
522    virtual void mediaPlayerEngineUpdated(MediaPlayer*) override;
523
524    virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) override;
525    virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) override;
526
527#if ENABLE(ENCRYPTED_MEDIA)
528    virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& keySystem, const String& sessionId) override;
529    virtual void mediaPlayerKeyError(MediaPlayer*, const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode) override;
530    virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL) override;
531    virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength) override;
532#endif
533
534#if ENABLE(ENCRYPTED_MEDIA_V2)
535    virtual bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) override;
536#endif
537
538#if ENABLE(IOS_AIRPLAY)
539    virtual void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) override;
540    virtual void mediaPlayerPlaybackTargetAvailabilityChanged(MediaPlayer*) override;
541    void enqueuePlaybackTargetAvailabilityChangedEvent();
542#endif
543
544    virtual String mediaPlayerReferrer() const override;
545    virtual String mediaPlayerUserAgent() const override;
546    virtual CORSMode mediaPlayerCORSMode() const override;
547
548    virtual bool mediaPlayerNeedsSiteSpecificHacks() const override;
549    virtual String mediaPlayerDocumentHost() const override;
550
551    virtual void mediaPlayerEnterFullscreen() override;
552    virtual void mediaPlayerExitFullscreen() override;
553    virtual bool mediaPlayerIsFullscreen() const override;
554    virtual bool mediaPlayerIsFullscreenPermitted() const override;
555    virtual bool mediaPlayerIsVideo() const override;
556    virtual LayoutRect mediaPlayerContentBoxRect() const override;
557    virtual void mediaPlayerSetSize(const IntSize&) override;
558    virtual void mediaPlayerPause() override;
559    virtual void mediaPlayerPlay() override;
560    virtual bool mediaPlayerPlatformVolumeConfigurationRequired() const override;
561    virtual bool mediaPlayerIsPaused() const override;
562    virtual bool mediaPlayerIsLooping() const override;
563    virtual HostWindow* mediaPlayerHostWindow() override;
564    virtual IntRect mediaPlayerWindowClipRect() override;
565    virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() override;
566
567#if PLATFORM(WIN) && USE(AVFOUNDATION)
568    virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const override;
569#endif
570
571    virtual bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) override;
572    virtual void mediaPlayerHandlePlaybackCommand(MediaSession::RemoteControlCommandType command) override { didReceiveRemoteControlCommand(command); }
573    virtual String mediaPlayerSourceApplicationIdentifier() const;
574
575#if PLATFORM(IOS)
576    virtual String mediaPlayerNetworkInterfaceName() const;
577    virtual bool mediaPlayerGetRawCookies(const URL&, Vector<Cookie>&) const override;
578#endif
579
580    void loadTimerFired(Timer<HTMLMediaElement>&);
581    void progressEventTimerFired(Timer<HTMLMediaElement>&);
582    void playbackProgressTimerFired(Timer<HTMLMediaElement>&);
583    void scanTimerFired(Timer<HTMLMediaElement>&);
584    void seekTimerFired(Timer<HTMLMediaElement>&);
585    void startPlaybackProgressTimer();
586    void startProgressEventTimer();
587    void stopPeriodicTimers();
588
589    void seek(double time);
590    void seekInternal(double time);
591    void seekWithTolerance(double time, double negativeTolerance, double positiveTolerance, bool fromDOM);
592    void finishSeek();
593    void checkIfSeekNeeded();
594    void addPlayedRange(double start, double end);
595
596    void scheduleTimeupdateEvent(bool periodicEvent);
597    void scheduleEvent(const AtomicString& eventName);
598
599    // loading
600    void selectMediaResource();
601    void loadResource(const URL&, ContentType&, const String& keySystem);
602    void scheduleNextSourceChild();
603    void loadNextSourceChild();
604    void userCancelledLoad();
605    void clearMediaPlayer(int flags);
606    bool havePotentialSourceChild();
607    void noneSupported();
608    void cancelPendingEventsAndCallbacks();
609    void waitForSourceChange();
610    void prepareToPlay();
611
612    URL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
613
614#if ENABLE(VIDEO_TRACK)
615    void updateActiveTextTrackCues(double);
616    HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
617
618    enum ReconfigureMode {
619        Immediately,
620        AfterDelay,
621    };
622    void markCaptionAndSubtitleTracksAsUnconfigured(ReconfigureMode);
623    virtual void captionPreferencesChanged() override;
624#endif
625
626    // These "internal" functions do not check user gesture restrictions.
627    void loadInternal();
628    void playInternal();
629    void pauseInternal();
630
631    void prepareForLoad();
632    void allowVideoRendering();
633
634    bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
635    void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
636    void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
637
638    void updateVolume();
639    void updatePlayState();
640    bool potentiallyPlaying() const;
641    bool endedPlayback() const;
642    bool stoppedDueToErrors() const;
643    bool pausedForUserInteraction() const;
644    bool couldPlayIfEnoughData() const;
645
646    double minTimeSeekable() const;
647    double maxTimeSeekable() const;
648
649#if PLATFORM(IOS)
650    bool parseMediaPlayerAttribute(const QualifiedName&, const AtomicString&);
651#endif
652
653    // Pauses playback without changing any states or generating events
654    void setPausedInternal(bool);
655
656    void setPlaybackRateInternal(double);
657
658    virtual void mediaCanStart() override;
659
660    void setShouldDelayLoadEvent(bool);
661    void invalidateCachedTime() const;
662    void refreshCachedTime() const;
663
664    bool hasMediaControls() const;
665    bool createMediaControls();
666    void configureMediaControls();
667
668    void prepareMediaFragmentURI();
669    void applyMediaFragmentURI();
670
671    void changeNetworkStateFromLoadingToIdle();
672
673    void removeBehaviorsRestrictionsAfterFirstUserGesture();
674
675    void updateMediaController();
676    bool isBlocked() const;
677    bool isBlockedOnMediaController() const;
678    virtual bool hasCurrentSrc() const override { return !m_currentSrc.isEmpty(); }
679    virtual bool isLiveStream() const override { return movieLoadType() == MediaPlayer::LiveStream; }
680    bool isAutoplaying() const { return m_autoplaying; }
681
682    void updateSleepDisabling();
683    bool shouldDisableSleep() const;
684
685#if ENABLE(MEDIA_CONTROLS_SCRIPT)
686    virtual void didAddUserAgentShadowRoot(ShadowRoot*) override;
687    DOMWrapperWorld& ensureIsolatedWorld();
688    bool ensureMediaControlsInjectedScript();
689#endif
690
691    // MediaSessionClient Overrides
692    virtual MediaSession::MediaType mediaType() const override;
693    virtual MediaSession::MediaType presentationType() const override;
694    virtual void pausePlayback() override;
695    virtual void resumePlayback() override;
696    virtual String mediaSessionTitle() const override;
697    virtual double mediaSessionDuration() const override { return duration(); }
698    virtual double mediaSessionCurrentTime() const override { return currentTime(); }
699    virtual bool canReceiveRemoteControlCommands() const override { return true; }
700    virtual void didReceiveRemoteControlCommand(MediaSession::RemoteControlCommandType) override;
701    virtual bool overrideBackgroundPlaybackRestriction() const override;
702
703    void registerWithDocument(Document&);
704    void unregisterWithDocument(Document&);
705
706    void updateCaptionContainer();
707
708    Timer<HTMLMediaElement> m_loadTimer;
709    Timer<HTMLMediaElement> m_progressEventTimer;
710    Timer<HTMLMediaElement> m_playbackProgressTimer;
711    Timer<HTMLMediaElement> m_scanTimer;
712    Timer<HTMLMediaElement> m_seekTimer;
713    RefPtr<TimeRanges> m_playedTimeRanges;
714    GenericEventQueue m_asyncEventQueue;
715
716    double m_playbackRate;
717    double m_defaultPlaybackRate;
718    bool m_webkitPreservesPitch;
719    NetworkState m_networkState;
720    ReadyState m_readyState;
721    ReadyState m_readyStateMaximum;
722    URL m_currentSrc;
723
724    RefPtr<MediaError> m_error;
725
726    struct PendingSeek {
727        PendingSeek(double now, double targetTime, double negativeTolerance, double positiveTolerance)
728            : now(now)
729            , targetTime(targetTime)
730            , negativeTolerance(negativeTolerance)
731            , positiveTolerance(positiveTolerance)
732        {
733        }
734        double now;
735        double targetTime;
736        double negativeTolerance;
737        double positiveTolerance;
738    };
739    std::unique_ptr<PendingSeek> m_pendingSeek;
740
741    double m_volume;
742    bool m_volumeInitialized;
743    double m_lastSeekTime;
744
745    unsigned m_previousProgress;
746    double m_previousProgressTime;
747
748    // The last time a timeupdate event was sent (based on monotonic clock).
749    double m_clockTimeAtLastUpdateEvent;
750
751    // The last time a timeupdate event was sent in movie time.
752    double m_lastTimeUpdateEventMovieTime;
753
754    // Loading state.
755    enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
756    LoadState m_loadState;
757    RefPtr<HTMLSourceElement> m_currentSourceNode;
758    RefPtr<Node> m_nextChildNodeToConsider;
759
760#if PLATFORM(IOS)
761    RetainPtr<PlatformLayer> m_videoFullscreenLayer;
762    FloatRect m_videoFullscreenFrame;
763    MediaPlayer::VideoGravity m_videoFullscreenGravity;
764#endif
765
766    OwnPtr<MediaPlayer> m_player;
767
768    MediaPlayer::Preload m_preload;
769
770    DisplayMode m_displayMode;
771
772    // Counter incremented while processing a callback from the media player, so we can avoid
773    // calling the media engine recursively.
774    int m_processingMediaPlayerCallback;
775
776#if ENABLE(MEDIA_SOURCE)
777    RefPtr<MediaSource> m_mediaSource;
778    unsigned long m_droppedVideoFrames;
779#endif
780
781    mutable double m_cachedTime;
782    mutable double m_clockTimeAtLastCachedTimeUpdate;
783    mutable double m_minimumClockTimeToUpdateCachedTime;
784
785    double m_fragmentStartTime;
786    double m_fragmentEndTime;
787
788    typedef unsigned PendingActionFlags;
789    PendingActionFlags m_pendingActionFlags;
790
791    enum ActionAfterScanType {
792        Nothing, Play, Pause
793    };
794    ActionAfterScanType m_actionAfterScan;
795
796    enum ScanType { Seek, Scan };
797    ScanType m_scanType;
798    ScanDirection m_scanDirection;
799
800    bool m_playing : 1;
801    bool m_isWaitingUntilMediaCanStart : 1;
802    bool m_shouldDelayLoadEvent : 1;
803    bool m_haveFiredLoadedData : 1;
804    bool m_inActiveDocument : 1;
805    bool m_autoplaying : 1;
806    bool m_muted : 1;
807    bool m_explicitlyMuted : 1;
808    bool m_paused : 1;
809    bool m_seeking : 1;
810
811    // data has not been loaded since sending a "stalled" event
812    bool m_sentStalledEvent : 1;
813
814    // time has not changed since sending an "ended" event
815    bool m_sentEndEvent : 1;
816
817    bool m_pausedInternal : 1;
818
819    // Not all media engines provide enough information about a file to be able to
820    // support progress events so setting m_sendProgressEvents disables them
821    bool m_sendProgressEvents : 1;
822
823    bool m_isFullscreen : 1;
824    bool m_closedCaptionsVisible : 1;
825    bool m_webkitLegacyClosedCaptionOverride : 1;
826    bool m_completelyLoaded : 1;
827    bool m_havePreparedToPlay : 1;
828    bool m_parsingInProgress : 1;
829    bool m_elementIsHidden : 1;
830
831#if PLATFORM(IOS)
832    bool m_requestingPlay : 1;
833#endif
834
835#if ENABLE(MEDIA_CONTROLS_SCRIPT)
836    bool m_mediaControlsDependOnPageScaleFactor : 1;
837#endif
838
839#if ENABLE(VIDEO_TRACK)
840    bool m_tracksAreReady : 1;
841    bool m_haveVisibleTextTrack : 1;
842    bool m_processingPreferenceChange : 1;
843
844    String m_subtitleTrackLanguage;
845    float m_lastTextTrackUpdateTime;
846
847    CaptionUserPreferences::CaptionDisplayMode m_captionDisplayMode;
848
849    RefPtr<AudioTrackList> m_audioTracks;
850    RefPtr<TextTrackList> m_textTracks;
851    RefPtr<VideoTrackList> m_videoTracks;
852    Vector<RefPtr<TextTrack>> m_textTracksWhenResourceSelectionBegan;
853
854    CueIntervalTree m_cueTree;
855
856    CueList m_currentlyActiveCues;
857    int m_ignoreTrackDisplayUpdate;
858#endif
859
860#if ENABLE(WEB_AUDIO)
861    // This is a weak reference, since m_audioSourceNode holds a reference to us.
862    // The value is set just after the MediaElementAudioSourceNode is created.
863    // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
864    MediaElementAudioSourceNode* m_audioSourceNode;
865#endif
866
867    String m_mediaGroup;
868    friend class MediaController;
869    RefPtr<MediaController> m_mediaController;
870
871    std::unique_ptr<DisplaySleepDisabler> m_sleepDisabler;
872
873    friend class TrackDisplayUpdateScope;
874
875#if ENABLE(ENCRYPTED_MEDIA_V2)
876    RefPtr<MediaKeys> m_mediaKeys;
877#endif
878
879#if USE(PLATFORM_TEXT_TRACK_MENU)
880    RefPtr<PlatformTextTrackMenuInterface> m_platformMenu;
881#endif
882
883    std::unique_ptr<HTMLMediaSession> m_mediaSession;
884    std::unique_ptr<PageActivityAssertionToken> m_activityToken;
885    size_t m_reportedExtraMemoryCost;
886
887#if ENABLE(MEDIA_CONTROLS_SCRIPT)
888    friend class MediaControlsHost;
889    RefPtr<MediaControlsHost> m_mediaControlsHost;
890    RefPtr<DOMWrapperWorld> m_isolatedWorld;
891#endif
892
893#if ENABLE(MEDIA_STREAM)
894    RefPtr<MediaStream> m_mediaStreamSrcObject;
895#endif
896};
897
898#if ENABLE(VIDEO_TRACK)
899#ifndef NDEBUG
900// Template specialization required by PodIntervalTree in debug mode.
901template <>
902struct ValueToString<TextTrackCue*> {
903    static String string(TextTrackCue* const& cue)
904    {
905        String text;
906        if (cue->isRenderable())
907            text = toVTTCue(cue)->text();
908        return String::format("%p id=%s interval=%f-->%f cue=%s)", cue, cue->id().utf8().data(), cue->startTime(), cue->endTime(), text.utf8().data());
909    }
910};
911#endif
912#endif
913
914void isHTMLMediaElement(const HTMLMediaElement&); // Catch unnecessary runtime check of type known at compile time.
915inline bool isHTMLMediaElement(const Element& element) { return element.isMediaElement(); }
916inline bool isHTMLMediaElement(const Node& node) { return node.isElementNode() && toElement(node).isMediaElement(); }
917template <> inline bool isElementOfType<const HTMLMediaElement>(const Element& element) { return element.isMediaElement(); }
918
919NODE_TYPE_CASTS(HTMLMediaElement)
920
921} //namespace
922
923#endif
924#endif
925