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