f7d840def6c9d32c4e691da8b91a0e65ffbd53fb
[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 "MediaCanStartListener.h"
34 #include "MediaControllerInterface.h"
35 #include "MediaPlayer.h"
36
37 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
38 #include "HTMLFrameOwnerElement.h"
39 #include "HTMLPlugInImageElement.h"
40 #include "MediaPlayerProxy.h"
41 #endif
42
43 #if ENABLE(VIDEO_TRACK)
44 #include "AudioTrack.h"
45 #include "CaptionUserPreferences.h"
46 #include "PODIntervalTree.h"
47 #include "TextTrack.h"
48 #include "TextTrackCue.h"
49 #include "VideoTrack.h"
50 #endif
51
52 #if ENABLE(MEDIA_STREAM)
53 #include "MediaStream.h"
54 #endif
55
56 #if USE(AUDIO_SESSION)
57 #include "MediaSessionManager.h"
58 #endif
59
60 namespace WebCore {
61
62 #if ENABLE(WEB_AUDIO)
63 class AudioSourceProvider;
64 class MediaElementAudioSourceNode;
65 #endif
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 PLATFORM(MAC)
80 class DisplaySleepDisabler;
81 #endif
82 #if ENABLE(ENCRYPTED_MEDIA_V2)
83 class MediaKeys;
84 #endif
85 #if ENABLE(MEDIA_SOURCE)
86 class VideoPlaybackQuality;
87 #endif
88
89 #if ENABLE(VIDEO_TRACK)
90 class AudioTrackList;
91 class AudioTrackPrivate;
92 class InbandTextTrackPrivate;
93 class TextTrackList;
94 class VideoTrackList;
95 class VideoTrackPrivate;
96
97 typedef PODIntervalTree<double, TextTrackCue*> CueIntervalTree;
98 typedef CueIntervalTree::IntervalType CueInterval;
99 typedef Vector<CueInterval> CueList;
100 #endif
101
102 class HTMLMediaElement
103 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
104     : public HTMLFrameOwnerElement
105 #else
106     : public HTMLElement
107 #endif
108     , private MediaPlayerClient, public MediaPlayerSupportsTypeClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface
109 #if ENABLE(VIDEO_TRACK)
110     , private AudioTrackClient
111     , private TextTrackClient
112     , private VideoTrackClient
113 #endif
114 #if USE(PLATFORM_TEXT_TRACK_MENU)
115     , public PlatformTextTrackMenuClient
116 #endif
117 #if USE(AUDIO_SESSION)
118     , public MediaSessionManagerClient
119 #endif
120 {
121 public:
122     MediaPlayer* player() const { return m_player.get(); }
123
124     virtual bool isVideo() const { return false; }
125     virtual bool hasVideo() const OVERRIDE { return false; }
126     virtual bool hasAudio() const OVERRIDE;
127
128     void rewind(double timeDelta);
129     virtual void returnToRealtime() OVERRIDE;
130
131     // Eventually overloaded in HTMLVideoElement
132     virtual bool supportsFullscreen() const OVERRIDE { return false; };
133
134     virtual bool supportsSave() const;
135     virtual bool supportsScanning() const OVERRIDE;
136     
137     PlatformMedia platformMedia() const;
138 #if USE(ACCELERATED_COMPOSITING)
139     PlatformLayer* platformLayer() const;
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 double duration() const OVERRIDE;
185     virtual bool paused() const OVERRIDE;
186     virtual double defaultPlaybackRate() const OVERRIDE;
187     virtual void setDefaultPlaybackRate(double) OVERRIDE;
188     virtual double playbackRate() const OVERRIDE;
189     virtual void setPlaybackRate(double) OVERRIDE;
190     void updatePlaybackRate();
191     bool webkitPreservesPitch() const;
192     void setWebkitPreservesPitch(bool);
193     virtual PassRefPtr<TimeRanges> played() OVERRIDE;
194     virtual PassRefPtr<TimeRanges> seekable() const OVERRIDE;
195     bool ended() const;
196     bool autoplay() const;
197     bool loop() const;    
198     void setLoop(bool b);
199     virtual void play() OVERRIDE;
200     virtual void pause() OVERRIDE;
201     void fastSeek(double);
202
203 // captions
204     bool webkitHasClosedCaptions() const;
205     bool webkitClosedCaptionsVisible() const;
206     void setWebkitClosedCaptionsVisible(bool);
207
208 #if ENABLE(MEDIA_STATISTICS)
209 // Statistics
210     unsigned webkitAudioDecodedByteCount() const;
211     unsigned webkitVideoDecodedByteCount() const;
212 #endif
213
214 #if ENABLE(MEDIA_SOURCE)
215 //  Media Source.
216     void closeMediaSource();
217     void incrementDroppedFrameCount() { ++m_droppedVideoFrames; }
218 #endif
219
220 #if ENABLE(ENCRYPTED_MEDIA)
221     void webkitGenerateKeyRequest(const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionCode&);
222     void webkitGenerateKeyRequest(const String& keySystem, ExceptionCode&);
223     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initData, const String& sessionId, ExceptionCode&);
224     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, ExceptionCode&);
225     void webkitCancelKeyRequest(const String& keySystem, const String& sessionId, ExceptionCode&);
226
227     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyadded);
228     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyerror);
229     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeymessage);
230 #endif
231 #if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
232     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitneedkey);
233 #endif
234
235 #if ENABLE(ENCRYPTED_MEDIA_V2)
236     MediaKeys* keys() const { return m_mediaKeys.get(); }
237     void setMediaKeys(MediaKeys*);
238 #endif
239
240 // controls
241     bool controls() const;
242     void setControls(bool);
243     virtual double volume() const OVERRIDE;
244     virtual void setVolume(double, ExceptionCode&) OVERRIDE;
245     virtual bool muted() const OVERRIDE;
246     virtual void setMuted(bool) OVERRIDE;
247
248     void togglePlayState();
249     virtual void beginScrubbing() OVERRIDE;
250     virtual void endScrubbing() OVERRIDE;
251     
252     virtual bool canPlay() const OVERRIDE;
253
254     double percentLoaded() const;
255
256 #if ENABLE(VIDEO_TRACK)
257     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
258     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, ExceptionCode& ec) { return addTextTrack(kind, label, emptyString(), ec); }
259     PassRefPtr<TextTrack> addTextTrack(const String& kind, ExceptionCode& ec) { return addTextTrack(kind, emptyString(), emptyString(), ec); }
260
261     AudioTrackList* audioTracks();
262     TextTrackList* textTracks();
263     VideoTrackList* videoTracks();
264
265     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
266
267     void addAudioTrack(PassRefPtr<AudioTrack>);
268     void addTextTrack(PassRefPtr<TextTrack>);
269     void addVideoTrack(PassRefPtr<VideoTrack>);
270     void removeAudioTrack(AudioTrack*);
271     void removeTextTrack(TextTrack*);
272     void removeVideoTrack(VideoTrack*);
273     void removeAllInbandTracks();
274     void closeCaptionTracksChanged();
275     void notifyMediaPlayerOfTextTrackChanges();
276
277     virtual void didAddTextTrack(HTMLTrackElement*);
278     virtual void didRemoveTextTrack(HTMLTrackElement*);
279
280     virtual void mediaPlayerDidAddAudioTrack(PassRefPtr<AudioTrackPrivate>) OVERRIDE;
281     virtual void mediaPlayerDidAddTextTrack(PassRefPtr<InbandTextTrackPrivate>) OVERRIDE;
282     virtual void mediaPlayerDidAddVideoTrack(PassRefPtr<VideoTrackPrivate>) OVERRIDE;
283     virtual void mediaPlayerDidRemoveAudioTrack(PassRefPtr<AudioTrackPrivate>) OVERRIDE;
284     virtual void mediaPlayerDidRemoveTextTrack(PassRefPtr<InbandTextTrackPrivate>) OVERRIDE;
285     virtual void mediaPlayerDidRemoveVideoTrack(PassRefPtr<VideoTrackPrivate>) OVERRIDE;
286
287 #if USE(PLATFORM_TEXT_TRACK_MENU)
288     virtual void setSelectedTextTrack(PassRefPtr<PlatformTextTrack>) OVERRIDE;
289     virtual Vector<RefPtr<PlatformTextTrack>> platformTextTracks() OVERRIDE;
290     PlatformTextTrackMenuInterface* platformTextTrackMenu();
291 #endif
292
293     struct TrackGroup {
294         enum GroupKind { CaptionsAndSubtitles, Description, Chapter, Metadata, Other };
295
296         TrackGroup(GroupKind kind)
297             : visibleTrack(0)
298             , defaultTrack(0)
299             , kind(kind)
300             , hasSrcLang(false)
301         {
302         }
303
304         Vector<RefPtr<TextTrack>> tracks;
305         RefPtr<TextTrack> visibleTrack;
306         RefPtr<TextTrack> defaultTrack;
307         GroupKind kind;
308         bool hasSrcLang;
309     };
310
311     void configureTextTrackGroupForLanguage(const TrackGroup&) const;
312     void configureTextTracks();
313     void configureTextTrackGroup(const TrackGroup&);
314
315     void setSelectedTextTrack(TextTrack*);
316
317     bool textTracksAreReady() const;
318     enum TextTrackVisibilityCheckType { CheckTextTrackVisibility, AssumeTextTrackVisibilityChanged };
319     void configureTextTrackDisplay(TextTrackVisibilityCheckType checkType = CheckTextTrackVisibility);
320     void updateTextTrackDisplay();
321
322     // AudioTrackClient
323     virtual void audioTrackEnabledChanged(AudioTrack*) OVERRIDE;
324
325     // TextTrackClient
326     virtual void textTrackReadyStateChanged(TextTrack*);
327     virtual void textTrackKindChanged(TextTrack*) OVERRIDE;
328     virtual void textTrackModeChanged(TextTrack*) OVERRIDE;
329     virtual void textTrackAddCues(TextTrack*, const TextTrackCueList*) OVERRIDE;
330     virtual void textTrackRemoveCues(TextTrack*, const TextTrackCueList*) OVERRIDE;
331     virtual void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>) OVERRIDE;
332     virtual void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>) OVERRIDE;
333
334     // VideoTrackClient
335     virtual void videoTrackSelectedChanged(VideoTrack*) OVERRIDE;
336
337     bool requiresTextTrackRepresentation() const;
338     void setTextTrackRepresentation(TextTrackRepresentation*);
339 #endif
340
341 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
342     void ensureMediaPlayer();
343     void setNeedWidgetUpdate(bool needWidgetUpdate) { m_needWidgetUpdate = needWidgetUpdate; }
344     void deliverNotification(MediaPlayerProxyNotificationType notification);
345     void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
346     void getPluginProxyParams(URL& url, Vector<String>& names, Vector<String>& values);
347     void createMediaPlayerProxy();
348     void updateWidget(PluginCreationOption);
349 #endif
350
351 #if ENABLE(IOS_AIRPLAY)
352     void webkitShowPlaybackTargetPicker();
353     bool webkitCurrentPlaybackTargetIsWireless() const;
354
355     virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture) OVERRIDE;
356     virtual bool removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture) OVERRIDE;
357
358     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitcurrentplaybacktargetiswirelesschanged);
359     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitplaybacktargetavailabilitychanged);
360 #endif
361
362     // EventTarget function.
363     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
364     // causes an ambiguity error at compile time. This class's constructor
365     // ensures that both implementations return document, so return the result
366     // of one of them here.
367     using HTMLElement::scriptExecutionContext;
368
369     bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
370     
371     virtual bool isFullscreen() const OVERRIDE;
372     void toggleFullscreenState();
373     virtual void enterFullscreen() OVERRIDE;
374     void exitFullscreen();
375
376     virtual bool hasClosedCaptions() const OVERRIDE;
377     virtual bool closedCaptionsVisible() const OVERRIDE;
378     virtual void setClosedCaptionsVisible(bool) OVERRIDE;
379
380     MediaControls* mediaControls() const;
381
382     void sourceWasRemoved(HTMLSourceElement*);
383     void sourceWasAdded(HTMLSourceElement*);
384
385     virtual void privateBrowsingStateDidChange() OVERRIDE;
386
387     // Media cache management.
388     static void getSitesInMediaCache(Vector<String>&);
389     static void clearMediaCache();
390     static void clearMediaCacheForSite(const String&);
391     static void resetMediaEngines();
392
393     bool isPlaying() const { return m_playing; }
394
395     virtual bool hasPendingActivity() const OVERRIDE;
396
397 #if ENABLE(WEB_AUDIO)
398     MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
399     void setAudioSourceNode(MediaElementAudioSourceNode*);
400
401     AudioSourceProvider* audioSourceProvider();
402 #endif
403
404     enum InvalidURLAction { DoNothing, Complain };
405     bool isSafeToLoadURL(const URL&, InvalidURLAction);
406
407     const String& mediaGroup() const;
408     void setMediaGroup(const String&);
409
410     MediaController* controller() const;
411     void setController(PassRefPtr<MediaController>);
412
413 #if !PLATFORM(IOS)
414     virtual bool willRespondToMouseClickEvents() OVERRIDE;
415 #endif
416
417     void enteredOrExitedFullscreen() { configureMediaControls(); }
418
419 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
420     bool shouldUseVideoPluginProxy() const;
421 #endif
422
423     unsigned long long fileSize() const;
424
425     void mediaLoadingFailed(MediaPlayer::NetworkState);
426     void mediaLoadingFailedFatally(MediaPlayer::NetworkState);
427
428 #if ENABLE(MEDIA_SOURCE)
429     RefPtr<VideoPlaybackQuality> getVideoPlaybackQuality();
430 #endif
431
432 protected:
433     HTMLMediaElement(const QualifiedName&, Document&, bool);
434     virtual ~HTMLMediaElement();
435
436     virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
437     virtual void finishParsingChildren() OVERRIDE;
438     virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
439     virtual void willAttachRenderers() OVERRIDE;
440     virtual void didAttachRenderers() OVERRIDE;
441
442     virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;
443
444     enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
445     DisplayMode displayMode() const { return m_displayMode; }
446     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
447     
448     virtual bool isMediaElement() const OVERRIDE { return true; }
449
450     // Restrictions to change default behaviors.
451     enum BehaviorRestrictionFlags {
452         NoRestrictions = 0,
453         RequireUserGestureForLoadRestriction = 1 << 0,
454         RequireUserGestureForRateChangeRestriction = 1 << 1,
455         RequireUserGestureForFullscreenRestriction = 1 << 2,
456         RequirePageConsentToLoadMediaRestriction = 1 << 3,
457         RequirePageConsentToResumeMediaRestriction = 1 << 4,
458 #if ENABLE(IOS_AIRPLAY)
459         RequireUserGestureToShowPlaybackTargetPicker = 1 << 5,
460 #endif
461     };
462     typedef unsigned BehaviorRestrictions;
463     
464     bool userGestureRequiredForLoad() const { return m_restrictions & RequireUserGestureForLoadRestriction; }
465     bool userGestureRequiredForRateChange() const { return m_restrictions & RequireUserGestureForRateChangeRestriction; }
466     bool userGestureRequiredForFullscreen() const { return m_restrictions & RequireUserGestureForFullscreenRestriction; }
467     bool pageConsentRequiredForLoad() const { return m_restrictions & RequirePageConsentToLoadMediaRestriction; }
468     bool pageConsentRequiredForResume() const { return m_restrictions & RequirePageConsentToResumeMediaRestriction; }
469 #if ENABLE(IOS_AIRPLAY)
470     bool userGestureRequiredToShowPlaybackTargetPicker() const { return m_restrictions & RequireUserGestureToShowPlaybackTargetPicker; }
471 #endif
472     
473     void addBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions |= restriction; }
474     void removeBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions &= ~restriction; }
475
476 #if ENABLE(VIDEO_TRACK)
477     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0 || !m_textTracks || !m_cueTree.size(); }
478     void beginIgnoringTrackDisplayUpdateRequests();
479     void endIgnoringTrackDisplayUpdateRequests();
480 #endif
481
482     virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
483
484 private:
485     void createMediaPlayer();
486
487     virtual bool alwaysCreateUserAgentShadowRoot() const OVERRIDE { return true; }
488     virtual bool areAuthorShadowsAllowed() const OVERRIDE { return false; }
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 #if USE(ACCELERATED_COMPOSITING)
535     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) OVERRIDE;
536     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) OVERRIDE;
537 #endif
538     virtual void mediaPlayerEngineUpdated(MediaPlayer*) OVERRIDE;
539     
540     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) OVERRIDE;
541     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) OVERRIDE;
542
543 #if ENABLE(ENCRYPTED_MEDIA)
544     virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& keySystem, const String& sessionId) OVERRIDE;
545     virtual void mediaPlayerKeyError(MediaPlayer*, const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode) OVERRIDE;
546     virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL) OVERRIDE;
547     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength) OVERRIDE;
548 #endif
549
550 #if ENABLE(ENCRYPTED_MEDIA_V2)
551     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) OVERRIDE;
552 #endif
553
554 #if ENABLE(IOS_AIRPLAY)
555     virtual void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) OVERRIDE;
556     virtual void mediaPlayerPlaybackTargetAvailabilityChanged(MediaPlayer*) OVERRIDE;
557     void enqueuePlaybackTargetAvailabilityChangedEvent();
558 #endif
559
560     virtual String mediaPlayerReferrer() const OVERRIDE;
561     virtual String mediaPlayerUserAgent() const OVERRIDE;
562     virtual CORSMode mediaPlayerCORSMode() const OVERRIDE;
563
564     virtual bool mediaPlayerNeedsSiteSpecificHacks() const OVERRIDE;
565     virtual String mediaPlayerDocumentHost() const OVERRIDE;
566
567     virtual void mediaPlayerEnterFullscreen() OVERRIDE;
568     virtual void mediaPlayerExitFullscreen() OVERRIDE;
569     virtual bool mediaPlayerIsFullscreen() const OVERRIDE;
570     virtual bool mediaPlayerIsFullscreenPermitted() const OVERRIDE;
571     virtual bool mediaPlayerIsVideo() const OVERRIDE;
572     virtual LayoutRect mediaPlayerContentBoxRect() const OVERRIDE;
573     virtual void mediaPlayerSetSize(const IntSize&) OVERRIDE;
574     virtual void mediaPlayerPause() OVERRIDE;
575     virtual void mediaPlayerPlay() OVERRIDE;
576     virtual bool mediaPlayerPlatformVolumeConfigurationRequired() const OVERRIDE;
577     virtual bool mediaPlayerIsPaused() const OVERRIDE;
578     virtual bool mediaPlayerIsLooping() const OVERRIDE;
579     virtual HostWindow* mediaPlayerHostWindow() OVERRIDE;
580     virtual IntRect mediaPlayerWindowClipRect() OVERRIDE;
581     virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() OVERRIDE;
582
583 #if PLATFORM(WIN) && USE(AVFOUNDATION)
584     virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const OVERRIDE;
585 #endif
586
587     virtual bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) OVERRIDE;
588
589     void loadTimerFired(Timer<HTMLMediaElement>*);
590     void progressEventTimerFired(Timer<HTMLMediaElement>*);
591     void playbackProgressTimerFired(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     void userRequestsMediaLoading();
658 #endif
659
660     // Pauses playback without changing any states or generating events
661     void setPausedInternal(bool);
662
663     void setPlaybackRateInternal(double);
664
665     virtual void mediaCanStart() OVERRIDE;
666
667     void setShouldDelayLoadEvent(bool);
668     void invalidateCachedTime();
669     void refreshCachedTime() const;
670
671     bool hasMediaControls() const;
672     bool createMediaControls();
673     void configureMediaControls();
674
675     void prepareMediaFragmentURI();
676     void applyMediaFragmentURI();
677
678     void changeNetworkStateFromLoadingToIdle();
679
680     void removeBehaviorsRestrictionsAfterFirstUserGesture();
681
682     void updateMediaController();
683     bool isBlocked() const;
684     bool isBlockedOnMediaController() const;
685     virtual bool hasCurrentSrc() const OVERRIDE { return !m_currentSrc.isEmpty(); }
686     virtual bool isLiveStream() const OVERRIDE { return movieLoadType() == MediaPlayer::LiveStream; }
687     bool isAutoplaying() const { return m_autoplaying; }
688
689     void updateSleepDisabling();
690 #if PLATFORM(MAC)
691     bool shouldDisableSleep() const;
692 #endif
693
694 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
695     virtual void didAddUserAgentShadowRoot(ShadowRoot*) OVERRIDE;
696     DOMWrapperWorld& ensureIsolatedWorld();
697     bool ensureMediaControlsInjectedScript();
698 #endif
699
700 #if USE(AUDIO_SESSION)
701     virtual MediaSessionManager::MediaType mediaType() const OVERRIDE;
702 #endif
703
704     Timer<HTMLMediaElement> m_loadTimer;
705     Timer<HTMLMediaElement> m_progressEventTimer;
706     Timer<HTMLMediaElement> m_playbackProgressTimer;
707     RefPtr<TimeRanges> m_playedTimeRanges;
708     GenericEventQueue m_asyncEventQueue;
709
710     double m_playbackRate;
711     double m_defaultPlaybackRate;
712     bool m_webkitPreservesPitch;
713     NetworkState m_networkState;
714     ReadyState m_readyState;
715     ReadyState m_readyStateMaximum;
716     URL m_currentSrc;
717
718     RefPtr<MediaError> m_error;
719
720     double m_volume;
721     bool m_volumeInitialized;
722     double m_lastSeekTime;
723     
724     unsigned m_previousProgress;
725     double m_previousProgressTime;
726
727     // The last time a timeupdate event was sent (based on monotonic clock).
728     double m_clockTimeAtLastUpdateEvent;
729
730     // The last time a timeupdate event was sent in movie time.
731     double m_lastTimeUpdateEventMovieTime;
732     
733     // Loading state.
734     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
735     LoadState m_loadState;
736     RefPtr<HTMLSourceElement> m_currentSourceNode;
737     RefPtr<Node> m_nextChildNodeToConsider;
738
739     OwnPtr<MediaPlayer> m_player;
740 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
741     RefPtr<Widget> m_proxyWidget;
742 #endif
743
744     BehaviorRestrictions m_restrictions;
745     
746     MediaPlayer::Preload m_preload;
747
748     DisplayMode m_displayMode;
749
750     // Counter incremented while processing a callback from the media player, so we can avoid
751     // calling the media engine recursively.
752     int m_processingMediaPlayerCallback;
753
754 #if ENABLE(MEDIA_SOURCE)
755     RefPtr<HTMLMediaSource> m_mediaSource;
756     unsigned long m_droppedVideoFrames;
757 #endif
758
759     mutable double m_cachedTime;
760     mutable double m_clockTimeAtLastCachedTimeUpdate;
761     mutable double m_minimumClockTimeToUpdateCachedTime;
762
763     double m_fragmentStartTime;
764     double m_fragmentEndTime;
765
766     typedef unsigned PendingActionFlags;
767     PendingActionFlags m_pendingActionFlags;
768
769     bool m_playing : 1;
770     bool m_isWaitingUntilMediaCanStart : 1;
771     bool m_shouldDelayLoadEvent : 1;
772     bool m_haveFiredLoadedData : 1;
773     bool m_inActiveDocument : 1;
774     bool m_autoplaying : 1;
775     bool m_muted : 1;
776     bool m_paused : 1;
777     bool m_seeking : 1;
778
779     // data has not been loaded since sending a "stalled" event
780     bool m_sentStalledEvent : 1;
781
782     // time has not changed since sending an "ended" event
783     bool m_sentEndEvent : 1;
784
785     bool m_pausedInternal : 1;
786
787     // Not all media engines provide enough information about a file to be able to
788     // support progress events so setting m_sendProgressEvents disables them 
789     bool m_sendProgressEvents : 1;
790
791     bool m_isFullscreen : 1;
792     bool m_closedCaptionsVisible : 1;
793     bool m_webkitLegacyClosedCaptionOverride : 1;
794
795 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
796     bool m_needWidgetUpdate : 1;
797 #endif
798
799     bool m_loadInitiatedByUserGesture : 1;
800     bool m_completelyLoaded : 1;
801     bool m_havePreparedToPlay : 1;
802     bool m_parsingInProgress : 1;
803 #if ENABLE(PAGE_VISIBILITY_API)
804     bool m_isDisplaySleepDisablingSuspended : 1;
805 #endif
806
807 #if PLATFORM(IOS)
808     bool m_requestingPlay : 1;
809     bool m_userStartedPlayback : 1;
810 #endif
811
812 #if ENABLE(VIDEO_TRACK)
813     bool m_tracksAreReady : 1;
814     bool m_haveVisibleTextTrack : 1;
815     bool m_processingPreferenceChange : 1;
816
817     String m_subtitleTrackLanguage;
818     float m_lastTextTrackUpdateTime;
819
820     CaptionUserPreferences::CaptionDisplayMode m_captionDisplayMode;
821
822     RefPtr<AudioTrackList> m_audioTracks;
823     RefPtr<TextTrackList> m_textTracks;
824     RefPtr<VideoTrackList> m_videoTracks;
825     Vector<RefPtr<TextTrack>> m_textTracksWhenResourceSelectionBegan;
826
827     CueIntervalTree m_cueTree;
828
829     CueList m_currentlyActiveCues;
830     int m_ignoreTrackDisplayUpdate;
831 #endif
832
833 #if ENABLE(WEB_AUDIO)
834     // This is a weak reference, since m_audioSourceNode holds a reference to us.
835     // The value is set just after the MediaElementAudioSourceNode is created.
836     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
837     MediaElementAudioSourceNode* m_audioSourceNode;
838 #endif
839
840     String m_mediaGroup;
841     friend class MediaController;
842     RefPtr<MediaController> m_mediaController;
843
844 #if PLATFORM(MAC)
845     OwnPtr<DisplaySleepDisabler> m_sleepDisabler;
846 #endif
847
848     friend class TrackDisplayUpdateScope;
849
850 #if ENABLE(ENCRYPTED_MEDIA_V2)
851     RefPtr<MediaKeys> m_mediaKeys;
852 #endif
853
854 #if USE(PLATFORM_TEXT_TRACK_MENU)
855     RefPtr<PlatformTextTrackMenuInterface> m_platformMenu;
856 #endif
857
858 #if USE(AUDIO_SESSION)
859     std::unique_ptr<MediaSessionManagerToken> m_mediaSessionManagerToken;
860 #endif
861
862     std::unique_ptr<PageActivityAssertionToken> m_activityToken;
863     size_t m_reportedExtraMemoryCost;
864
865 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
866     RefPtr<MediaControlsHost> m_mediaControlsHost;
867     RefPtr<DOMWrapperWorld> m_isolatedWorld;
868 #endif
869
870 #if ENABLE(MEDIA_STREAM)
871     RefPtr<MediaStream> m_mediaStreamSrcObject;
872 #endif
873 };
874
875 #if ENABLE(VIDEO_TRACK)
876 #ifndef NDEBUG
877 // Template specialization required by PodIntervalTree in debug mode.
878 template <>
879 struct ValueToString<TextTrackCue*> {
880     static String string(TextTrackCue* const& cue)
881     {
882         return String::format("%p id=%s interval=%f-->%f cue=%s)", cue, cue->id().utf8().data(), cue->startTime(), cue->endTime(), cue->text().utf8().data());
883     }
884 };
885 #endif
886 #endif
887
888 void isHTMLMediaElement(const HTMLMediaElement&); // Catch unnecessary runtime check of type known at compile time.
889 inline bool isHTMLMediaElement(const Element& element) { return element.isMediaElement(); }
890 inline bool isHTMLMediaElement(const Node& node) { return node.isElementNode() && toElement(node).isMediaElement(); }
891 template <> inline bool isElementOfType<const HTMLMediaElement>(const Element& element) { return element.isMediaElement(); }
892
893 NODE_TYPE_CASTS(HTMLMediaElement)
894
895 } //namespace
896
897 #endif
898 #endif