[Qt] Test fonts are not used with Qt5
[WebKit-https.git] / Source / WebCore / html / HTMLMediaElement.h
1 /*
2  * Copyright (C) 2007, 2008, 2009, 2010, 2011 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 "MediaCanStartListener.h"
34 #include "MediaControllerInterface.h"
35 #include "MediaPlayer.h"
36
37 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
38 #include "MediaPlayerProxy.h"
39 #endif
40
41 #if ENABLE(VIDEO_TRACK)
42 #include "PODIntervalTree.h"
43 #include "TextTrack.h"
44 #include "TextTrackCue.h"
45 #endif
46
47 namespace WebCore {
48
49 #if ENABLE(WEB_AUDIO)
50 class AudioSourceProvider;
51 class MediaElementAudioSourceNode;
52 #endif
53 class Event;
54 class HTMLSourceElement;
55 class HTMLTrackElement;
56 class MediaController;
57 class MediaControls;
58 class MediaError;
59 class KURL;
60 class TextTrackList;
61 class TimeRanges;
62 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
63 class Widget;
64 #endif
65 #if PLATFORM(MAC)
66 class DisplaySleepDisabler;
67 #endif
68
69 // FIXME: The inheritance from MediaPlayerClient here should be private inheritance.
70 // But it can't be until the Chromium WebMediaPlayerClientImpl class is fixed so it
71 // no longer depends on typecasting a MediaPlayerClient to an HTMLMediaElement.
72
73 class HTMLMediaElement : public HTMLElement, public MediaPlayerClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface
74 #if ENABLE(VIDEO_TRACK)
75     , private TextTrackClient
76 #endif
77 {
78 public:
79     MediaPlayer* player() const { return m_player.get(); }
80     
81     virtual bool isVideo() const = 0;
82     virtual bool hasVideo() const { return false; }
83     virtual bool hasAudio() const;
84
85     void rewind(float timeDelta);
86     void returnToRealtime();
87
88     // Eventually overloaded in HTMLVideoElement
89     virtual bool supportsFullscreen() const { return false; };
90
91     virtual bool supportsSave() const;
92     virtual bool supportsScanning() const;
93     
94     PlatformMedia platformMedia() const;
95 #if USE(ACCELERATED_COMPOSITING)
96     PlatformLayer* platformLayer() const;
97 #endif
98
99     enum LoadType {
100         MediaResource = 1 << 0,
101         TextTrackResource = 1 << 1
102     };
103     void scheduleLoad(LoadType);
104     
105     MediaPlayer::MovieLoadType movieLoadType() const;
106     
107     bool inActiveDocument() const { return m_inActiveDocument; }
108     
109 // DOM API
110 // error state
111     PassRefPtr<MediaError> error() const;
112
113 // network state
114     void setSrc(const String&);
115     const KURL& currentSrc() const { return m_currentSrc; }
116
117     enum NetworkState { NETWORK_EMPTY, NETWORK_IDLE, NETWORK_LOADING, NETWORK_NO_SOURCE };
118     NetworkState networkState() const;
119
120     String preload() const;    
121     void setPreload(const String&);
122
123     PassRefPtr<TimeRanges> buffered() const;
124     void load(ExceptionCode&);
125     String canPlayType(const String& mimeType) const;
126
127 // ready state
128     ReadyState readyState() const;
129     bool seeking() const;
130
131 // playback state
132     float currentTime() const;
133     void setCurrentTime(float, ExceptionCode&);
134     double initialTime() const;
135     float startTime() const;
136     float duration() const;
137     bool paused() const;
138     float defaultPlaybackRate() const;
139     void setDefaultPlaybackRate(float);
140     float playbackRate() const;
141     void setPlaybackRate(float);
142     void updatePlaybackRate();
143     bool webkitPreservesPitch() const;
144     void setWebkitPreservesPitch(bool);
145     PassRefPtr<TimeRanges> played();
146     PassRefPtr<TimeRanges> seekable() const;
147     bool ended() const;
148     bool autoplay() const;    
149     void setAutoplay(bool b);
150     bool loop() const;    
151     void setLoop(bool b);
152     void play();
153     void pause();
154
155 // captions
156     bool webkitHasClosedCaptions() const;
157     bool webkitClosedCaptionsVisible() const;
158     void setWebkitClosedCaptionsVisible(bool);
159
160 #if ENABLE(MEDIA_STATISTICS)
161 // Statistics
162     unsigned webkitAudioDecodedByteCount() const;
163     unsigned webkitVideoDecodedByteCount() const;
164 #endif
165
166 #if ENABLE(MEDIA_SOURCE)
167 //  Media Source.
168     const KURL& webkitMediaSourceURL() const { return m_mediaSourceURL; }
169     void webkitSourceAppend(PassRefPtr<Uint8Array> data, ExceptionCode&);
170     enum EndOfStreamStatus { EOS_NO_ERROR, EOS_NETWORK_ERR, EOS_DECODE_ERR };
171     void webkitSourceEndOfStream(unsigned short, ExceptionCode&);
172     enum SourceState { SOURCE_CLOSED, SOURCE_OPEN, SOURCE_ENDED };
173     SourceState webkitSourceState() const;
174     void setSourceState(SourceState);
175 #endif 
176
177 // controls
178     bool controls() const;
179     void setControls(bool);
180     float volume() const;
181     void setVolume(float, ExceptionCode&);
182     bool muted() const;
183     void setMuted(bool);
184
185     void togglePlayState();
186     void beginScrubbing();
187     void endScrubbing();
188     
189     bool canPlay() const;
190
191     float percentLoaded() const;
192
193 #if ENABLE(VIDEO_TRACK)
194     PassRefPtr<TextTrack> addTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
195     PassRefPtr<TextTrack> addTrack(const String& kind, const String& label, ExceptionCode& ec) { return addTrack(kind, label, emptyString(), ec); }
196     PassRefPtr<TextTrack> addTrack(const String& kind, ExceptionCode& ec) { return addTrack(kind, emptyString(), emptyString(), ec); }
197
198     TextTrackList* textTracks();
199
200     virtual void trackWasAdded(HTMLTrackElement*);
201     virtual void trackWillBeRemoved(HTMLTrackElement*);
202     
203     void configureTextTrack(HTMLTrackElement*);
204     void configureTextTracks();
205     bool textTracksAreReady() const;
206
207     // TextTrackClient
208     virtual void textTrackReadyStateChanged(TextTrack*);
209     virtual void textTrackKindChanged(TextTrack*);
210     virtual void textTrackModeChanged(TextTrack*);
211     virtual void textTrackAddCues(TextTrack*, const TextTrackCueList*);
212     virtual void textTrackRemoveCues(TextTrack*, const TextTrackCueList*);
213     virtual void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>);
214     virtual void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>);
215 #endif
216
217 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
218     void allocateMediaPlayerIfNecessary();
219     void setNeedWidgetUpdate(bool needWidgetUpdate) { m_needWidgetUpdate = needWidgetUpdate; }
220     void deliverNotification(MediaPlayerProxyNotificationType notification);
221     void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
222     void getPluginProxyParams(KURL& url, Vector<String>& names, Vector<String>& values);
223     void createMediaPlayerProxy();
224     void updateWidget(PluginCreationOption);
225 #endif
226
227     bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
228     
229     bool isFullscreen() const;
230     void enterFullscreen();
231     void exitFullscreen();
232
233     bool hasClosedCaptions() const;
234     bool closedCaptionsVisible() const;
235     void setClosedCaptionsVisible(bool);
236
237     MediaControls* mediaControls();
238
239     void sourceWillBeRemoved(HTMLSourceElement*);
240     void sourceWasAdded(HTMLSourceElement*);
241
242     void privateBrowsingStateDidChange();
243
244     // Media cache management.
245     static void getSitesInMediaCache(Vector<String>&);
246     static void clearMediaCache();
247     static void clearMediaCacheForSite(const String&);
248
249     bool isPlaying() const { return m_playing; }
250
251     virtual bool hasPendingActivity() const;
252
253 #if ENABLE(WEB_AUDIO)
254     MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
255     void setAudioSourceNode(MediaElementAudioSourceNode*);
256
257     AudioSourceProvider* audioSourceProvider();
258 #endif
259
260     enum InvalidURLAction { DoNothing, Complain };
261     bool isSafeToLoadURL(const KURL&, InvalidURLAction);
262
263     const String& mediaGroup() const;
264     void setMediaGroup(const String&);
265
266     MediaController* controller() const;
267     void setController(PassRefPtr<MediaController>);
268
269 protected:
270     HTMLMediaElement(const QualifiedName&, Document*, bool);
271     virtual ~HTMLMediaElement();
272
273     virtual void parseMappedAttribute(Attribute*);
274     virtual void finishParsingChildren();
275     virtual bool isURLAttribute(Attribute*) const;
276     virtual void attach();
277
278     virtual void willMoveToNewOwnerDocument();
279     virtual void didMoveToNewOwnerDocument();
280
281     enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
282     DisplayMode displayMode() const { return m_displayMode; }
283     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
284     
285     virtual bool isMediaElement() const { return true; }
286
287     // Restrictions to change default behaviors.
288     enum BehaviorRestrictionFlags {
289         NoRestrictions = 0,
290         RequireUserGestureForLoadRestriction = 1 << 0,
291         RequireUserGestureForRateChangeRestriction = 1 << 1,
292         RequireUserGestureForFullscreenRestriction = 1 << 2,
293         RequirePageConsentToLoadMediaRestriction = 1 << 3,
294     };
295     typedef unsigned BehaviorRestrictions;
296     
297     bool userGestureRequiredForLoad() const { return m_restrictions & RequireUserGestureForLoadRestriction; }
298     bool userGestureRequiredForRateChange() const { return m_restrictions & RequireUserGestureForRateChangeRestriction; }
299     bool userGestureRequiredForFullscreen() const { return m_restrictions & RequireUserGestureForFullscreenRestriction; }
300     bool pageConsentRequiredForLoad() const { return m_restrictions & RequirePageConsentToLoadMediaRestriction; }
301     
302     void addBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions |= restriction; }
303     void removeBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions &= ~restriction; }
304     
305 private:
306     void createMediaPlayer();
307
308     virtual bool supportsFocus() const;
309     virtual void attributeChanged(Attribute*, bool preserveDecls);
310     virtual bool rendererIsNeeded(const NodeRenderingContext&);
311     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
312     virtual void insertedIntoDocument();
313     virtual void removedFromDocument();
314     virtual void didRecalcStyle(StyleChange);
315     
316     virtual void defaultEventHandler(Event*);
317
318     virtual void didBecomeFullscreenElement();
319     virtual void willStopBeingFullscreenElement();
320
321     // ActiveDOMObject functions.
322     virtual bool canSuspend() const;
323     virtual void suspend(ReasonForSuspension);
324     virtual void resume();
325     virtual void stop();
326     
327     virtual void mediaVolumeDidChange();
328
329     virtual void updateDisplayState() { }
330     
331     void setReadyState(MediaPlayer::ReadyState);
332     void setNetworkState(MediaPlayer::NetworkState);
333
334     virtual Document* mediaPlayerOwningDocument();
335     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*);
336     virtual void mediaPlayerReadyStateChanged(MediaPlayer*);
337     virtual void mediaPlayerTimeChanged(MediaPlayer*);
338     virtual void mediaPlayerVolumeChanged(MediaPlayer*);
339     virtual void mediaPlayerMuteChanged(MediaPlayer*);
340     virtual void mediaPlayerDurationChanged(MediaPlayer*);
341     virtual void mediaPlayerRateChanged(MediaPlayer*);
342     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*);
343     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*);
344     virtual void mediaPlayerRepaint(MediaPlayer*);
345     virtual void mediaPlayerSizeChanged(MediaPlayer*);
346 #if USE(ACCELERATED_COMPOSITING)
347     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*);
348     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*);
349 #endif
350     virtual void mediaPlayerEngineUpdated(MediaPlayer*);
351     
352     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*);
353     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*);
354
355 #if ENABLE(MEDIA_SOURCE)
356     virtual void mediaPlayerSourceOpened();
357     virtual String mediaPlayerSourceURL() const;
358 #endif
359
360     void loadTimerFired(Timer<HTMLMediaElement>*);
361     void asyncEventTimerFired(Timer<HTMLMediaElement>*);
362     void progressEventTimerFired(Timer<HTMLMediaElement>*);
363     void playbackProgressTimerFired(Timer<HTMLMediaElement>*);
364     void startPlaybackProgressTimer();
365     void startProgressEventTimer();
366     void stopPeriodicTimers();
367
368     void seek(float time, ExceptionCode&);
369     void finishSeek();
370     void checkIfSeekNeeded();
371     void addPlayedRange(float start, float end);
372     
373     void scheduleTimeupdateEvent(bool periodicEvent);
374     void scheduleEvent(const AtomicString& eventName);
375     
376     // loading
377     void selectMediaResource();
378     void loadResource(const KURL&, ContentType&);
379     void scheduleNextSourceChild();
380     void loadNextSourceChild();
381     void userCancelledLoad();
382     bool havePotentialSourceChild();
383     void noneSupported();
384     void mediaEngineError(PassRefPtr<MediaError> err);
385     void cancelPendingEventsAndCallbacks();
386     void waitForSourceChange();
387     void prepareToPlay();
388
389     KURL selectNextSourceChild(ContentType*, InvalidURLAction);
390     void mediaLoadingFailed(MediaPlayer::NetworkState);
391
392 #if ENABLE(VIDEO_TRACK)
393     void updateActiveTextTrackCues(float);
394     bool userIsInterestedInThisLanguage(const String&) const;
395     bool userIsInterestedInThisTrack(HTMLTrackElement*) const;
396     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
397 #endif
398
399     // These "internal" functions do not check user gesture restrictions.
400     void loadInternal();
401     void playInternal();
402     void pauseInternal();
403
404     void prepareForLoad();
405     void allowVideoRendering();
406
407     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
408     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
409     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
410
411     void updateVolume();
412     void updatePlayState();
413     bool potentiallyPlaying() const;
414     bool endedPlayback() const;
415     bool stoppedDueToErrors() const;
416     bool pausedForUserInteraction() const;
417     bool couldPlayIfEnoughData() const;
418
419     float minTimeSeekable() const;
420     float maxTimeSeekable() const;
421
422     // Pauses playback without changing any states or generating events
423     void setPausedInternal(bool);
424
425     void setPlaybackRateInternal(float);
426
427     virtual void mediaCanStart();
428
429     void setShouldDelayLoadEvent(bool);
430
431     void invalidateCachedTime();
432     void refreshCachedTime() const;
433
434     bool hasMediaControls();
435     bool createMediaControls();
436     void configureMediaControls();
437
438     virtual void* preDispatchEventHandler(Event*);
439
440 #if ENABLE(MICRODATA)
441     virtual String itemValueText() const;
442     virtual void setItemValueText(const String&, ExceptionCode&);
443 #endif
444
445     void updateMediaController();
446     bool isBlocked() const;
447     bool isBlockedOnMediaController() const;
448     bool hasCurrentSrc() const { return !m_currentSrc.isEmpty(); }
449     bool isLiveStream() const { return movieLoadType() == MediaPlayer::LiveStream; }
450     bool isAutoplaying() const { return m_autoplaying; }
451
452     Timer<HTMLMediaElement> m_loadTimer;
453     Timer<HTMLMediaElement> m_asyncEventTimer;
454     Timer<HTMLMediaElement> m_progressEventTimer;
455     Timer<HTMLMediaElement> m_playbackProgressTimer;
456     Vector<RefPtr<Event> > m_pendingEvents;
457     RefPtr<TimeRanges> m_playedTimeRanges;
458
459     float m_playbackRate;
460     float m_defaultPlaybackRate;
461     bool m_webkitPreservesPitch;
462     NetworkState m_networkState;
463     ReadyState m_readyState;
464     ReadyState m_readyStateMaximum;
465     KURL m_currentSrc;
466
467     RefPtr<MediaError> m_error;
468
469     float m_volume;
470     float m_lastSeekTime;
471     
472     unsigned m_previousProgress;
473     double m_previousProgressTime;
474
475     // The last time a timeupdate event was sent (wall clock).
476     double m_lastTimeUpdateEventWallTime;
477
478     // The last time a timeupdate event was sent in movie time.
479     float m_lastTimeUpdateEventMovieTime;
480     
481     // Loading state.
482     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
483     LoadState m_loadState;
484     HTMLSourceElement* m_currentSourceNode;
485     Node* m_nextChildNodeToConsider;
486     Node* sourceChildEndOfListValue() { return static_cast<Node*>(this); }
487
488     OwnPtr<MediaPlayer> m_player;
489 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
490     RefPtr<Widget> m_proxyWidget;
491 #endif
492
493     BehaviorRestrictions m_restrictions;
494     
495     MediaPlayer::Preload m_preload;
496
497     DisplayMode m_displayMode;
498
499     // Counter incremented while processing a callback from the media player, so we can avoid
500     // calling the media engine recursively.
501     int m_processingMediaPlayerCallback;
502
503 #if ENABLE(MEDIA_SOURCE)
504     KURL m_mediaSourceURL;
505     SourceState m_sourceState;
506 #endif
507
508     mutable float m_cachedTime;
509     mutable double m_cachedTimeWallClockUpdateTime;
510     mutable double m_minimumWallClockTimeToCacheMediaTime;
511     
512     typedef unsigned PendingLoadFlags;
513     PendingLoadFlags m_pendingLoadFlags;
514
515     bool m_playing : 1;
516     bool m_isWaitingUntilMediaCanStart : 1;
517     bool m_shouldDelayLoadEvent : 1;
518     bool m_haveFiredLoadedData : 1;
519     bool m_inActiveDocument : 1;
520     bool m_autoplaying : 1;
521     bool m_muted : 1;
522     bool m_paused : 1;
523     bool m_seeking : 1;
524
525     // data has not been loaded since sending a "stalled" event
526     bool m_sentStalledEvent : 1;
527
528     // time has not changed since sending an "ended" event
529     bool m_sentEndEvent : 1;
530
531     bool m_pausedInternal : 1;
532
533     // Not all media engines provide enough information about a file to be able to
534     // support progress events so setting m_sendProgressEvents disables them 
535     bool m_sendProgressEvents : 1;
536
537     bool m_isFullscreen : 1;
538     bool m_closedCaptionsVisible : 1;
539
540 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
541     bool m_needWidgetUpdate : 1;
542 #endif
543
544     bool m_dispatchingCanPlayEvent : 1;
545     bool m_loadInitiatedByUserGesture : 1;
546     bool m_completelyLoaded : 1;
547     bool m_havePreparedToPlay : 1;
548     bool m_parsingInProgress : 1;
549
550 #if ENABLE(VIDEO_TRACK)
551     bool m_tracksAreReady : 1;
552     RefPtr<TextTrackList> m_textTracks;
553     Vector<RefPtr<TextTrack> > m_textTracksWhenResourceSelectionBegan;
554     
555     typedef PODIntervalTree <double, TextTrackCue*> CueIntervalTree;
556     CueIntervalTree m_cueTree;
557     Vector<CueIntervalTree::IntervalType> m_currentlyVisibleCues;
558 #endif
559
560 #if ENABLE(WEB_AUDIO)
561     // This is a weak reference, since m_audioSourceNode holds a reference to us.
562     // The value is set just after the MediaElementAudioSourceNode is created.
563     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
564     MediaElementAudioSourceNode* m_audioSourceNode;
565 #endif
566
567     String m_mediaGroup;
568     friend class MediaController;
569     RefPtr<MediaController> m_mediaController;
570
571 #if PLATFORM(MAC)
572     OwnPtr<DisplaySleepDisabler> m_sleepDisabler;
573 #endif
574 };
575
576 #if ENABLE(VIDEO_TRACK)
577 #ifndef NDEBUG
578 // Template specializations required by PodIntervalTree in debug mode.
579 template <>
580 struct ValueToString<double> {
581     static String string(const double value)
582     {
583         return String::number(value);
584     }
585 };
586
587 template <>
588 struct ValueToString<TextTrackCue*> {
589     static String string(TextTrackCue* const& cue)
590     {
591         return String::format("%p id=%s interval=%f-->%f cue=%s)", cue, cue->id().utf8().data(), cue->startTime(), cue->endTime(), cue->getCueAsSource().utf8().data());
592     }
593 };
594 #endif
595 #endif
596
597 } //namespace
598
599 #endif
600 #endif