[EFL][WK2] Use the correct enum for control key in Ewk_Event_Modifiers in ewk_navigat...
[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(VIDEO_TRACK)
39 #include "AudioTrack.h"
40 #include "CaptionUserPreferences.h"
41 #include "PODIntervalTree.h"
42 #include "TextTrack.h"
43 #include "TextTrackCue.h"
44 #include "VTTCue.h"
45 #include "VideoTrack.h"
46 #endif
47
48 #if ENABLE(MEDIA_STREAM)
49 #include "MediaStream.h"
50 #endif
51
52 #ifndef NDEBUG
53 #include <wtf/StringPrintStream.h>
54 #endif
55
56 namespace WebCore {
57
58 #if ENABLE(WEB_AUDIO)
59 class AudioSourceProvider;
60 class MediaElementAudioSourceNode;
61 #endif
62 class DisplaySleepDisabler;
63 class Event;
64 class HTMLSourceElement;
65 class HTMLTrackElement;
66 class URL;
67 class MediaController;
68 class MediaControls;
69 class MediaControlsHost;
70 class MediaError;
71 class PageActivityAssertionToken;
72 class TimeRanges;
73 #if ENABLE(ENCRYPTED_MEDIA_V2)
74 class MediaKeys;
75 #endif
76 #if ENABLE(MEDIA_SOURCE)
77 class MediaSource;
78 class SourceBuffer;
79 class VideoPlaybackQuality;
80 #endif
81
82 #if ENABLE(VIDEO_TRACK)
83 class AudioTrackList;
84 class AudioTrackPrivate;
85 class InbandTextTrackPrivate;
86 class TextTrackList;
87 class VideoTrackList;
88 class VideoTrackPrivate;
89
90 typedef PODIntervalTree<MediaTime, TextTrackCue*> CueIntervalTree;
91 typedef CueIntervalTree::IntervalType CueInterval;
92 typedef Vector<CueInterval> CueList;
93 #endif
94
95 class HTMLMediaElement
96     : public HTMLElement
97     , private MediaPlayerClient, public MediaPlayerSupportsTypeClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface , public MediaSessionClient
98 #if ENABLE(VIDEO_TRACK)
99     , private AudioTrackClient
100     , private TextTrackClient
101     , private VideoTrackClient
102 #endif
103 #if USE(PLATFORM_TEXT_TRACK_MENU)
104     , public PlatformTextTrackMenuClient
105 #endif
106 {
107 public:
108     MediaPlayer* player() const { return m_player.get(); }
109
110     virtual bool isVideo() const { return false; }
111     virtual bool hasVideo() const override { return false; }
112     virtual bool hasAudio() const override;
113
114     void rewind(double timeDelta);
115     WEBCORE_EXPORT virtual void returnToRealtime() override;
116
117     // Eventually overloaded in HTMLVideoElement
118     virtual bool supportsFullscreen() const override { return false; };
119
120     virtual bool supportsSave() const;
121     virtual bool supportsScanning() const override;
122     
123     virtual bool doesHaveAttribute(const AtomicString&, AtomicString* value = nullptr) const override;
124
125     WEBCORE_EXPORT PlatformMedia platformMedia() const;
126     PlatformLayer* platformLayer() const;
127 #if PLATFORM(IOS)
128     void setVideoFullscreenLayer(PlatformLayer*);
129     void setVideoFullscreenFrame(FloatRect);
130     void setVideoFullscreenGravity(MediaPlayer::VideoGravity);
131 #endif
132
133     enum DelayedActionType {
134         LoadMediaResource = 1 << 0,
135         ConfigureTextTracks = 1 << 1,
136         TextTrackChangesNotification = 1 << 2,
137         ConfigureTextTrackDisplay = 1 << 3,
138     };
139     void scheduleDelayedAction(DelayedActionType);
140     
141     MediaPlayer::MovieLoadType movieLoadType() const;
142     
143     bool inActiveDocument() const { return m_inActiveDocument; }
144     
145 // DOM API
146 // error state
147     PassRefPtr<MediaError> error() const;
148
149     void setSrc(const String&);
150     const URL& currentSrc() const { return m_currentSrc; }
151
152 #if ENABLE(MEDIA_STREAM)
153     MediaStream* srcObject() const { return m_mediaStreamSrcObject.get(); }
154     void setSrcObject(MediaStream*);
155 #endif
156
157 // network state
158     enum NetworkState { NETWORK_EMPTY, NETWORK_IDLE, NETWORK_LOADING, NETWORK_NO_SOURCE };
159     NetworkState networkState() const;
160
161     String preload() const;    
162     void setPreload(const String&);
163
164     virtual PassRefPtr<TimeRanges> buffered() const override;
165     void load();
166     String canPlayType(const String& mimeType, const String& keySystem = String(), const URL& = URL()) const;
167
168 // ready state
169     virtual ReadyState readyState() const override;
170     bool seeking() const;
171
172 // playback state
173     WEBCORE_EXPORT virtual double currentTime() const override;
174     virtual void setCurrentTime(double) override;
175     virtual void setCurrentTime(double, ExceptionCode&);
176     WEBCORE_EXPORT virtual double duration() const override;
177     WEBCORE_EXPORT virtual bool paused() const override;
178     virtual double defaultPlaybackRate() const override;
179     virtual void setDefaultPlaybackRate(double) override;
180     WEBCORE_EXPORT virtual double playbackRate() const override;
181     virtual void setPlaybackRate(double) override;
182
183 // MediaTime versions of playback state
184     MediaTime currentMediaTime() const;
185     void setCurrentTime(const MediaTime&);
186     MediaTime durationMediaTime() const;
187     void fastSeek(const MediaTime&);
188
189     void updatePlaybackRate();
190     bool webkitPreservesPitch() const;
191     void setWebkitPreservesPitch(bool);
192     virtual PassRefPtr<TimeRanges> played() override;
193     virtual PassRefPtr<TimeRanges> seekable() const override;
194     WEBCORE_EXPORT bool ended() const;
195     bool autoplay() const;
196     bool loop() const;    
197     void setLoop(bool b);
198     WEBCORE_EXPORT virtual void play() override;
199     WEBCORE_EXPORT virtual void pause() override;
200     virtual void setShouldBufferData(bool) override;
201     void fastSeek(double);
202     double minFastReverseRate() const;
203     double maxFastForwardRate() const;
204
205 // captions
206     bool webkitHasClosedCaptions() const;
207     bool webkitClosedCaptionsVisible() const;
208     void setWebkitClosedCaptionsVisible(bool);
209
210     virtual bool elementIsHidden() const override { return m_elementIsHidden; }
211
212 #if ENABLE(MEDIA_STATISTICS)
213 // Statistics
214     unsigned webkitAudioDecodedByteCount() const;
215     unsigned webkitVideoDecodedByteCount() const;
216 #endif
217
218 #if ENABLE(MEDIA_SOURCE)
219 //  Media Source.
220     void closeMediaSource();
221     void incrementDroppedFrameCount() { ++m_droppedVideoFrames; }
222     size_t maximumSourceBufferSize(const SourceBuffer&) const;
223 #endif
224
225 #if ENABLE(ENCRYPTED_MEDIA)
226     void webkitGenerateKeyRequest(const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionCode&);
227     void webkitGenerateKeyRequest(const String& keySystem, ExceptionCode&);
228     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initData, const String& sessionId, ExceptionCode&);
229     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, ExceptionCode&);
230     void webkitCancelKeyRequest(const String& keySystem, const String& sessionId, ExceptionCode&);
231
232     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyadded);
233     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyerror);
234     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeymessage);
235 #endif
236 #if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
237     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitneedkey);
238 #endif
239
240 #if ENABLE(ENCRYPTED_MEDIA_V2)
241     MediaKeys* keys() const { return m_mediaKeys.get(); }
242     void setMediaKeys(MediaKeys*);
243 #endif
244
245 // controls
246     bool controls() const;
247     void setControls(bool);
248     WEBCORE_EXPORT virtual double volume() const override;
249     virtual void setVolume(double, ExceptionCode&) override;
250     WEBCORE_EXPORT virtual bool muted() const override;
251     WEBCORE_EXPORT virtual void setMuted(bool) override;
252
253     WEBCORE_EXPORT void togglePlayState();
254     WEBCORE_EXPORT virtual void beginScrubbing() override;
255     WEBCORE_EXPORT virtual void endScrubbing() override;
256
257     virtual void beginScanning(ScanDirection) override;
258     virtual void endScanning() override;
259     double nextScanRate();
260
261     WEBCORE_EXPORT virtual bool canPlay() const override;
262
263     double percentLoaded() const;
264
265     DEFINE_ATTRIBUTE_EVENT_LISTENER(emptied);
266     DEFINE_ATTRIBUTE_EVENT_LISTENER(loadedmetadata);
267     DEFINE_ATTRIBUTE_EVENT_LISTENER(loadeddata);
268     DEFINE_ATTRIBUTE_EVENT_LISTENER(canplay);
269     DEFINE_ATTRIBUTE_EVENT_LISTENER(canplaythrough);
270     DEFINE_ATTRIBUTE_EVENT_LISTENER(playing);
271     DEFINE_ATTRIBUTE_EVENT_LISTENER(ended);
272     DEFINE_ATTRIBUTE_EVENT_LISTENER(waiting);
273     DEFINE_ATTRIBUTE_EVENT_LISTENER(durationchange);
274     DEFINE_ATTRIBUTE_EVENT_LISTENER(timeupdate);
275     DEFINE_ATTRIBUTE_EVENT_LISTENER(play);
276     DEFINE_ATTRIBUTE_EVENT_LISTENER(pause);
277     DEFINE_ATTRIBUTE_EVENT_LISTENER(ratechange);
278     DEFINE_ATTRIBUTE_EVENT_LISTENER(volumechange);
279
280 #if ENABLE(VIDEO_TRACK)
281     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
282     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, ExceptionCode& ec) { return addTextTrack(kind, label, emptyString(), ec); }
283     PassRefPtr<TextTrack> addTextTrack(const String& kind, ExceptionCode& ec) { return addTextTrack(kind, emptyString(), emptyString(), ec); }
284
285     AudioTrackList* audioTracks();
286     TextTrackList* textTracks();
287     VideoTrackList* videoTracks();
288
289     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
290
291     void addAudioTrack(PassRefPtr<AudioTrack>);
292     void addTextTrack(PassRefPtr<TextTrack>);
293     void addVideoTrack(PassRefPtr<VideoTrack>);
294     void removeAudioTrack(AudioTrack*);
295     void removeTextTrack(TextTrack*, bool scheduleEvent = true);
296     void removeVideoTrack(VideoTrack*);
297     void forgetResourceSpecificTracks();
298     void closeCaptionTracksChanged();
299     void notifyMediaPlayerOfTextTrackChanges();
300
301     virtual void didAddTextTrack(HTMLTrackElement*);
302     virtual void didRemoveTextTrack(HTMLTrackElement*);
303
304     virtual void mediaPlayerDidAddAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
305     virtual void mediaPlayerDidAddTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
306     virtual void mediaPlayerDidAddVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
307     virtual void mediaPlayerDidRemoveAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
308     virtual void mediaPlayerDidRemoveTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
309     virtual void mediaPlayerDidRemoveVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
310
311 #if ENABLE(AVF_CAPTIONS)
312     virtual Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources() override;
313 #endif
314
315 #if USE(PLATFORM_TEXT_TRACK_MENU)
316     virtual void setSelectedTextTrack(PassRefPtr<PlatformTextTrack>) override;
317     virtual Vector<RefPtr<PlatformTextTrack>> platformTextTracks() override;
318     PlatformTextTrackMenuInterface* platformTextTrackMenu();
319 #endif
320
321     struct TrackGroup {
322         enum GroupKind { CaptionsAndSubtitles, Description, Chapter, Metadata, Other };
323
324         TrackGroup(GroupKind kind)
325             : visibleTrack(0)
326             , defaultTrack(0)
327             , kind(kind)
328             , hasSrcLang(false)
329         {
330         }
331
332         Vector<RefPtr<TextTrack>> tracks;
333         RefPtr<TextTrack> visibleTrack;
334         RefPtr<TextTrack> defaultTrack;
335         GroupKind kind;
336         bool hasSrcLang;
337     };
338
339     void configureTextTrackGroupForLanguage(const TrackGroup&) const;
340     void configureTextTracks();
341     void configureTextTrackGroup(const TrackGroup&);
342
343     void setSelectedTextTrack(TextTrack*);
344
345     bool textTracksAreReady() const;
346     enum TextTrackVisibilityCheckType { CheckTextTrackVisibility, AssumeTextTrackVisibilityChanged };
347     void configureTextTrackDisplay(TextTrackVisibilityCheckType checkType = CheckTextTrackVisibility);
348     void updateTextTrackDisplay();
349
350     // AudioTrackClient
351     virtual void audioTrackEnabledChanged(AudioTrack*) override;
352
353     // TextTrackClient
354     virtual void textTrackReadyStateChanged(TextTrack*);
355     virtual void textTrackKindChanged(TextTrack*) override;
356     virtual void textTrackModeChanged(TextTrack*) override;
357     virtual void textTrackAddCues(TextTrack*, const TextTrackCueList*) override;
358     virtual void textTrackRemoveCues(TextTrack*, const TextTrackCueList*) override;
359     virtual void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
360     virtual void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
361
362     // VideoTrackClient
363     virtual void videoTrackSelectedChanged(VideoTrack*) override;
364
365     bool requiresTextTrackRepresentation() const;
366     void setTextTrackRepresentation(TextTrackRepresentation*);
367     void syncTextTrackBounds();
368 #endif
369
370 #if ENABLE(IOS_AIRPLAY)
371     void webkitShowPlaybackTargetPicker();
372     bool webkitCurrentPlaybackTargetIsWireless() const;
373
374     virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture) override;
375     virtual bool removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture) override;
376
377     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitcurrentplaybacktargetiswirelesschanged);
378     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitplaybacktargetavailabilitychanged);
379 #endif
380
381     // EventTarget function.
382     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
383     // causes an ambiguity error at compile time. This class's constructor
384     // ensures that both implementations return document, so return the result
385     // of one of them here.
386     using HTMLElement::scriptExecutionContext;
387
388     bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
389     
390     WEBCORE_EXPORT virtual bool isFullscreen() const override;
391     void toggleFullscreenState();
392     virtual void enterFullscreen() override;
393     WEBCORE_EXPORT void exitFullscreen();
394
395     virtual bool hasClosedCaptions() const override;
396     virtual bool closedCaptionsVisible() const override;
397     virtual void setClosedCaptionsVisible(bool) override;
398
399     MediaControls* mediaControls() const;
400
401     void sourceWasRemoved(HTMLSourceElement*);
402     void sourceWasAdded(HTMLSourceElement*);
403
404     virtual void privateBrowsingStateDidChange() override;
405
406     // Media cache management.
407     WEBCORE_EXPORT static void getSitesInMediaCache(Vector<String>&);
408     WEBCORE_EXPORT static void clearMediaCache();
409     WEBCORE_EXPORT static void clearMediaCacheForSite(const String&);
410     static void resetMediaEngines();
411
412     bool isPlaying() const { return m_playing; }
413
414     virtual bool hasPendingActivity() const override;
415
416 #if ENABLE(WEB_AUDIO)
417     MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
418     void setAudioSourceNode(MediaElementAudioSourceNode*);
419
420     AudioSourceProvider* audioSourceProvider();
421 #endif
422
423     enum InvalidURLAction { DoNothing, Complain };
424     bool isSafeToLoadURL(const URL&, InvalidURLAction);
425
426     const String& mediaGroup() const;
427     void setMediaGroup(const String&);
428
429     MediaController* controller() const;
430     void setController(PassRefPtr<MediaController>);
431
432     void enteredOrExitedFullscreen() { configureMediaControls(); }
433
434     unsigned long long fileSize() const;
435
436     void mediaLoadingFailed(MediaPlayer::NetworkState);
437     void mediaLoadingFailedFatally(MediaPlayer::NetworkState);
438
439 #if ENABLE(MEDIA_SOURCE)
440     RefPtr<VideoPlaybackQuality> getVideoPlaybackQuality();
441 #endif
442
443     MediaPlayer::Preload preloadValue() const { return m_preload; }
444     HTMLMediaSession& mediaSession() const { return *m_mediaSession; }
445
446 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
447     void pageScaleFactorChanged();
448 #endif
449
450     MediaControlsHost* mediaControlsHost() { return m_mediaControlsHost.get(); }
451
452 protected:
453     HTMLMediaElement(const QualifiedName&, Document&, bool);
454     virtual ~HTMLMediaElement();
455
456     virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;
457     virtual void finishParsingChildren() override;
458     virtual bool isURLAttribute(const Attribute&) const override;
459     virtual void willAttachRenderers() override;
460     virtual void didAttachRenderers() override;
461
462     virtual void didMoveToNewDocument(Document* oldDocument) override;
463
464     enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
465     DisplayMode displayMode() const { return m_displayMode; }
466     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
467     
468     virtual bool isMediaElement() const override { return true; }
469
470 #if ENABLE(VIDEO_TRACK)
471     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0 || !m_textTracks || !m_cueTree.size(); }
472     void beginIgnoringTrackDisplayUpdateRequests();
473     void endIgnoringTrackDisplayUpdateRequests();
474 #endif
475
476     virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) override;
477
478 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
479     bool mediaControlsDependOnPageScaleFactor() const { return m_mediaControlsDependOnPageScaleFactor; }
480     void setMediaControlsDependOnPageScaleFactor(bool);
481 #endif
482
483 private:
484     void createMediaPlayer();
485
486     virtual bool alwaysCreateUserAgentShadowRoot() const override { return true; }
487
488     virtual bool hasCustomFocusLogic() const override;
489     virtual bool supportsFocus() const override;
490     virtual bool isMouseFocusable() const override;
491     virtual bool rendererIsNeeded(const RenderStyle&) override;
492     virtual bool childShouldCreateRenderer(const Node&) const override;
493     virtual InsertionNotificationRequest insertedInto(ContainerNode&) override;
494     virtual void removedFrom(ContainerNode&) override;
495     virtual void didRecalcStyle(Style::Change) override;
496
497     virtual void didBecomeFullscreenElement() override;
498     virtual void willStopBeingFullscreenElement() override;
499
500     // ActiveDOMObject functions.
501     virtual bool canSuspend() const override;
502     virtual void suspend(ReasonForSuspension) override;
503     virtual void resume() override;
504     virtual void stop() override;
505     
506     virtual void mediaVolumeDidChange() override;
507
508     virtual void visibilityStateChanged() override;
509
510     virtual void updateDisplayState() { }
511     
512     void setReadyState(MediaPlayer::ReadyState);
513     void setNetworkState(MediaPlayer::NetworkState);
514
515     double effectivePlaybackRate() const;
516
517     virtual Document* mediaPlayerOwningDocument() override;
518     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*) override;
519     virtual void mediaPlayerReadyStateChanged(MediaPlayer*) override;
520     virtual void mediaPlayerTimeChanged(MediaPlayer*) override;
521     virtual void mediaPlayerVolumeChanged(MediaPlayer*) override;
522     virtual void mediaPlayerMuteChanged(MediaPlayer*) override;
523     virtual void mediaPlayerDurationChanged(MediaPlayer*) override;
524     virtual void mediaPlayerRateChanged(MediaPlayer*) override;
525     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*) override;
526     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*) override;
527     virtual void mediaPlayerResourceNotSupported(MediaPlayer*) override;
528     virtual void mediaPlayerRepaint(MediaPlayer*) override;
529     virtual void mediaPlayerSizeChanged(MediaPlayer*) override;
530     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) override;
531     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) override;
532     virtual void mediaPlayerEngineUpdated(MediaPlayer*) override;
533     
534     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) override;
535     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) override;
536
537 #if ENABLE(ENCRYPTED_MEDIA)
538     virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& keySystem, const String& sessionId) override;
539     virtual void mediaPlayerKeyError(MediaPlayer*, const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode) override;
540     virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL) override;
541     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength) override;
542 #endif
543
544 #if ENABLE(ENCRYPTED_MEDIA_V2)
545     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) override;
546 #endif
547
548 #if ENABLE(IOS_AIRPLAY)
549     virtual void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) override;
550     virtual void mediaPlayerPlaybackTargetAvailabilityChanged(MediaPlayer*) override;
551     void enqueuePlaybackTargetAvailabilityChangedEvent();
552 #endif
553
554     virtual String mediaPlayerReferrer() const override;
555     virtual String mediaPlayerUserAgent() const override;
556     virtual CORSMode mediaPlayerCORSMode() const override;
557
558     virtual bool mediaPlayerNeedsSiteSpecificHacks() const override;
559     virtual String mediaPlayerDocumentHost() const override;
560
561     virtual void mediaPlayerEnterFullscreen() override;
562     virtual void mediaPlayerExitFullscreen() override;
563     virtual bool mediaPlayerIsFullscreen() const override;
564     virtual bool mediaPlayerIsFullscreenPermitted() const override;
565     virtual bool mediaPlayerIsVideo() const override;
566     virtual LayoutRect mediaPlayerContentBoxRect() const override;
567     virtual void mediaPlayerSetSize(const IntSize&) override;
568     virtual void mediaPlayerPause() override;
569     virtual void mediaPlayerPlay() override;
570     virtual bool mediaPlayerPlatformVolumeConfigurationRequired() const override;
571     virtual bool mediaPlayerIsPaused() const override;
572     virtual bool mediaPlayerIsLooping() const override;
573     virtual HostWindow* mediaPlayerHostWindow() override;
574     virtual IntRect mediaPlayerWindowClipRect() override;
575     virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() override;
576
577 #if PLATFORM(WIN) && USE(AVFOUNDATION)
578     virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const override;
579 #endif
580
581     virtual bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) override;
582     virtual void mediaPlayerHandlePlaybackCommand(MediaSession::RemoteControlCommandType command) override { didReceiveRemoteControlCommand(command); }
583     virtual String mediaPlayerSourceApplicationIdentifier() const;
584
585 #if PLATFORM(IOS)
586     virtual String mediaPlayerNetworkInterfaceName() const;
587     virtual bool mediaPlayerGetRawCookies(const URL&, Vector<Cookie>&) const override;
588 #endif
589
590     void loadTimerFired(Timer<HTMLMediaElement>&);
591     void progressEventTimerFired(Timer<HTMLMediaElement>&);
592     void playbackProgressTimerFired(Timer<HTMLMediaElement>&);
593     void scanTimerFired(Timer<HTMLMediaElement>&);
594     void seekTimerFired(Timer<HTMLMediaElement>&);
595     void startPlaybackProgressTimer();
596     void startProgressEventTimer();
597     void stopPeriodicTimers();
598
599     void seek(const MediaTime&);
600     void seekInternal(const MediaTime&);
601     void seekWithTolerance(const MediaTime&, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance, bool fromDOM);
602     void finishSeek();
603     void checkIfSeekNeeded();
604     void addPlayedRange(const MediaTime& start, const MediaTime& end);
605     
606     void scheduleTimeupdateEvent(bool periodicEvent);
607     void scheduleEvent(const AtomicString& eventName);
608     
609     // loading
610     void selectMediaResource();
611     void loadResource(const URL&, ContentType&, const String& keySystem);
612     void scheduleNextSourceChild();
613     void loadNextSourceChild();
614     void userCancelledLoad();
615     void clearMediaPlayer(int flags);
616     bool havePotentialSourceChild();
617     void noneSupported();
618     void cancelPendingEventsAndCallbacks();
619     void waitForSourceChange();
620     void prepareToPlay();
621
622     URL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
623
624 #if ENABLE(VIDEO_TRACK)
625     void updateActiveTextTrackCues(const MediaTime&);
626     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
627
628     enum ReconfigureMode {
629         Immediately,
630         AfterDelay,
631     };
632     void markCaptionAndSubtitleTracksAsUnconfigured(ReconfigureMode);
633     virtual void captionPreferencesChanged() override;
634 #endif
635
636     // These "internal" functions do not check user gesture restrictions.
637     void loadInternal();
638     void playInternal();
639     void pauseInternal();
640
641     void prepareForLoad();
642     void allowVideoRendering();
643
644     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
645     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
646     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
647
648     void updateVolume();
649     void updatePlayState();
650     bool potentiallyPlaying() const;
651     bool endedPlayback() const;
652     bool stoppedDueToErrors() const;
653     bool pausedForUserInteraction() const;
654     bool couldPlayIfEnoughData() const;
655
656     MediaTime minTimeSeekable() const;
657     MediaTime maxTimeSeekable() const;
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     bool shouldDisableSleep() const;
690
691 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
692     virtual void didAddUserAgentShadowRoot(ShadowRoot*) override;
693     DOMWrapperWorld& ensureIsolatedWorld();
694     bool ensureMediaControlsInjectedScript();
695 #endif
696
697     // MediaSessionClient Overrides
698     virtual MediaSession::MediaType mediaType() const override;
699     virtual MediaSession::MediaType presentationType() const override;
700     virtual void pausePlayback() override;
701     virtual void resumePlayback() override;
702     virtual String mediaSessionTitle() const override;
703     virtual double mediaSessionDuration() const override { return duration(); }
704     virtual double mediaSessionCurrentTime() const override { return currentTime(); }
705     virtual bool canReceiveRemoteControlCommands() const override { return true; }
706     virtual void didReceiveRemoteControlCommand(MediaSession::RemoteControlCommandType) override;
707     virtual bool overrideBackgroundPlaybackRestriction() const override;
708
709     void registerWithDocument(Document&);
710     void unregisterWithDocument(Document&);
711
712     void updateCaptionContainer();
713
714     Timer<HTMLMediaElement> m_loadTimer;
715     Timer<HTMLMediaElement> m_progressEventTimer;
716     Timer<HTMLMediaElement> m_playbackProgressTimer;
717     Timer<HTMLMediaElement> m_scanTimer;
718     Timer<HTMLMediaElement> m_seekTimer;
719     RefPtr<TimeRanges> m_playedTimeRanges;
720     GenericEventQueue m_asyncEventQueue;
721
722     double m_playbackRate;
723     double m_defaultPlaybackRate;
724     bool m_webkitPreservesPitch;
725     NetworkState m_networkState;
726     ReadyState m_readyState;
727     ReadyState m_readyStateMaximum;
728     URL m_currentSrc;
729
730     RefPtr<MediaError> m_error;
731
732     struct PendingSeek {
733         PendingSeek(const MediaTime& now, const MediaTime& targetTime, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance)
734             : now(now)
735             , targetTime(targetTime)
736             , negativeTolerance(negativeTolerance)
737             , positiveTolerance(positiveTolerance)
738         {
739         }
740         MediaTime now;
741         MediaTime targetTime;
742         MediaTime negativeTolerance;
743         MediaTime positiveTolerance;
744     };
745     std::unique_ptr<PendingSeek> m_pendingSeek;
746
747     double m_volume;
748     bool m_volumeInitialized;
749     MediaTime m_lastSeekTime;
750     
751     unsigned m_previousProgress;
752     double m_previousProgressTime;
753
754     // The last time a timeupdate event was sent (based on monotonic clock).
755     double m_clockTimeAtLastUpdateEvent;
756
757     // The last time a timeupdate event was sent in movie time.
758     MediaTime m_lastTimeUpdateEventMovieTime;
759     
760     // Loading state.
761     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
762     LoadState m_loadState;
763     RefPtr<HTMLSourceElement> m_currentSourceNode;
764     RefPtr<Node> m_nextChildNodeToConsider;
765
766 #if PLATFORM(IOS)
767     RetainPtr<PlatformLayer> m_videoFullscreenLayer;
768     FloatRect m_videoFullscreenFrame;
769     MediaPlayer::VideoGravity m_videoFullscreenGravity;
770 #endif
771
772     OwnPtr<MediaPlayer> m_player;
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 MediaTime m_cachedTime;
788     mutable double m_clockTimeAtLastCachedTimeUpdate;
789     mutable double m_minimumClockTimeToUpdateCachedTime;
790
791     MediaTime m_fragmentStartTime;
792     MediaTime 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_isInVideoFullscreen : 1;
830     bool m_closedCaptionsVisible : 1;
831     bool m_webkitLegacyClosedCaptionOverride : 1;
832     bool m_completelyLoaded : 1;
833     bool m_havePreparedToPlay : 1;
834     bool m_parsingInProgress : 1;
835     bool m_elementIsHidden : 1;
836
837 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
838     bool m_mediaControlsDependOnPageScaleFactor : 1;
839 #endif
840
841 #if ENABLE(VIDEO_TRACK)
842     bool m_tracksAreReady : 1;
843     bool m_haveVisibleTextTrack : 1;
844     bool m_processingPreferenceChange : 1;
845
846     String m_subtitleTrackLanguage;
847     MediaTime m_lastTextTrackUpdateTime;
848
849     CaptionUserPreferences::CaptionDisplayMode m_captionDisplayMode;
850
851     RefPtr<AudioTrackList> m_audioTracks;
852     RefPtr<TextTrackList> m_textTracks;
853     RefPtr<VideoTrackList> m_videoTracks;
854     Vector<RefPtr<TextTrack>> m_textTracksWhenResourceSelectionBegan;
855
856     CueIntervalTree m_cueTree;
857
858     CueList m_currentlyActiveCues;
859     int m_ignoreTrackDisplayUpdate;
860 #endif
861
862 #if ENABLE(WEB_AUDIO)
863     // This is a weak reference, since m_audioSourceNode holds a reference to us.
864     // The value is set just after the MediaElementAudioSourceNode is created.
865     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
866     MediaElementAudioSourceNode* m_audioSourceNode;
867 #endif
868
869     String m_mediaGroup;
870     friend class MediaController;
871     RefPtr<MediaController> m_mediaController;
872
873     std::unique_ptr<DisplaySleepDisabler> m_sleepDisabler;
874
875     friend class TrackDisplayUpdateScope;
876
877 #if ENABLE(ENCRYPTED_MEDIA_V2)
878     RefPtr<MediaKeys> m_mediaKeys;
879 #endif
880
881 #if USE(PLATFORM_TEXT_TRACK_MENU)
882     RefPtr<PlatformTextTrackMenuInterface> m_platformMenu;
883 #endif
884
885     std::unique_ptr<HTMLMediaSession> m_mediaSession;
886     std::unique_ptr<PageActivityAssertionToken> m_activityToken;
887     size_t m_reportedExtraMemoryCost;
888
889 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
890     friend class MediaControlsHost;
891     RefPtr<MediaControlsHost> m_mediaControlsHost;
892     RefPtr<DOMWrapperWorld> m_isolatedWorld;
893 #endif
894
895 #if ENABLE(MEDIA_STREAM)
896     RefPtr<MediaStream> m_mediaStreamSrcObject;
897 #endif
898 };
899
900 #if ENABLE(VIDEO_TRACK)
901 #ifndef NDEBUG
902 // Template specialization required by PodIntervalTree in debug mode.
903 template <>
904 struct ValueToString<TextTrackCue*> {
905     static String string(TextTrackCue* const& cue)
906     {
907         String text;
908         if (cue->isRenderable())
909             text = toVTTCue(cue)->text();
910         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());
911     }
912 };
913 #endif
914 #endif
915
916 void isHTMLMediaElement(const HTMLMediaElement&); // Catch unnecessary runtime check of type known at compile time.
917 inline bool isHTMLMediaElement(const Element& element) { return element.isMediaElement(); }
918 inline bool isHTMLMediaElement(const Node& node) { return node.isElementNode() && toElement(node).isMediaElement(); }
919
920 template <typename ArgType>
921 struct ElementTypeCastTraits<const HTMLMediaElement, ArgType> {
922     static bool is(ArgType& node) { return isHTMLMediaElement(node); }
923 };
924
925 NODE_TYPE_CASTS(HTMLMediaElement)
926
927 #ifndef NDEBUG
928 template<>
929 struct ValueToString<MediaTime> {
930     static String string(const MediaTime& time)
931     {
932         return toString(time);
933     }
934 };
935 #endif
936
937 } //namespace
938
939 #endif
940 #endif