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