4781a39e33aa1480800144b7382fb7b1935cdfaa
[WebKit-https.git] / Source / WebCore / platform / graphics / MediaPlayer.cpp
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 #include "config.h"
27
28 #if ENABLE(VIDEO)
29 #include "MediaPlayer.h"
30
31 #include "ContentType.h"
32 #include "Document.h"
33 #include "Frame.h"
34 #include "FrameView.h"
35 #include "IntRect.h"
36 #include "MIMETypeRegistry.h"
37 #include "MediaPlayerPrivate.h"
38 #include "Settings.h"
39 #include "TimeRanges.h"
40
41 #if PLATFORM(QT)
42 #include <QtGlobal>
43 #endif
44
45 #if USE(GSTREAMER)
46 #include "MediaPlayerPrivateGStreamer.h"
47 #endif
48
49 #if PLATFORM(MAC) || (PLATFORM(QT) && USE(QTKIT))
50 #include "MediaPlayerPrivateQTKit.h"
51 #if USE(AVFOUNDATION)
52 #include "MediaPlayerPrivateAVFoundationObjC.h"
53 #endif
54 #define PlatformMediaEngineClassName MediaPlayerPrivateQTKit
55 #elif OS(WINCE) && !PLATFORM(QT)
56 #include "MediaPlayerPrivateWinCE.h"
57 #define PlatformMediaEngineClassName MediaPlayerPrivate
58 #elif PLATFORM(WIN)
59 #include "MediaPlayerPrivateQuickTimeVisualContext.h"
60 #define PlatformMediaEngineClassName MediaPlayerPrivateQuickTimeVisualContext
61 #elif PLATFORM(QT)
62 #if USE(QT_MULTIMEDIA) && !USE(GSTREAMER)
63 #include "MediaPlayerPrivateQt.h"
64 #define PlatformMediaEngineClassName MediaPlayerPrivateQt
65 #elif !USE(GSTREAMER) && !USE(QTKIT)
66 #include "MediaPlayerPrivatePhonon.h"
67 #define PlatformMediaEngineClassName MediaPlayerPrivatePhonon
68 #endif
69 #elif PLATFORM(CHROMIUM)
70 #include "MediaPlayerPrivateChromium.h"
71 #define PlatformMediaEngineClassName MediaPlayerPrivate
72 #endif
73
74 namespace WebCore {
75
76 const PlatformMedia NoPlatformMedia = { PlatformMedia::None, {0} };
77
78 // a null player to make MediaPlayer logic simpler
79
80 class NullMediaPlayerPrivate : public MediaPlayerPrivateInterface {
81 public:
82     NullMediaPlayerPrivate(MediaPlayer*) { }
83
84     virtual void load(const String&) { }
85     virtual void cancelLoad() { }
86
87     virtual void prepareToPlay() { }
88     virtual void play() { }
89     virtual void pause() { }    
90
91     virtual PlatformMedia platformMedia() const { return NoPlatformMedia; }
92 #if USE(ACCELERATED_COMPOSITING)
93     virtual PlatformLayer* platformLayer() const { return 0; }
94 #endif
95
96     virtual IntSize naturalSize() const { return IntSize(0, 0); }
97
98     virtual bool hasVideo() const { return false; }
99     virtual bool hasAudio() const { return false; }
100
101     virtual void setVisible(bool) { }
102
103     virtual float duration() const { return 0; }
104
105     virtual float currentTime() const { return 0; }
106     virtual void seek(float) { }
107     virtual bool seeking() const { return false; }
108
109     virtual void setRate(float) { }
110     virtual void setPreservesPitch(bool) { }
111     virtual bool paused() const { return false; }
112
113     virtual void setVolume(float) { }
114
115     virtual bool supportsMuting() const { return false; }
116     virtual void setMuted(bool) { }
117
118     virtual bool hasClosedCaptions() const { return false; }
119     virtual void setClosedCaptionsVisible(bool) { };
120
121     virtual MediaPlayer::NetworkState networkState() const { return MediaPlayer::Empty; }
122     virtual MediaPlayer::ReadyState readyState() const { return MediaPlayer::HaveNothing; }
123
124     virtual float maxTimeSeekable() const { return 0; }
125     virtual PassRefPtr<TimeRanges> buffered() const { return TimeRanges::create(); }
126
127     virtual unsigned totalBytes() const { return 0; }
128     virtual unsigned bytesLoaded() const { return 0; }
129
130     virtual void setSize(const IntSize&) { }
131
132     virtual void paint(GraphicsContext*, const IntRect&) { }
133
134     virtual bool canLoadPoster() const { return false; }
135     virtual void setPoster(const String&) { }
136
137 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
138     virtual void deliverNotification(MediaPlayerProxyNotificationType) { }
139     virtual void setMediaPlayerProxy(WebMediaPlayerProxy*) { }
140     virtual void setControls(bool) { }
141 #endif
142
143     virtual bool hasSingleSecurityOrigin() const { return true; }
144 };
145
146 static PassOwnPtr<MediaPlayerPrivateInterface> createNullMediaPlayer(MediaPlayer* player) 
147
148     return adoptPtr(new NullMediaPlayerPrivate(player)); 
149 }
150
151
152 // engine support
153
154 struct MediaPlayerFactory {
155     WTF_MAKE_NONCOPYABLE(MediaPlayerFactory); WTF_MAKE_FAST_ALLOCATED;
156 public:
157     MediaPlayerFactory(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsTypeAndCodecs,
158         MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite) 
159         : constructor(constructor)
160         , getSupportedTypes(getSupportedTypes)
161         , supportsTypeAndCodecs(supportsTypeAndCodecs)
162         , getSitesInMediaCache(getSitesInMediaCache)
163         , clearMediaCache(clearMediaCache)
164         , clearMediaCacheForSite(clearMediaCacheForSite)
165
166     { 
167     }
168
169     CreateMediaEnginePlayer constructor;
170     MediaEngineSupportedTypes getSupportedTypes;
171     MediaEngineSupportsType supportsTypeAndCodecs;
172     MediaEngineGetSitesInMediaCache getSitesInMediaCache;
173     MediaEngineClearMediaCache clearMediaCache;
174     MediaEngineClearMediaCacheForSite clearMediaCacheForSite;
175 };
176
177 static void addMediaEngine(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite);
178 static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, MediaPlayerFactory* current = 0);
179 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current);
180
181 static Vector<MediaPlayerFactory*>& installedMediaEngines() 
182 {
183     DEFINE_STATIC_LOCAL(Vector<MediaPlayerFactory*>, installedEngines, ());
184     static bool enginesQueried = false;
185
186     if (!enginesQueried) {
187         enginesQueried = true;
188
189 #if USE(GSTREAMER)
190         MediaPlayerPrivateGStreamer::registerMediaEngine(addMediaEngine);
191 #endif
192
193 #if USE(AVFOUNDATION) && PLATFORM(MAC)
194         if (Settings::isAVFoundationEnabled())
195             MediaPlayerPrivateAVFoundationObjC::registerMediaEngine(addMediaEngine);
196 #endif
197
198 #if !PLATFORM(GTK) && !PLATFORM(EFL) && !(PLATFORM(QT) && USE(GSTREAMER))
199         PlatformMediaEngineClassName::registerMediaEngine(addMediaEngine);
200 #endif
201     }
202
203     return installedEngines;
204 }
205
206 static void addMediaEngine(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,
207     MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite)
208 {
209     ASSERT(constructor);
210     ASSERT(getSupportedTypes);
211     ASSERT(supportsType);
212
213     installedMediaEngines().append(new MediaPlayerFactory(constructor, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite));
214 }
215
216 static const AtomicString& applicationOctetStream()
217 {
218     DEFINE_STATIC_LOCAL(const AtomicString, applicationOctetStream, ("application/octet-stream"));
219     return applicationOctetStream;
220 }
221
222 static const AtomicString& textPlain()
223 {
224     DEFINE_STATIC_LOCAL(const AtomicString, textPlain, ("text/plain"));
225     return textPlain;
226 }
227
228 static const AtomicString& codecs()
229 {
230     DEFINE_STATIC_LOCAL(const AtomicString, codecs, ("codecs"));
231     return codecs;
232 }
233
234 static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, MediaPlayerFactory* current)
235 {
236     if (type.isEmpty())
237         return 0;
238
239     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
240     if (engines.isEmpty())
241         return 0;
242
243     // 4.8.10.3 MIME types - In the absence of a specification to the contrary, the MIME type "application/octet-stream" 
244     // when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows 
245     // it cannot render.
246     if (type == applicationOctetStream()) {
247         if (!codecs.isEmpty())
248             return 0;
249     }
250
251     MediaPlayerFactory* engine = 0;
252     MediaPlayer::SupportsType supported = MediaPlayer::IsNotSupported;
253     unsigned count = engines.size();
254     for (unsigned ndx = 0; ndx < count; ndx++) {
255         if (current) {
256             if (current == engines[ndx])
257                 current = 0;
258             continue;
259         }
260         MediaPlayer::SupportsType engineSupport = engines[ndx]->supportsTypeAndCodecs(type, codecs);
261         if (engineSupport > supported) {
262             supported = engineSupport;
263             engine = engines[ndx];
264         }
265     }
266
267     return engine;
268 }
269
270 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current)
271 {
272     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
273     if (engines.isEmpty())
274         return 0;
275
276     if (!current) 
277         return engines.first();
278
279     size_t currentIndex = engines.find(current);
280     if (currentIndex == WTF::notFound || currentIndex + 1 >= engines.size()) 
281         return 0;
282
283     return engines[currentIndex + 1];
284 }
285
286 // media player
287
288 MediaPlayer::MediaPlayer(MediaPlayerClient* client)
289     : m_mediaPlayerClient(client)
290     , m_reloadTimer(this, &MediaPlayer::reloadTimerFired)
291     , m_private(createNullMediaPlayer(this))
292     , m_currentMediaEngine(0)
293     , m_frameView(0)
294     , m_preload(Auto)
295     , m_visible(false)
296     , m_rate(1.0f)
297     , m_volume(1.0f)
298     , m_muted(false)
299     , m_preservesPitch(true)
300     , m_privateBrowsing(false)
301     , m_shouldPrepareToRender(false)
302 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
303     , m_playerProxy(0)
304 #endif
305 {
306 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
307     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
308     if (!engines.isEmpty()) {
309         m_currentMediaEngine = engines[0];
310         m_private = engines[0]->constructor(this);
311         if (m_mediaPlayerClient)
312             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
313     }
314 #endif
315 }
316
317 MediaPlayer::~MediaPlayer()
318 {
319     m_mediaPlayerClient = 0;
320 }
321
322 void MediaPlayer::load(const String& url, const ContentType& contentType)
323 {
324     String type = contentType.type().lower();
325     String typeCodecs = contentType.parameter(codecs());
326
327     // If the MIME type is missing or is not meaningful, try to figure it out from the URL.
328     if (type.isEmpty() || type == applicationOctetStream() || type == textPlain()) {
329         if (protocolIs(url, "data"))
330             type = mimeTypeFromDataURL(url);
331         else {
332             size_t pos = url.reverseFind('.');
333             if (pos != notFound) {
334                 String extension = url.substring(pos + 1);
335                 String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
336                 if (!mediaType.isEmpty())
337                     type = mediaType;
338             }
339         }
340     }
341
342     m_url = url;
343     m_contentMIMEType = type;
344     m_contentTypeCodecs = typeCodecs;
345     loadWithNextMediaEngine(0);
346 }
347
348 void MediaPlayer::loadWithNextMediaEngine(MediaPlayerFactory* current)
349 {
350     MediaPlayerFactory* engine;
351
352     // If no MIME type is specified, just use the next engine.
353     if (m_contentMIMEType.isEmpty())
354         engine = nextMediaEngine(current);
355     else
356         engine = bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, current);
357
358     // Don't delete and recreate the player unless it comes from a different engine.
359     if (!engine) {
360         m_currentMediaEngine = engine;
361         m_private = nullptr;
362     } else if (m_currentMediaEngine != engine) {
363         m_currentMediaEngine = engine;
364         m_private = engine->constructor(this);
365         if (m_mediaPlayerClient)
366             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
367 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
368         m_private->setMediaPlayerProxy(m_playerProxy);
369 #endif
370         m_private->setPrivateBrowsingMode(m_privateBrowsing);
371         m_private->setPreload(m_preload);
372         m_private->setPreservesPitch(preservesPitch());
373         if (m_shouldPrepareToRender)
374             m_private->prepareForRendering();
375     }
376
377     if (m_private)
378         m_private->load(m_url);
379     else {
380         m_private = createNullMediaPlayer(this);
381         if (m_mediaPlayerClient)
382             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
383     }
384 }    
385
386 bool MediaPlayer::hasAvailableVideoFrame() const
387 {
388     return m_private->hasAvailableVideoFrame();
389 }
390
391 void MediaPlayer::prepareForRendering()
392 {
393     m_shouldPrepareToRender = true;
394     m_private->prepareForRendering();
395 }
396
397 bool MediaPlayer::canLoadPoster() const
398 {
399     return m_private->canLoadPoster();
400 }
401
402 void MediaPlayer::setPoster(const String& url)
403 {
404     m_private->setPoster(url);
405 }    
406
407 void MediaPlayer::cancelLoad()
408 {
409     m_private->cancelLoad();
410 }    
411
412 void MediaPlayer::prepareToPlay()
413 {
414     m_private->prepareToPlay();
415 }
416
417 void MediaPlayer::play()
418 {
419     m_private->play();
420 }
421
422 void MediaPlayer::pause()
423 {
424     m_private->pause();
425 }
426
427 float MediaPlayer::duration() const
428 {
429     return m_private->duration();
430 }
431
432 float MediaPlayer::startTime() const
433 {
434     return m_private->startTime();
435 }
436
437 float MediaPlayer::currentTime() const
438 {
439     return m_private->currentTime();
440 }
441
442 void MediaPlayer::seek(float time)
443 {
444     m_private->seek(time);
445 }
446
447 bool MediaPlayer::paused() const
448 {
449     return m_private->paused();
450 }
451
452 bool MediaPlayer::seeking() const
453 {
454     return m_private->seeking();
455 }
456
457 bool MediaPlayer::supportsFullscreen() const
458 {
459     return m_private->supportsFullscreen();
460 }
461
462 bool MediaPlayer::supportsSave() const
463 {
464     return m_private->supportsSave();
465 }
466
467 IntSize MediaPlayer::naturalSize()
468 {
469     return m_private->naturalSize();
470 }
471
472 bool MediaPlayer::hasVideo() const
473 {
474     return m_private->hasVideo();
475 }
476
477 bool MediaPlayer::hasAudio() const
478 {
479     return m_private->hasAudio();
480 }
481
482 bool MediaPlayer::inMediaDocument()
483 {
484     Frame* frame = m_frameView ? m_frameView->frame() : 0;
485     Document* document = frame ? frame->document() : 0;
486
487     return document && document->isMediaDocument();
488 }
489
490 PlatformMedia MediaPlayer::platformMedia() const
491 {
492     return m_private->platformMedia();
493 }
494
495 #if USE(ACCELERATED_COMPOSITING)
496 PlatformLayer* MediaPlayer::platformLayer() const
497 {
498     return m_private->platformLayer();
499 }
500 #endif
501
502 MediaPlayer::NetworkState MediaPlayer::networkState()
503 {
504     return m_private->networkState();
505 }
506
507 MediaPlayer::ReadyState MediaPlayer::readyState()
508 {
509     return m_private->readyState();
510 }
511
512 float MediaPlayer::volume() const
513 {
514     return m_volume;
515 }
516
517 void MediaPlayer::setVolume(float volume)
518 {
519     m_volume = volume;
520
521     if (m_private->supportsMuting() || !m_muted)
522         m_private->setVolume(volume);
523 }
524
525 bool MediaPlayer::muted() const
526 {
527     return m_muted;
528 }
529
530 void MediaPlayer::setMuted(bool muted)
531 {
532     m_muted = muted;
533
534     if (m_private->supportsMuting())
535         m_private->setMuted(muted);
536     else
537         m_private->setVolume(muted ? 0 : m_volume);
538 }
539
540 bool MediaPlayer::hasClosedCaptions() const
541 {
542     return m_private->hasClosedCaptions();
543 }
544
545 void MediaPlayer::setClosedCaptionsVisible(bool closedCaptionsVisible)
546 {
547     m_private->setClosedCaptionsVisible(closedCaptionsVisible);
548 }
549
550 float MediaPlayer::rate() const
551 {
552     return m_rate;
553 }
554
555 void MediaPlayer::setRate(float rate)
556 {
557     m_rate = rate;
558     m_private->setRate(rate);   
559 }
560
561 bool MediaPlayer::preservesPitch() const
562 {
563     return m_preservesPitch;
564 }
565
566 void MediaPlayer::setPreservesPitch(bool preservesPitch)
567 {
568     m_preservesPitch = preservesPitch;
569     m_private->setPreservesPitch(preservesPitch);
570 }
571
572 PassRefPtr<TimeRanges> MediaPlayer::buffered()
573 {
574     return m_private->buffered();
575 }
576
577 float MediaPlayer::maxTimeSeekable()
578 {
579     return m_private->maxTimeSeekable();
580 }
581
582 unsigned MediaPlayer::bytesLoaded()
583 {
584     return m_private->bytesLoaded();
585 }
586
587 void MediaPlayer::setSize(const IntSize& size)
588
589     m_size = size;
590     m_private->setSize(size);
591 }
592
593 bool MediaPlayer::visible() const
594 {
595     return m_visible;
596 }
597
598 void MediaPlayer::setVisible(bool b)
599 {
600     m_visible = b;
601     m_private->setVisible(b);
602 }
603
604 MediaPlayer::Preload MediaPlayer::preload() const
605 {
606     return m_preload;
607 }
608
609 void MediaPlayer::setPreload(MediaPlayer::Preload preload)
610 {
611     m_preload = preload;
612     m_private->setPreload(preload);
613 }
614
615 void MediaPlayer::paint(GraphicsContext* p, const IntRect& r)
616 {
617     m_private->paint(p, r);
618 }
619
620 void MediaPlayer::paintCurrentFrameInContext(GraphicsContext* p, const IntRect& r)
621 {
622     m_private->paintCurrentFrameInContext(p, r);
623 }
624
625 MediaPlayer::SupportsType MediaPlayer::supportsType(const ContentType& contentType)
626 {
627     String type = contentType.type().lower();
628     String typeCodecs = contentType.parameter(codecs());
629
630     // 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the 
631     // user agent knows it cannot render or is the type "application/octet-stream"
632     if (type == applicationOctetStream())
633         return IsNotSupported;
634
635     MediaPlayerFactory* engine = bestMediaEngineForTypeAndCodecs(type, typeCodecs);
636     if (!engine)
637         return IsNotSupported;
638
639     return engine->supportsTypeAndCodecs(type, typeCodecs);
640 }
641
642 void MediaPlayer::getSupportedTypes(HashSet<String>& types)
643 {
644     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
645     if (engines.isEmpty())
646         return;
647
648     unsigned count = engines.size();
649     for (unsigned ndx = 0; ndx < count; ndx++)
650         engines[ndx]->getSupportedTypes(types);
651
652
653 bool MediaPlayer::isAvailable()
654 {
655     return !installedMediaEngines().isEmpty();
656
657
658 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
659 void MediaPlayer::deliverNotification(MediaPlayerProxyNotificationType notification)
660 {
661     m_private->deliverNotification(notification);
662 }
663
664 void MediaPlayer::setMediaPlayerProxy(WebMediaPlayerProxy* proxy)
665 {
666     m_playerProxy = proxy;
667     m_private->setMediaPlayerProxy(proxy);
668 }
669
670 void MediaPlayer::setControls(bool controls)
671 {
672     m_private->setControls(controls);
673 }    
674
675 void MediaPlayer::enterFullscreen()
676 {
677     m_private->enterFullscreen();
678 }    
679
680 void MediaPlayer::exitFullscreen()
681 {
682     m_private->exitFullscreen();
683 }    
684 #endif
685
686 #if USE(ACCELERATED_COMPOSITING)
687 void MediaPlayer::acceleratedRenderingStateChanged()
688 {
689     m_private->acceleratedRenderingStateChanged();
690 }
691
692 bool MediaPlayer::supportsAcceleratedRendering() const
693 {
694     return m_private->supportsAcceleratedRendering();
695 }
696 #endif // USE(ACCELERATED_COMPOSITING)
697
698 bool MediaPlayer::hasSingleSecurityOrigin() const
699 {
700     return m_private->hasSingleSecurityOrigin();
701 }
702
703 MediaPlayer::MovieLoadType MediaPlayer::movieLoadType() const
704 {
705     return m_private->movieLoadType();
706 }
707
708 float MediaPlayer::mediaTimeForTimeValue(float timeValue) const
709 {
710     return m_private->mediaTimeForTimeValue(timeValue);
711 }
712
713 double MediaPlayer::maximumDurationToCacheMediaTime() const
714 {
715     return m_private->maximumDurationToCacheMediaTime();
716 }
717
718 unsigned MediaPlayer::decodedFrameCount() const
719 {
720     return m_private->decodedFrameCount();
721 }
722
723 unsigned MediaPlayer::droppedFrameCount() const
724 {
725     return m_private->droppedFrameCount();
726 }
727
728 unsigned MediaPlayer::audioDecodedByteCount() const
729 {
730     return m_private->audioDecodedByteCount();
731 }
732
733 unsigned MediaPlayer::videoDecodedByteCount() const
734 {
735     return m_private->videoDecodedByteCount();
736 }
737
738 void MediaPlayer::reloadTimerFired(Timer<MediaPlayer>*)
739 {
740     m_private->cancelLoad();
741     loadWithNextMediaEngine(m_currentMediaEngine);
742 }
743
744 void MediaPlayer::getSitesInMediaCache(Vector<String>& sites)
745 {
746     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
747     unsigned size = engines.size();
748     for (unsigned i = 0; i < size; i++) {
749         if (!engines[i]->getSitesInMediaCache)
750             continue;
751         Vector<String> engineSites;
752         engines[i]->getSitesInMediaCache(engineSites);
753         sites.append(engineSites);
754     }
755 }
756
757 void MediaPlayer::clearMediaCache()
758 {
759     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
760     unsigned size = engines.size();
761     for (unsigned i = 0; i < size; i++) {
762         if (engines[i]->clearMediaCache)
763             engines[i]->clearMediaCache();
764     }
765 }
766
767 void MediaPlayer::clearMediaCacheForSite(const String& site)
768 {
769     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
770     unsigned size = engines.size();
771     for (unsigned i = 0; i < size; i++) {
772         if (engines[i]->clearMediaCacheForSite)
773             engines[i]->clearMediaCacheForSite(site);
774     }
775 }
776
777 void MediaPlayer::setPrivateBrowsingMode(bool privateBrowsingMode)
778 {
779     m_privateBrowsing = privateBrowsingMode;
780     m_private->setPrivateBrowsingMode(m_privateBrowsing);
781 }
782
783 // Client callbacks.
784 void MediaPlayer::networkStateChanged()
785 {
786     // If more than one media engine is installed and this one failed before finding metadata,
787     // let the next engine try.
788     if (m_private->networkState() >= FormatError
789         && m_private->readyState() < HaveMetadata
790         && installedMediaEngines().size() > 1) {
791         if ( m_contentMIMEType.isEmpty() || bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, m_currentMediaEngine)) {
792             m_reloadTimer.startOneShot(0);
793             return;
794         }
795     }
796     if (m_mediaPlayerClient)
797         m_mediaPlayerClient->mediaPlayerNetworkStateChanged(this);
798 }
799
800 void MediaPlayer::readyStateChanged()
801 {
802     if (m_mediaPlayerClient)
803         m_mediaPlayerClient->mediaPlayerReadyStateChanged(this);
804 }
805
806 void MediaPlayer::volumeChanged(float newVolume)
807 {
808     m_volume = newVolume;
809     if (m_mediaPlayerClient)
810         m_mediaPlayerClient->mediaPlayerVolumeChanged(this);
811 }
812
813 void MediaPlayer::muteChanged(bool newMuted)
814 {
815     m_muted = newMuted;
816     if (m_mediaPlayerClient)
817         m_mediaPlayerClient->mediaPlayerMuteChanged(this);
818 }
819
820 void MediaPlayer::timeChanged()
821 {
822     if (m_mediaPlayerClient)
823         m_mediaPlayerClient->mediaPlayerTimeChanged(this);
824 }
825
826 void MediaPlayer::sizeChanged()
827 {
828     if (m_mediaPlayerClient)
829         m_mediaPlayerClient->mediaPlayerSizeChanged(this);
830 }
831
832 void MediaPlayer::repaint()
833 {
834     if (m_mediaPlayerClient)
835         m_mediaPlayerClient->mediaPlayerRepaint(this);
836 }
837
838 void MediaPlayer::durationChanged()
839 {
840     if (m_mediaPlayerClient)
841         m_mediaPlayerClient->mediaPlayerDurationChanged(this);
842 }
843
844 void MediaPlayer::rateChanged()
845 {
846     if (m_mediaPlayerClient)
847         m_mediaPlayerClient->mediaPlayerRateChanged(this);
848 }
849
850 void MediaPlayer::playbackStateChanged()
851 {
852     if (m_mediaPlayerClient)
853         m_mediaPlayerClient->mediaPlayerPlaybackStateChanged(this);
854 }
855
856 void MediaPlayer::firstVideoFrameAvailable()
857 {
858     if (m_mediaPlayerClient)
859         m_mediaPlayerClient->mediaPlayerFirstVideoFrameAvailable(this);
860 }
861
862 void MediaPlayer::characteristicChanged()
863 {
864     if (m_mediaPlayerClient)
865         m_mediaPlayerClient->mediaPlayerCharacteristicChanged(this);
866 }
867
868 }
869
870 #endif