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