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