da7d2c68c89606542c0b8835e7a4c0bdf053568b
[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&) 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     void fastSeek(double);
203
204 // captions
205     bool webkitHasClosedCaptions() const;
206     bool webkitClosedCaptionsVisible() const;
207     void setWebkitClosedCaptionsVisible(bool);
208
209 #if ENABLE(MEDIA_STATISTICS)
210 // Statistics
211     unsigned webkitAudioDecodedByteCount() const;
212     unsigned webkitVideoDecodedByteCount() const;
213 #endif
214
215 #if ENABLE(MEDIA_SOURCE)
216 //  Media Source.
217     void closeMediaSource();
218     void incrementDroppedFrameCount() { ++m_droppedVideoFrames; }
219 #endif
220
221 #if ENABLE(ENCRYPTED_MEDIA)
222     void webkitGenerateKeyRequest(const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionCode&);
223     void webkitGenerateKeyRequest(const String& keySystem, ExceptionCode&);
224     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initData, const String& sessionId, ExceptionCode&);
225     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, ExceptionCode&);
226     void webkitCancelKeyRequest(const String& keySystem, const String& sessionId, ExceptionCode&);
227
228     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyadded);
229     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyerror);
230     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeymessage);
231 #endif
232 #if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
233     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitneedkey);
234 #endif
235
236 #if ENABLE(ENCRYPTED_MEDIA_V2)
237     MediaKeys* keys() const { return m_mediaKeys.get(); }
238     void setMediaKeys(MediaKeys*);
239 #endif
240
241 // controls
242     bool controls() const;
243     void setControls(bool);
244     virtual double volume() const override;
245     virtual void setVolume(double, ExceptionCode&) override;
246     virtual bool muted() const override;
247     virtual void setMuted(bool) override;
248
249     void togglePlayState();
250     virtual void beginScrubbing() override;
251     virtual void endScrubbing() override;
252
253     virtual void beginScanning(ScanDirection) override;
254     virtual void endScanning() override;
255     double nextScanRate();
256
257     virtual bool canPlay() const override;
258
259     double percentLoaded() const;
260
261     DEFINE_ATTRIBUTE_EVENT_LISTENER(emptied);
262     DEFINE_ATTRIBUTE_EVENT_LISTENER(loadedmetadata);
263     DEFINE_ATTRIBUTE_EVENT_LISTENER(loadeddata);
264     DEFINE_ATTRIBUTE_EVENT_LISTENER(canplay);
265     DEFINE_ATTRIBUTE_EVENT_LISTENER(canplaythrough);
266     DEFINE_ATTRIBUTE_EVENT_LISTENER(playing);
267     DEFINE_ATTRIBUTE_EVENT_LISTENER(ended);
268     DEFINE_ATTRIBUTE_EVENT_LISTENER(waiting);
269     DEFINE_ATTRIBUTE_EVENT_LISTENER(durationchange);
270     DEFINE_ATTRIBUTE_EVENT_LISTENER(timeupdate);
271     DEFINE_ATTRIBUTE_EVENT_LISTENER(play);
272     DEFINE_ATTRIBUTE_EVENT_LISTENER(pause);
273     DEFINE_ATTRIBUTE_EVENT_LISTENER(ratechange);
274     DEFINE_ATTRIBUTE_EVENT_LISTENER(volumechange);
275
276 #if ENABLE(VIDEO_TRACK)
277     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
278     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, ExceptionCode& ec) { return addTextTrack(kind, label, emptyString(), ec); }
279     PassRefPtr<TextTrack> addTextTrack(const String& kind, ExceptionCode& ec) { return addTextTrack(kind, emptyString(), emptyString(), ec); }
280
281     AudioTrackList* audioTracks();
282     TextTrackList* textTracks();
283     VideoTrackList* videoTracks();
284
285     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
286
287     void addAudioTrack(PassRefPtr<AudioTrack>);
288     void addTextTrack(PassRefPtr<TextTrack>);
289     void addVideoTrack(PassRefPtr<VideoTrack>);
290     void removeAudioTrack(AudioTrack*);
291     void removeTextTrack(TextTrack*, bool scheduleEvent = true);
292     void removeVideoTrack(VideoTrack*);
293     void forgetResourceSpecificTracks();
294     void closeCaptionTracksChanged();
295     void notifyMediaPlayerOfTextTrackChanges();
296
297     virtual void didAddTextTrack(HTMLTrackElement*);
298     virtual void didRemoveTextTrack(HTMLTrackElement*);
299
300     virtual void mediaPlayerDidAddAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
301     virtual void mediaPlayerDidAddTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
302     virtual void mediaPlayerDidAddVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
303     virtual void mediaPlayerDidRemoveAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
304     virtual void mediaPlayerDidRemoveTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
305     virtual void mediaPlayerDidRemoveVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
306
307 #if ENABLE(AVF_CAPTIONS)
308     virtual Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources() override;
309 #endif
310
311 #if USE(PLATFORM_TEXT_TRACK_MENU)
312     virtual void setSelectedTextTrack(PassRefPtr<PlatformTextTrack>) override;
313     virtual Vector<RefPtr<PlatformTextTrack>> platformTextTracks() override;
314     PlatformTextTrackMenuInterface* platformTextTrackMenu();
315 #endif
316
317     struct TrackGroup {
318         enum GroupKind { CaptionsAndSubtitles, Description, Chapter, Metadata, Other };
319
320         TrackGroup(GroupKind kind)
321             : visibleTrack(0)
322             , defaultTrack(0)
323             , kind(kind)
324             , hasSrcLang(false)
325         {
326         }
327
328         Vector<RefPtr<TextTrack>> tracks;
329         RefPtr<TextTrack> visibleTrack;
330         RefPtr<TextTrack> defaultTrack;
331         GroupKind kind;
332         bool hasSrcLang;
333     };
334
335     void configureTextTrackGroupForLanguage(const TrackGroup&) const;
336     void configureTextTracks();
337     void configureTextTrackGroup(const TrackGroup&);
338
339     void setSelectedTextTrack(TextTrack*);
340
341     bool textTracksAreReady() const;
342     enum TextTrackVisibilityCheckType { CheckTextTrackVisibility, AssumeTextTrackVisibilityChanged };
343     void configureTextTrackDisplay(TextTrackVisibilityCheckType checkType = CheckTextTrackVisibility);
344     void updateTextTrackDisplay();
345
346     // AudioTrackClient
347     virtual void audioTrackEnabledChanged(AudioTrack*) override;
348
349     // TextTrackClient
350     virtual void textTrackReadyStateChanged(TextTrack*);
351     virtual void textTrackKindChanged(TextTrack*) override;
352     virtual void textTrackModeChanged(TextTrack*) override;
353     virtual void textTrackAddCues(TextTrack*, const TextTrackCueList*) override;
354     virtual void textTrackRemoveCues(TextTrack*, const TextTrackCueList*) override;
355     virtual void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
356     virtual void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
357
358     // VideoTrackClient
359     virtual void videoTrackSelectedChanged(VideoTrack*) override;
360
361     bool requiresTextTrackRepresentation() const;
362     void setTextTrackRepresentation(TextTrackRepresentation*);
363 #endif
364
365 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
366     void ensureMediaPlayer();
367     void setNeedWidgetUpdate(bool needWidgetUpdate) { m_needWidgetUpdate = needWidgetUpdate; }
368     void deliverNotification(MediaPlayerProxyNotificationType notification);
369     void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
370     void getPluginProxyParams(URL& url, Vector<String>& names, Vector<String>& values);
371     void createMediaPlayerProxy();
372     void updateWidget(PluginCreationOption);
373 #endif
374
375 #if ENABLE(IOS_AIRPLAY)
376     void webkitShowPlaybackTargetPicker();
377     bool webkitCurrentPlaybackTargetIsWireless() const;
378
379     virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture) override;
380     virtual bool removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture) override;
381
382     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitcurrentplaybacktargetiswirelesschanged);
383     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitplaybacktargetavailabilitychanged);
384 #endif
385
386     // EventTarget function.
387     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
388     // causes an ambiguity error at compile time. This class's constructor
389     // ensures that both implementations return document, so return the result
390     // of one of them here.
391     using HTMLElement::scriptExecutionContext;
392
393     bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
394     
395     virtual bool isFullscreen() const override;
396     void toggleFullscreenState();
397     virtual void enterFullscreen() override;
398     void exitFullscreen();
399
400     virtual bool hasClosedCaptions() const override;
401     virtual bool closedCaptionsVisible() const override;
402     virtual void setClosedCaptionsVisible(bool) override;
403
404     MediaControls* mediaControls() const;
405
406     void sourceWasRemoved(HTMLSourceElement*);
407     void sourceWasAdded(HTMLSourceElement*);
408
409     virtual void privateBrowsingStateDidChange() override;
410
411     // Media cache management.
412     static void getSitesInMediaCache(Vector<String>&);
413     static void clearMediaCache();
414     static void clearMediaCacheForSite(const String&);
415     static void resetMediaEngines();
416
417     bool isPlaying() const { return m_playing; }
418
419     virtual bool hasPendingActivity() const override;
420
421 #if ENABLE(WEB_AUDIO)
422     MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
423     void setAudioSourceNode(MediaElementAudioSourceNode*);
424
425     AudioSourceProvider* audioSourceProvider();
426 #endif
427
428     enum InvalidURLAction { DoNothing, Complain };
429     bool isSafeToLoadURL(const URL&, InvalidURLAction);
430
431     const String& mediaGroup() const;
432     void setMediaGroup(const String&);
433
434     MediaController* controller() const;
435     void setController(PassRefPtr<MediaController>);
436
437 #if !PLATFORM(IOS)
438     virtual bool willRespondToMouseClickEvents() override;
439 #endif
440
441     void enteredOrExitedFullscreen() { configureMediaControls(); }
442
443 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
444     bool shouldUseVideoPluginProxy() const;
445 #endif
446
447     unsigned long long fileSize() const;
448
449     void mediaLoadingFailed(MediaPlayer::NetworkState);
450     void mediaLoadingFailedFatally(MediaPlayer::NetworkState);
451
452 #if ENABLE(MEDIA_SOURCE)
453     RefPtr<VideoPlaybackQuality> getVideoPlaybackQuality();
454 #endif
455
456     MediaPlayer::Preload preloadValue() const { return m_preload; }
457     HTMLMediaSession& mediaSession() const { return *m_mediaSession; }
458
459 protected:
460     HTMLMediaElement(const QualifiedName&, Document&, bool);
461     virtual ~HTMLMediaElement();
462
463     virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;
464     virtual void finishParsingChildren() override;
465     virtual bool isURLAttribute(const Attribute&) const override;
466     virtual void willAttachRenderers() override;
467     virtual void didAttachRenderers() override;
468
469     virtual void didMoveToNewDocument(Document* oldDocument) override;
470
471     enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
472     DisplayMode displayMode() const { return m_displayMode; }
473     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
474     
475     virtual bool isMediaElement() const override { return true; }
476
477 #if ENABLE(VIDEO_TRACK)
478     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0 || !m_textTracks || !m_cueTree.size(); }
479     void beginIgnoringTrackDisplayUpdateRequests();
480     void endIgnoringTrackDisplayUpdateRequests();
481 #endif
482
483     virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) override;
484
485 private:
486     void createMediaPlayer();
487
488     virtual bool alwaysCreateUserAgentShadowRoot() const override { return true; }
489
490     virtual bool hasCustomFocusLogic() const override;
491     virtual bool supportsFocus() const override;
492     virtual bool isMouseFocusable() const override;
493     virtual bool rendererIsNeeded(const RenderStyle&) override;
494     virtual bool childShouldCreateRenderer(const Node&) const override;
495     virtual InsertionNotificationRequest insertedInto(ContainerNode&) override;
496     virtual void removedFrom(ContainerNode&) override;
497     virtual void didRecalcStyle(Style::Change) override;
498
499     virtual void defaultEventHandler(Event*) override;
500
501     virtual void didBecomeFullscreenElement() override;
502     virtual void willStopBeingFullscreenElement() override;
503
504     // ActiveDOMObject functions.
505     virtual bool canSuspend() const override;
506     virtual void suspend(ReasonForSuspension) override;
507     virtual void resume() override;
508     virtual void stop() override;
509     
510     virtual void mediaVolumeDidChange() override;
511
512 #if ENABLE(PAGE_VISIBILITY_API)
513     virtual void visibilityStateChanged() override;
514 #endif
515
516     virtual void updateDisplayState() { }
517     
518     void setReadyState(MediaPlayer::ReadyState);
519     void setNetworkState(MediaPlayer::NetworkState);
520
521     virtual Document* mediaPlayerOwningDocument() override;
522     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*) override;
523     virtual void mediaPlayerReadyStateChanged(MediaPlayer*) override;
524     virtual void mediaPlayerTimeChanged(MediaPlayer*) override;
525     virtual void mediaPlayerVolumeChanged(MediaPlayer*) override;
526     virtual void mediaPlayerMuteChanged(MediaPlayer*) override;
527     virtual void mediaPlayerDurationChanged(MediaPlayer*) override;
528     virtual void mediaPlayerRateChanged(MediaPlayer*) override;
529     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*) override;
530     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*) override;
531     virtual void mediaPlayerResourceNotSupported(MediaPlayer*) override;
532     virtual void mediaPlayerRepaint(MediaPlayer*) override;
533     virtual void mediaPlayerSizeChanged(MediaPlayer*) override;
534     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) override;
535     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) override;
536     virtual void mediaPlayerEngineUpdated(MediaPlayer*) override;
537     
538     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) override;
539     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) override;
540
541 #if ENABLE(ENCRYPTED_MEDIA)
542     virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& keySystem, const String& sessionId) override;
543     virtual void mediaPlayerKeyError(MediaPlayer*, const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode) override;
544     virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL) override;
545     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength) override;
546 #endif
547
548 #if ENABLE(ENCRYPTED_MEDIA_V2)
549     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) override;
550 #endif
551
552 #if ENABLE(IOS_AIRPLAY)
553     virtual void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) override;
554     virtual void mediaPlayerPlaybackTargetAvailabilityChanged(MediaPlayer*) override;
555     void enqueuePlaybackTargetAvailabilityChangedEvent();
556 #endif
557
558     virtual String mediaPlayerReferrer() const override;
559     virtual String mediaPlayerUserAgent() const override;
560     virtual CORSMode mediaPlayerCORSMode() const override;
561
562     virtual bool mediaPlayerNeedsSiteSpecificHacks() const override;
563     virtual String mediaPlayerDocumentHost() const override;
564
565     virtual void mediaPlayerEnterFullscreen() override;
566     virtual void mediaPlayerExitFullscreen() override;
567     virtual bool mediaPlayerIsFullscreen() const override;
568     virtual bool mediaPlayerIsFullscreenPermitted() const override;
569     virtual bool mediaPlayerIsVideo() const override;
570     virtual LayoutRect mediaPlayerContentBoxRect() const override;
571     virtual void mediaPlayerSetSize(const IntSize&) override;
572     virtual void mediaPlayerPause() override;
573     virtual void mediaPlayerPlay() override;
574     virtual bool mediaPlayerPlatformVolumeConfigurationRequired() const override;
575     virtual bool mediaPlayerIsPaused() const override;
576     virtual bool mediaPlayerIsLooping() const override;
577     virtual HostWindow* mediaPlayerHostWindow() override;
578     virtual IntRect mediaPlayerWindowClipRect() override;
579     virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() override;
580
581 #if PLATFORM(WIN) && USE(AVFOUNDATION)
582     virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const override;
583 #endif
584
585     virtual bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) override;
586     virtual void mediaPlayerHandlePlaybackCommand(MediaSession::RemoteControlCommandType command) override { didReceiveRemoteControlCommand(command); }
587
588     void loadTimerFired(Timer<HTMLMediaElement>&);
589     void progressEventTimerFired(Timer<HTMLMediaElement>&);
590     void playbackProgressTimerFired(Timer<HTMLMediaElement>&);
591     void scanTimerFired(Timer<HTMLMediaElement>&);
592     void startPlaybackProgressTimer();
593     void startProgressEventTimer();
594     void stopPeriodicTimers();
595
596     void seek(double time);
597     void seekWithTolerance(double time, double negativeTolerance, double positiveTolerance);
598     void finishSeek();
599     void checkIfSeekNeeded();
600     void addPlayedRange(double start, double end);
601     
602     void scheduleTimeupdateEvent(bool periodicEvent);
603     void scheduleEvent(const AtomicString& eventName);
604     
605     // loading
606     void selectMediaResource();
607     void loadResource(const URL&, ContentType&, const String& keySystem);
608     void scheduleNextSourceChild();
609     void loadNextSourceChild();
610     void userCancelledLoad();
611     void clearMediaPlayer(int flags);
612     bool havePotentialSourceChild();
613     void noneSupported();
614     void cancelPendingEventsAndCallbacks();
615     void waitForSourceChange();
616     void prepareToPlay();
617
618     URL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
619
620 #if ENABLE(VIDEO_TRACK)
621     void updateActiveTextTrackCues(double);
622     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
623
624     enum ReconfigureMode {
625         Immediately,
626         AfterDelay,
627     };
628     void markCaptionAndSubtitleTracksAsUnconfigured(ReconfigureMode);
629     virtual void captionPreferencesChanged() override;
630 #endif
631
632     // These "internal" functions do not check user gesture restrictions.
633     void loadInternal();
634     void playInternal();
635     void pauseInternal();
636
637     void prepareForLoad();
638     void allowVideoRendering();
639
640     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
641     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
642     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
643
644     void updateVolume();
645     void updatePlayState();
646     bool potentiallyPlaying() const;
647     bool endedPlayback() const;
648     bool stoppedDueToErrors() const;
649     bool pausedForUserInteraction() const;
650     bool couldPlayIfEnoughData() const;
651
652     double minTimeSeekable() const;
653     double maxTimeSeekable() const;
654
655 #if PLATFORM(IOS)
656     bool parseMediaPlayerAttribute(const QualifiedName&, const AtomicString&);
657 #endif
658
659     // Pauses playback without changing any states or generating events
660     void setPausedInternal(bool);
661
662     void setPlaybackRateInternal(double);
663
664     virtual void mediaCanStart() override;
665
666     void setShouldDelayLoadEvent(bool);
667     void invalidateCachedTime() const;
668     void refreshCachedTime() const;
669
670     bool hasMediaControls() const;
671     bool createMediaControls();
672     void configureMediaControls();
673
674     void prepareMediaFragmentURI();
675     void applyMediaFragmentURI();
676
677     void changeNetworkStateFromLoadingToIdle();
678
679     void removeBehaviorsRestrictionsAfterFirstUserGesture();
680
681     void updateMediaController();
682     bool isBlocked() const;
683     bool isBlockedOnMediaController() const;
684     virtual bool hasCurrentSrc() const override { return !m_currentSrc.isEmpty(); }
685     virtual bool isLiveStream() const override { return movieLoadType() == MediaPlayer::LiveStream; }
686     bool isAutoplaying() const { return m_autoplaying; }
687
688     void updateSleepDisabling();
689 #if PLATFORM(COCOA)
690     bool shouldDisableSleep() const;
691 #endif
692
693 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
694     virtual void didAddUserAgentShadowRoot(ShadowRoot*) override;
695     DOMWrapperWorld& ensureIsolatedWorld();
696     bool ensureMediaControlsInjectedScript();
697 #endif
698
699     // MediaSessionClient Overrides
700     virtual MediaSession::MediaType mediaType() const override;
701     virtual void pausePlayback() override;
702     virtual void resumePlayback() override;
703     virtual String mediaSessionTitle() const override;
704     virtual double mediaSessionDuration() const override { return duration(); }
705     virtual double mediaSessionCurrentTime() const override { return currentTime(); }
706     virtual bool canReceiveRemoteControlCommands() const override { return true; }
707     virtual void didReceiveRemoteControlCommand(MediaSession::RemoteControlCommandType) override;
708
709     void registerWithDocument(Document&);
710     void unregisterWithDocument(Document&);
711
712     Timer<HTMLMediaElement> m_loadTimer;
713     Timer<HTMLMediaElement> m_progressEventTimer;
714     Timer<HTMLMediaElement> m_playbackProgressTimer;
715     Timer<HTMLMediaElement> m_scanTimer;
716     RefPtr<TimeRanges> m_playedTimeRanges;
717     GenericEventQueue m_asyncEventQueue;
718
719     double m_playbackRate;
720     double m_defaultPlaybackRate;
721     bool m_webkitPreservesPitch;
722     NetworkState m_networkState;
723     ReadyState m_readyState;
724     ReadyState m_readyStateMaximum;
725     URL m_currentSrc;
726
727     RefPtr<MediaError> m_error;
728
729     double m_volume;
730     bool m_volumeInitialized;
731     double m_lastSeekTime;
732     
733     unsigned m_previousProgress;
734     double m_previousProgressTime;
735
736     // The last time a timeupdate event was sent (based on monotonic clock).
737     double m_clockTimeAtLastUpdateEvent;
738
739     // The last time a timeupdate event was sent in movie time.
740     double m_lastTimeUpdateEventMovieTime;
741     
742     // Loading state.
743     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
744     LoadState m_loadState;
745     RefPtr<HTMLSourceElement> m_currentSourceNode;
746     RefPtr<Node> m_nextChildNodeToConsider;
747
748 #if PLATFORM(IOS)
749     RetainPtr<PlatformLayer> m_videoFullscreenLayer;
750     FloatRect m_videoFullscreenFrame;
751     MediaPlayer::VideoGravity m_videoFullscreenGravity;
752 #endif
753
754     OwnPtr<MediaPlayer> m_player;
755 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
756     RefPtr<Widget> m_proxyWidget;
757 #endif
758
759     MediaPlayer::Preload m_preload;
760
761     DisplayMode m_displayMode;
762
763     // Counter incremented while processing a callback from the media player, so we can avoid
764     // calling the media engine recursively.
765     int m_processingMediaPlayerCallback;
766
767 #if ENABLE(MEDIA_SOURCE)
768     RefPtr<MediaSource> m_mediaSource;
769     unsigned long m_droppedVideoFrames;
770 #endif
771
772     mutable double m_cachedTime;
773     mutable double m_clockTimeAtLastCachedTimeUpdate;
774     mutable double m_minimumClockTimeToUpdateCachedTime;
775
776     double m_fragmentStartTime;
777     double m_fragmentEndTime;
778
779     typedef unsigned PendingActionFlags;
780     PendingActionFlags m_pendingActionFlags;
781
782     enum ActionAfterScanType {
783         Nothing, Play, Pause
784     };
785     ActionAfterScanType m_actionAfterScan;
786
787     enum ScanType { Seek, Scan };
788     ScanType m_scanType;
789     ScanDirection m_scanDirection;
790
791     bool m_playing : 1;
792     bool m_isWaitingUntilMediaCanStart : 1;
793     bool m_shouldDelayLoadEvent : 1;
794     bool m_haveFiredLoadedData : 1;
795     bool m_inActiveDocument : 1;
796     bool m_autoplaying : 1;
797     bool m_muted : 1;
798     bool m_explicitlyMuted : 1;
799     bool m_paused : 1;
800     bool m_seeking : 1;
801
802     // data has not been loaded since sending a "stalled" event
803     bool m_sentStalledEvent : 1;
804
805     // time has not changed since sending an "ended" event
806     bool m_sentEndEvent : 1;
807
808     bool m_pausedInternal : 1;
809
810     // Not all media engines provide enough information about a file to be able to
811     // support progress events so setting m_sendProgressEvents disables them 
812     bool m_sendProgressEvents : 1;
813
814     bool m_isFullscreen : 1;
815     bool m_closedCaptionsVisible : 1;
816     bool m_webkitLegacyClosedCaptionOverride : 1;
817
818 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
819     bool m_needWidgetUpdate : 1;
820 #endif
821
822     bool m_completelyLoaded : 1;
823     bool m_havePreparedToPlay : 1;
824     bool m_parsingInProgress : 1;
825 #if ENABLE(PAGE_VISIBILITY_API)
826     bool m_isDisplaySleepDisablingSuspended : 1;
827 #endif
828
829 #if PLATFORM(IOS)
830     bool m_requestingPlay : 1;
831 #endif
832
833 #if ENABLE(VIDEO_TRACK)
834     bool m_tracksAreReady : 1;
835     bool m_haveVisibleTextTrack : 1;
836     bool m_processingPreferenceChange : 1;
837
838     String m_subtitleTrackLanguage;
839     float m_lastTextTrackUpdateTime;
840
841     CaptionUserPreferences::CaptionDisplayMode m_captionDisplayMode;
842
843     RefPtr<AudioTrackList> m_audioTracks;
844     RefPtr<TextTrackList> m_textTracks;
845     RefPtr<VideoTrackList> m_videoTracks;
846     Vector<RefPtr<TextTrack>> m_textTracksWhenResourceSelectionBegan;
847
848     CueIntervalTree m_cueTree;
849
850     CueList m_currentlyActiveCues;
851     int m_ignoreTrackDisplayUpdate;
852 #endif
853
854 #if ENABLE(WEB_AUDIO)
855     // This is a weak reference, since m_audioSourceNode holds a reference to us.
856     // The value is set just after the MediaElementAudioSourceNode is created.
857     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
858     MediaElementAudioSourceNode* m_audioSourceNode;
859 #endif
860
861     String m_mediaGroup;
862     friend class MediaController;
863     RefPtr<MediaController> m_mediaController;
864
865     std::unique_ptr<DisplaySleepDisabler> m_sleepDisabler;
866
867     friend class TrackDisplayUpdateScope;
868
869 #if ENABLE(ENCRYPTED_MEDIA_V2)
870     RefPtr<MediaKeys> m_mediaKeys;
871 #endif
872
873 #if USE(PLATFORM_TEXT_TRACK_MENU)
874     RefPtr<PlatformTextTrackMenuInterface> m_platformMenu;
875 #endif
876
877     std::unique_ptr<HTMLMediaSession> m_mediaSession;
878     std::unique_ptr<PageActivityAssertionToken> m_activityToken;
879     size_t m_reportedExtraMemoryCost;
880
881 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
882     RefPtr<MediaControlsHost> m_mediaControlsHost;
883     RefPtr<DOMWrapperWorld> m_isolatedWorld;
884 #endif
885
886 #if ENABLE(MEDIA_STREAM)
887     RefPtr<MediaStream> m_mediaStreamSrcObject;
888 #endif
889 };
890
891 #if ENABLE(VIDEO_TRACK)
892 #ifndef NDEBUG
893 // Template specialization required by PodIntervalTree in debug mode.
894 template <>
895 struct ValueToString<TextTrackCue*> {
896     static String string(TextTrackCue* const& cue)
897     {
898         String text;
899         if (cue->isRenderable())
900             text = toVTTCue(cue)->text();
901         return String::format("%p id=%s interval=%f-->%f cue=%s)", cue, cue->id().utf8().data(), cue->startTime(), cue->endTime(), text.utf8().data());
902     }
903 };
904 #endif
905 #endif
906
907 void isHTMLMediaElement(const HTMLMediaElement&); // Catch unnecessary runtime check of type known at compile time.
908 inline bool isHTMLMediaElement(const Element& element) { return element.isMediaElement(); }
909 inline bool isHTMLMediaElement(const Node& node) { return node.isElementNode() && toElement(node).isMediaElement(); }
910 template <> inline bool isElementOfType<const HTMLMediaElement>(const Element& element) { return element.isMediaElement(); }
911
912 NODE_TYPE_CASTS(HTMLMediaElement)
913
914 } //namespace
915
916 #endif
917 #endif