EME v0.1: Report defaultURL in KeyMessage.
[WebKit-https.git] / Source / WebCore / html / HTMLMediaElement.h
1 /*
2  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012 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
31 #include "HTMLElement.h"
32 #include "ActiveDOMObject.h"
33 #include "GenericEventQueue.h"
34 #include "MediaCanStartListener.h"
35 #include "MediaControllerInterface.h"
36 #include "MediaPlayer.h"
37
38 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
39 #include "MediaPlayerProxy.h"
40 #endif
41
42 #if ENABLE(VIDEO_TRACK)
43 #include "CaptionUserPreferences.h"
44 #include "PODIntervalTree.h"
45 #include "TextTrack.h"
46 #include "TextTrackCue.h"
47 #endif
48
49 namespace WebCore {
50
51 #if ENABLE(WEB_AUDIO)
52 class AudioSourceProvider;
53 class MediaElementAudioSourceNode;
54 #endif
55 class Event;
56 class HTMLSourceElement;
57 class HTMLTrackElement;
58 class MediaController;
59 class MediaControls;
60 class MediaError;
61 class KURL;
62 class TextTrackList;
63 class TimeRanges;
64 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
65 class Widget;
66 #endif
67 #if PLATFORM(MAC)
68 class DisplaySleepDisabler;
69 #endif
70
71 #if ENABLE(VIDEO_TRACK)
72 class InbandTextTrackPrivate;
73
74 typedef PODIntervalTree<double, TextTrackCue*> CueIntervalTree;
75 typedef Vector<CueIntervalTree::IntervalType> CueList;
76 #endif
77
78 // FIXME: The inheritance from MediaPlayerClient here should be private inheritance.
79 // But it can't be until the Chromium WebMediaPlayerClientImpl class is fixed so it
80 // no longer depends on typecasting a MediaPlayerClient to an HTMLMediaElement.
81
82 class HTMLMediaElement : public HTMLElement, public MediaPlayerClient, public MediaPlayerSupportsTypeClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface
83 #if ENABLE(VIDEO_TRACK)
84     , private TextTrackClient, private CaptionPreferencesChangedListener
85 #endif
86 {
87 public:
88     MediaPlayer* player() const { return m_player.get(); }
89
90     void createShadowSubtree();
91     virtual void willAddAuthorShadowRoot() OVERRIDE;
92     virtual bool areAuthorShadowsAllowed() const OVERRIDE { return false; }
93
94     virtual bool isVideo() const = 0;
95     virtual bool hasVideo() const { return false; }
96     virtual bool hasAudio() const;
97
98     void rewind(float timeDelta);
99     void returnToRealtime();
100
101     // Eventually overloaded in HTMLVideoElement
102     virtual bool supportsFullscreen() const { return false; };
103
104     virtual bool supportsSave() const;
105     virtual bool supportsScanning() const;
106     
107     PlatformMedia platformMedia() const;
108 #if USE(ACCELERATED_COMPOSITING)
109     PlatformLayer* platformLayer() const;
110 #endif
111
112     enum LoadType {
113         MediaResource = 1 << 0,
114         TextTrackResource = 1 << 1
115     };
116     void scheduleLoad(LoadType);
117     
118     MediaPlayer::MovieLoadType movieLoadType() const;
119     
120     bool inActiveDocument() const { return m_inActiveDocument; }
121     
122 // DOM API
123 // error state
124     PassRefPtr<MediaError> error() const;
125
126 // network state
127     void setSrc(const String&);
128     const KURL& currentSrc() const { return m_currentSrc; }
129
130     enum NetworkState { NETWORK_EMPTY, NETWORK_IDLE, NETWORK_LOADING, NETWORK_NO_SOURCE };
131     NetworkState networkState() const;
132
133     String preload() const;    
134     void setPreload(const String&);
135
136     PassRefPtr<TimeRanges> buffered() const;
137     void load();
138     String canPlayType(const String& mimeType, const String& keySystem = String(), const KURL& = KURL()) const;
139
140 // ready state
141     ReadyState readyState() const;
142     bool seeking() const;
143
144 // playback state
145     float currentTime() const;
146     void setCurrentTime(float, ExceptionCode&);
147     double initialTime() const;
148     float startTime() const;
149     float duration() const;
150     bool paused() const;
151     float defaultPlaybackRate() const;
152     void setDefaultPlaybackRate(float);
153     float playbackRate() const;
154     void setPlaybackRate(float);
155     void updatePlaybackRate();
156     bool webkitPreservesPitch() const;
157     void setWebkitPreservesPitch(bool);
158     PassRefPtr<TimeRanges> played();
159     PassRefPtr<TimeRanges> seekable() const;
160     bool ended() const;
161     bool autoplay() const;    
162     void setAutoplay(bool b);
163     bool loop() const;    
164     void setLoop(bool b);
165     void play();
166     void pause();
167
168 // captions
169     bool webkitHasClosedCaptions() const;
170     bool webkitClosedCaptionsVisible() const;
171     void setWebkitClosedCaptionsVisible(bool);
172
173 #if ENABLE(MEDIA_STATISTICS)
174 // Statistics
175     unsigned webkitAudioDecodedByteCount() const;
176     unsigned webkitVideoDecodedByteCount() const;
177 #endif
178
179 #if ENABLE(MEDIA_SOURCE)
180 //  Media Source.
181     void setSourceState(const String&);
182 #endif 
183
184 #if ENABLE(ENCRYPTED_MEDIA)
185     void webkitGenerateKeyRequest(const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionCode&);
186     void webkitGenerateKeyRequest(const String& keySystem, ExceptionCode&);
187     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initData, const String& sessionId, ExceptionCode&);
188     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, ExceptionCode&);
189     void webkitCancelKeyRequest(const String& keySystem, const String& sessionId, ExceptionCode&);
190
191     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyadded);
192     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyerror);
193     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeymessage);
194     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitneedkey);
195 #endif
196
197 // controls
198     bool controls() const;
199     void setControls(bool);
200     float volume() const;
201     void setVolume(float, ExceptionCode&);
202     bool muted() const;
203     void setMuted(bool);
204
205     void togglePlayState();
206     void beginScrubbing();
207     void endScrubbing();
208     
209     bool canPlay() const;
210
211     float percentLoaded() const;
212
213 #if ENABLE(VIDEO_TRACK)
214     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
215     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, ExceptionCode& ec) { return addTextTrack(kind, label, emptyString(), ec); }
216     PassRefPtr<TextTrack> addTextTrack(const String& kind, ExceptionCode& ec) { return addTextTrack(kind, emptyString(), emptyString(), ec); }
217
218     TextTrackList* textTracks();
219     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
220
221     virtual void didAddTrack(HTMLTrackElement*);
222     virtual void didRemoveTrack(HTMLTrackElement*);
223
224     virtual void mediaPlayerDidAddTrack(PassRefPtr<InbandTextTrackPrivate>) OVERRIDE;
225     virtual void mediaPlayerDidRemoveTrack(PassRefPtr<InbandTextTrackPrivate>) OVERRIDE;
226
227     struct TrackGroup {
228         enum GroupKind { CaptionsAndSubtitles, Description, Chapter, Metadata, Other };
229
230         TrackGroup(GroupKind kind)
231             : visibleTrack(0)
232             , defaultTrack(0)
233             , kind(kind)
234             , hasSrcLang(false)
235         {
236         }
237
238         Vector<RefPtr<TextTrack> > tracks;
239         RefPtr<TextTrack> visibleTrack;
240         RefPtr<TextTrack> defaultTrack;
241         GroupKind kind;
242         bool hasSrcLang;
243     };
244
245     void configureTextTrackGroupForLanguage(const TrackGroup&) const;
246     void configureTextTracks();
247     void configureTextTrackGroup(const TrackGroup&) const;
248
249     void toggleTrackAtIndex(int index, bool exclusive = true);
250     static int textTracksOffIndex() { return -1; }
251     static int textTracksIndexNotFound() { return -2; }
252
253     bool userPrefersCaptions() const;
254     bool userIsInterestedInThisTrackKind(String) const;
255     bool textTracksAreReady() const;
256     void configureTextTrackDisplay();
257     void updateClosedCaptionsControls();
258
259     // TextTrackClient
260     virtual void textTrackReadyStateChanged(TextTrack*);
261     virtual void textTrackKindChanged(TextTrack*);
262     virtual void textTrackModeChanged(TextTrack*);
263     virtual void textTrackAddCues(TextTrack*, const TextTrackCueList*);
264     virtual void textTrackRemoveCues(TextTrack*, const TextTrackCueList*);
265     virtual void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>);
266     virtual void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>);
267 #endif
268
269 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
270     void allocateMediaPlayerIfNecessary();
271     void setNeedWidgetUpdate(bool needWidgetUpdate) { m_needWidgetUpdate = needWidgetUpdate; }
272     void deliverNotification(MediaPlayerProxyNotificationType notification);
273     void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
274     void getPluginProxyParams(KURL& url, Vector<String>& names, Vector<String>& values);
275     void createMediaPlayerProxy();
276     void updateWidget(PluginCreationOption);
277 #endif
278
279     // EventTarget function.
280     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
281     // causes an ambiguity error at compile time. This class's constructor
282     // ensures that both implementations return document, so return the result
283     // of one of them here.
284     virtual ScriptExecutionContext* scriptExecutionContext() const OVERRIDE { return HTMLElement::scriptExecutionContext(); }
285
286     bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
287     
288     bool isFullscreen() const;
289     void enterFullscreen();
290     void exitFullscreen();
291
292     bool hasClosedCaptions() const;
293     bool closedCaptionsVisible() const;
294     void setClosedCaptionsVisible(bool);
295
296     MediaControls* mediaControls() const;
297
298     void sourceWasRemoved(HTMLSourceElement*);
299     void sourceWasAdded(HTMLSourceElement*);
300
301     void privateBrowsingStateDidChange();
302
303     // Media cache management.
304     static void getSitesInMediaCache(Vector<String>&);
305     static void clearMediaCache();
306     static void clearMediaCacheForSite(const String&);
307
308     bool isPlaying() const { return m_playing; }
309
310     virtual bool hasPendingActivity() const;
311
312 #if ENABLE(WEB_AUDIO)
313     MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
314     void setAudioSourceNode(MediaElementAudioSourceNode*);
315
316     AudioSourceProvider* audioSourceProvider();
317 #endif
318
319     enum InvalidURLAction { DoNothing, Complain };
320     bool isSafeToLoadURL(const KURL&, InvalidURLAction);
321
322     const String& mediaGroup() const;
323     void setMediaGroup(const String&);
324
325     MediaController* controller() const;
326     void setController(PassRefPtr<MediaController>);
327
328     virtual bool dispatchEvent(PassRefPtr<Event>);
329
330     virtual bool willRespondToMouseClickEvents() OVERRIDE;
331
332     virtual void reportMemoryUsage(MemoryObjectInfo*) const;
333
334 protected:
335     HTMLMediaElement(const QualifiedName&, Document*, bool);
336     virtual ~HTMLMediaElement();
337
338     virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
339     virtual void finishParsingChildren();
340     virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
341     virtual void attach() OVERRIDE;
342     virtual void detach() OVERRIDE;
343
344     virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;
345
346     enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
347     DisplayMode displayMode() const { return m_displayMode; }
348     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
349     
350     virtual bool isMediaElement() const { return true; }
351
352     // Restrictions to change default behaviors.
353     enum BehaviorRestrictionFlags {
354         NoRestrictions = 0,
355         RequireUserGestureForLoadRestriction = 1 << 0,
356         RequireUserGestureForRateChangeRestriction = 1 << 1,
357         RequireUserGestureForFullscreenRestriction = 1 << 2,
358         RequirePageConsentToLoadMediaRestriction = 1 << 3,
359     };
360     typedef unsigned BehaviorRestrictions;
361     
362     bool userGestureRequiredForLoad() const { return m_restrictions & RequireUserGestureForLoadRestriction; }
363     bool userGestureRequiredForRateChange() const { return m_restrictions & RequireUserGestureForRateChangeRestriction; }
364     bool userGestureRequiredForFullscreen() const { return m_restrictions & RequireUserGestureForFullscreenRestriction; }
365     bool pageConsentRequiredForLoad() const { return m_restrictions & RequirePageConsentToLoadMediaRestriction; }
366     
367     void addBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions |= restriction; }
368     void removeBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions &= ~restriction; }
369     
370 private:
371     void createMediaPlayer();
372
373     virtual bool hasCustomFocusLogic() const OVERRIDE;
374     virtual bool supportsFocus() const;
375     virtual bool isMouseFocusable() const;
376     virtual bool rendererIsNeeded(const NodeRenderingContext&);
377     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
378     virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const OVERRIDE;
379     virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
380     virtual void removedFrom(ContainerNode*) OVERRIDE;
381     virtual void didRecalcStyle(StyleChange);
382     
383     virtual void defaultEventHandler(Event*);
384
385     virtual void didBecomeFullscreenElement();
386     virtual void willStopBeingFullscreenElement();
387
388     // ActiveDOMObject functions.
389     virtual bool canSuspend() const;
390     virtual void suspend(ReasonForSuspension);
391     virtual void resume();
392     virtual void stop();
393     
394     virtual void mediaVolumeDidChange();
395
396     virtual void updateDisplayState() { }
397     
398     void setReadyState(MediaPlayer::ReadyState);
399     void setNetworkState(MediaPlayer::NetworkState);
400
401     virtual Document* mediaPlayerOwningDocument();
402     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*);
403     virtual void mediaPlayerReadyStateChanged(MediaPlayer*);
404     virtual void mediaPlayerTimeChanged(MediaPlayer*);
405     virtual void mediaPlayerVolumeChanged(MediaPlayer*);
406     virtual void mediaPlayerMuteChanged(MediaPlayer*);
407     virtual void mediaPlayerDurationChanged(MediaPlayer*);
408     virtual void mediaPlayerRateChanged(MediaPlayer*);
409     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*);
410     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*);
411     virtual void mediaPlayerResourceNotSupported(MediaPlayer*);
412     virtual void mediaPlayerRepaint(MediaPlayer*);
413     virtual void mediaPlayerSizeChanged(MediaPlayer*);
414 #if USE(ACCELERATED_COMPOSITING)
415     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*);
416     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*);
417 #endif
418     virtual void mediaPlayerEngineUpdated(MediaPlayer*);
419     
420     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*);
421     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*);
422
423 #if ENABLE(MEDIA_SOURCE)
424     virtual void mediaPlayerSourceOpened();
425     virtual String mediaPlayerSourceURL() const;
426 #endif
427
428 #if ENABLE(ENCRYPTED_MEDIA)
429     virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& keySystem, const String& sessionId) OVERRIDE;
430     virtual void mediaPlayerKeyError(MediaPlayer*, const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode) OVERRIDE;
431     virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const KURL& defaultURL) OVERRIDE;
432     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength) OVERRIDE;
433 #endif
434
435     virtual String mediaPlayerReferrer() const OVERRIDE;
436     virtual String mediaPlayerUserAgent() const OVERRIDE;
437     virtual CORSMode mediaPlayerCORSMode() const OVERRIDE;
438
439     virtual bool mediaPlayerNeedsSiteSpecificHacks() const OVERRIDE;
440     virtual String mediaPlayerDocumentHost() const OVERRIDE;
441
442     virtual void mediaPlayerEnterFullscreen() OVERRIDE;
443     virtual void mediaPlayerExitFullscreen() OVERRIDE;
444     virtual bool mediaPlayerIsFullscreen() const OVERRIDE;
445     virtual bool mediaPlayerIsFullscreenPermitted() const OVERRIDE;
446     virtual bool mediaPlayerIsVideo() const OVERRIDE;
447     virtual LayoutRect mediaPlayerContentBoxRect() const OVERRIDE;
448     virtual void mediaPlayerSetSize(const IntSize&) OVERRIDE;
449     virtual void mediaPlayerPause() OVERRIDE;
450     virtual void mediaPlayerPlay() OVERRIDE;
451     virtual bool mediaPlayerIsPaused() const OVERRIDE;
452     virtual bool mediaPlayerIsLooping() const OVERRIDE;
453     virtual HostWindow* mediaPlayerHostWindow() OVERRIDE;
454     virtual IntRect mediaPlayerWindowClipRect() OVERRIDE;
455     virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() OVERRIDE;
456
457 #if PLATFORM(WIN) && USE(AVFOUNDATION)
458     virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const OVERRIDE;
459 #endif
460
461     void loadTimerFired(Timer<HTMLMediaElement>*);
462     void progressEventTimerFired(Timer<HTMLMediaElement>*);
463     void playbackProgressTimerFired(Timer<HTMLMediaElement>*);
464     void startPlaybackProgressTimer();
465     void startProgressEventTimer();
466     void stopPeriodicTimers();
467
468     void seek(float time, ExceptionCode&);
469     void finishSeek();
470     void checkIfSeekNeeded();
471     void addPlayedRange(float start, float end);
472     
473     void scheduleTimeupdateEvent(bool periodicEvent);
474     void scheduleEvent(const AtomicString& eventName);
475     
476     // loading
477     void selectMediaResource();
478     void loadResource(const KURL&, ContentType&, const String& keySystem);
479     void scheduleNextSourceChild();
480     void loadNextSourceChild();
481     void userCancelledLoad();
482     void clearMediaPlayer(int flags);
483     bool havePotentialSourceChild();
484     void noneSupported();
485     void mediaEngineError(PassRefPtr<MediaError> err);
486     void cancelPendingEventsAndCallbacks();
487     void waitForSourceChange();
488     void prepareToPlay();
489
490     KURL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
491
492     void mediaLoadingFailed(MediaPlayer::NetworkState);
493
494 #if ENABLE(VIDEO_TRACK)
495     void updateActiveTextTrackCues(float);
496     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
497
498     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0; }
499     void beginIgnoringTrackDisplayUpdateRequests() { ++m_ignoreTrackDisplayUpdate; }
500     void endIgnoringTrackDisplayUpdateRequests() { ASSERT(m_ignoreTrackDisplayUpdate); --m_ignoreTrackDisplayUpdate; }
501
502     void markCaptionAndSubtitleTracksAsUnconfigured();
503     virtual void captionPreferencesChanged() OVERRIDE;
504 #endif
505
506     // These "internal" functions do not check user gesture restrictions.
507     void loadInternal();
508     void playInternal();
509     void pauseInternal();
510
511     void prepareForLoad();
512     void allowVideoRendering();
513
514     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
515     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
516     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
517
518     void updateVolume();
519     void updatePlayState();
520     bool potentiallyPlaying() const;
521     bool endedPlayback() const;
522     bool stoppedDueToErrors() const;
523     bool pausedForUserInteraction() const;
524     bool couldPlayIfEnoughData() const;
525
526     float minTimeSeekable() const;
527     float maxTimeSeekable() const;
528
529     // Pauses playback without changing any states or generating events
530     void setPausedInternal(bool);
531
532     void setPlaybackRateInternal(float);
533
534     virtual void mediaCanStart();
535
536     void setShouldDelayLoadEvent(bool);
537     void invalidateCachedTime();
538     void refreshCachedTime() const;
539
540     bool hasMediaControls() const;
541     bool createMediaControls();
542     void configureMediaControls();
543
544     void prepareMediaFragmentURI();
545     void applyMediaFragmentURI();
546
547     virtual void* preDispatchEventHandler(Event*);
548
549     void changeNetworkStateFromLoadingToIdle();
550
551     void removeBehaviorsRestrictionsAfterFirstUserGesture();
552
553 #if ENABLE(MICRODATA)
554     virtual String itemValueText() const;
555     virtual void setItemValueText(const String&, ExceptionCode&);
556 #endif
557
558     void updateMediaController();
559     bool isBlocked() const;
560     bool isBlockedOnMediaController() const;
561     bool hasCurrentSrc() const { return !m_currentSrc.isEmpty(); }
562     bool isLiveStream() const { return movieLoadType() == MediaPlayer::LiveStream; }
563     bool isAutoplaying() const { return m_autoplaying; }
564
565 #if PLATFORM(MAC)
566     void updateDisableSleep();
567     bool shouldDisableSleep() const;
568 #endif
569
570     Timer<HTMLMediaElement> m_loadTimer;
571     Timer<HTMLMediaElement> m_progressEventTimer;
572     Timer<HTMLMediaElement> m_playbackProgressTimer;
573     RefPtr<TimeRanges> m_playedTimeRanges;
574     OwnPtr<GenericEventQueue> m_asyncEventQueue;
575
576     float m_playbackRate;
577     float m_defaultPlaybackRate;
578     bool m_webkitPreservesPitch;
579     NetworkState m_networkState;
580     ReadyState m_readyState;
581     ReadyState m_readyStateMaximum;
582     KURL m_currentSrc;
583
584     RefPtr<MediaError> m_error;
585
586     float m_volume;
587     float m_lastSeekTime;
588     
589     unsigned m_previousProgress;
590     double m_previousProgressTime;
591
592     // The last time a timeupdate event was sent (wall clock).
593     double m_lastTimeUpdateEventWallTime;
594
595     // The last time a timeupdate event was sent in movie time.
596     float m_lastTimeUpdateEventMovieTime;
597     
598     // Loading state.
599     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
600     LoadState m_loadState;
601     RefPtr<HTMLSourceElement> m_currentSourceNode;
602     RefPtr<Node> m_nextChildNodeToConsider;
603
604     OwnPtr<MediaPlayer> m_player;
605 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
606     RefPtr<Widget> m_proxyWidget;
607 #endif
608
609     BehaviorRestrictions m_restrictions;
610     
611     MediaPlayer::Preload m_preload;
612
613     DisplayMode m_displayMode;
614
615     // Counter incremented while processing a callback from the media player, so we can avoid
616     // calling the media engine recursively.
617     int m_processingMediaPlayerCallback;
618
619 #if ENABLE(MEDIA_SOURCE)
620     KURL m_mediaSourceURL;
621     RefPtr<MediaSource> m_mediaSource;
622 #endif
623
624     mutable float m_cachedTime;
625     mutable double m_cachedTimeWallClockUpdateTime;
626     mutable double m_minimumWallClockTimeToCacheMediaTime;
627
628     double m_fragmentStartTime;
629     double m_fragmentEndTime;
630
631     typedef unsigned PendingLoadFlags;
632     PendingLoadFlags m_pendingLoadFlags;
633
634     bool m_playing : 1;
635     bool m_isWaitingUntilMediaCanStart : 1;
636     bool m_shouldDelayLoadEvent : 1;
637     bool m_haveFiredLoadedData : 1;
638     bool m_inActiveDocument : 1;
639     bool m_autoplaying : 1;
640     bool m_muted : 1;
641     bool m_paused : 1;
642     bool m_seeking : 1;
643
644     // data has not been loaded since sending a "stalled" event
645     bool m_sentStalledEvent : 1;
646
647     // time has not changed since sending an "ended" event
648     bool m_sentEndEvent : 1;
649
650     bool m_pausedInternal : 1;
651
652     // Not all media engines provide enough information about a file to be able to
653     // support progress events so setting m_sendProgressEvents disables them 
654     bool m_sendProgressEvents : 1;
655
656     bool m_isFullscreen : 1;
657     bool m_closedCaptionsVisible : 1;
658
659 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
660     bool m_needWidgetUpdate : 1;
661 #endif
662
663     bool m_dispatchingCanPlayEvent : 1;
664     bool m_loadInitiatedByUserGesture : 1;
665     bool m_completelyLoaded : 1;
666     bool m_havePreparedToPlay : 1;
667     bool m_parsingInProgress : 1;
668
669 #if ENABLE(VIDEO_TRACK)
670     bool m_tracksAreReady : 1;
671     bool m_haveVisibleTextTrack : 1;
672     float m_lastTextTrackUpdateTime;
673
674     RefPtr<TextTrackList> m_textTracks;
675     Vector<RefPtr<TextTrack> > m_textTracksWhenResourceSelectionBegan;
676
677     CueIntervalTree m_cueTree;
678
679     CueList m_currentlyActiveCues;
680     int m_ignoreTrackDisplayUpdate;
681     bool m_disableCaptions;
682 #endif
683
684 #if ENABLE(WEB_AUDIO)
685     // This is a weak reference, since m_audioSourceNode holds a reference to us.
686     // The value is set just after the MediaElementAudioSourceNode is created.
687     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
688     MediaElementAudioSourceNode* m_audioSourceNode;
689 #endif
690
691     String m_mediaGroup;
692     friend class MediaController;
693     RefPtr<MediaController> m_mediaController;
694
695 #if PLATFORM(MAC)
696     OwnPtr<DisplaySleepDisabler> m_sleepDisabler;
697 #endif
698 };
699
700 #if ENABLE(VIDEO_TRACK)
701 #ifndef NDEBUG
702 // Template specializations required by PodIntervalTree in debug mode.
703 template <>
704 struct ValueToString<double> {
705     static String string(const double value)
706     {
707         return String::number(value);
708     }
709 };
710
711 template <>
712 struct ValueToString<TextTrackCue*> {
713     static String string(TextTrackCue* const& cue)
714     {
715         return String::format("%p id=%s interval=%f-->%f cue=%s)", cue, cue->id().utf8().data(), cue->startTime(), cue->endTime(), cue->text().utf8().data());
716     }
717 };
718 #endif
719 #endif
720
721 inline bool isMediaElement(Node* node)
722 {
723     return node && node->isElementNode() && toElement(node)->isMediaElement();
724 }
725
726 inline HTMLMediaElement* toMediaElement(Node* node)
727 {
728     ASSERT(!node || isMediaElement(node));
729     return static_cast<HTMLMediaElement*>(node);
730 }
731
732 } //namespace
733
734 #endif
735 #endif