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