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