Unreviewed, rolling out r119125.
[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 "Logging.h"
37 #include "MIMETypeRegistry.h"
38 #include "MediaPlayerPrivate.h"
39 #include "Settings.h"
40 #include "TimeRanges.h"
41 #include <wtf/text/CString.h>
42
43 #if PLATFORM(QT)
44 #include <QtGlobal>
45 #endif
46
47 #if USE(GSTREAMER)
48 #include "MediaPlayerPrivateGStreamer.h"
49 #define PlatformMediaEngineClassName MediaPlayerPrivateGStreamer
50 #endif
51
52 #if PLATFORM(MAC) || (PLATFORM(QT) && USE(QTKIT))
53 #include "MediaPlayerPrivateQTKit.h"
54 #if USE(AVFOUNDATION)
55 #include "MediaPlayerPrivateAVFoundationObjC.h"
56 #endif
57 #define PlatformMediaEngineClassName MediaPlayerPrivateQTKit
58 #elif OS(WINCE) && !PLATFORM(QT)
59 #include "MediaPlayerPrivateWinCE.h"
60 #define PlatformMediaEngineClassName MediaPlayerPrivate
61 #elif PLATFORM(WIN)
62 #include "MediaPlayerPrivateQuickTimeVisualContext.h"
63 #define PlatformMediaEngineClassName MediaPlayerPrivateQuickTimeVisualContext
64 #if USE(AVFOUNDATION)
65 #include "MediaPlayerPrivateAVFoundationCF.h"
66 #endif
67 #elif PLATFORM(QT)
68 #if USE(QT_MULTIMEDIA) && !USE(GSTREAMER)
69 #include "MediaPlayerPrivateQt.h"
70 #define PlatformMediaEngineClassName MediaPlayerPrivateQt
71 #endif
72 #elif PLATFORM(CHROMIUM)
73 #include "MediaPlayerPrivateChromium.h"
74 #define PlatformMediaEngineClassName MediaPlayerPrivate
75 #elif PLATFORM(BLACKBERRY)
76 #include "MediaPlayerPrivateBlackBerry.h"
77 #define PlatformMediaEngineClassName MediaPlayerPrivate
78 #endif
79
80 namespace WebCore {
81
82 const PlatformMedia NoPlatformMedia = { PlatformMedia::None, {0} };
83
84 // a null player to make MediaPlayer logic simpler
85
86 class NullMediaPlayerPrivate : public MediaPlayerPrivateInterface {
87 public:
88     NullMediaPlayerPrivate(MediaPlayer*) { }
89
90     virtual void load(const String&) { }
91     virtual void cancelLoad() { }
92
93     virtual void prepareToPlay() { }
94     virtual void play() { }
95     virtual void pause() { }    
96
97     virtual PlatformMedia platformMedia() const { return NoPlatformMedia; }
98 #if USE(ACCELERATED_COMPOSITING)
99     virtual PlatformLayer* platformLayer() const { return 0; }
100 #endif
101
102     virtual IntSize naturalSize() const { return IntSize(0, 0); }
103
104     virtual bool hasVideo() const { return false; }
105     virtual bool hasAudio() const { return false; }
106
107     virtual void setVisible(bool) { }
108
109     virtual float duration() const { return 0; }
110
111     virtual float currentTime() const { return 0; }
112     virtual void seek(float) { }
113     virtual bool seeking() const { return false; }
114
115     virtual void setRate(float) { }
116     virtual void setPreservesPitch(bool) { }
117     virtual bool paused() const { return false; }
118
119     virtual void setVolume(float) { }
120
121     virtual bool supportsMuting() const { return false; }
122     virtual void setMuted(bool) { }
123
124     virtual bool hasClosedCaptions() const { return false; }
125     virtual void setClosedCaptionsVisible(bool) { };
126
127     virtual MediaPlayer::NetworkState networkState() const { return MediaPlayer::Empty; }
128     virtual MediaPlayer::ReadyState readyState() const { return MediaPlayer::HaveNothing; }
129
130     virtual float maxTimeSeekable() const { return 0; }
131     virtual PassRefPtr<TimeRanges> buffered() const { return TimeRanges::create(); }
132
133     virtual unsigned totalBytes() const { return 0; }
134     virtual unsigned bytesLoaded() const { return 0; }
135
136     virtual void setSize(const IntSize&) { }
137
138     virtual void paint(GraphicsContext*, const IntRect&) { }
139
140     virtual bool canLoadPoster() const { return false; }
141     virtual void setPoster(const String&) { }
142
143 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
144     virtual void deliverNotification(MediaPlayerProxyNotificationType) { }
145     virtual void setMediaPlayerProxy(WebMediaPlayerProxy*) { }
146     virtual void setControls(bool) { }
147 #endif
148
149     virtual bool hasSingleSecurityOrigin() const { return true; }
150
151 #if ENABLE(MEDIA_SOURCE)
152     virtual MediaPlayer::AddIdStatus sourceAddId(const String& id, const String& type, const Vector<String>& codecs) { return MediaPlayer::NotSupported; }
153     virtual PassRefPtr<TimeRanges> sourceBuffered(const String&) { return TimeRanges::create(); }
154     virtual bool sourceRemoveId(const String&) { return false; }
155     virtual bool sourceAppend(const String&, const unsigned char*, unsigned) { return false; }
156     virtual bool sourceAbort(const String&) { return false; }
157     virtual void sourceEndOfStream(MediaPlayer::EndOfStreamStatus) { }
158 #endif
159
160 #if ENABLE(ENCRYPTED_MEDIA)
161     virtual MediaPlayer::MediaKeyException generateKeyRequest(const String&, const unsigned char*, unsigned) OVERRIDE { return MediaPlayer::InvalidPlayerState; }
162     virtual MediaPlayer::MediaKeyException addKey(const String&, const unsigned char*, unsigned, const unsigned char*, unsigned, const String&) OVERRIDE { return MediaPlayer::InvalidPlayerState; }
163     virtual MediaPlayer::MediaKeyException cancelKeyRequest(const String&, const String&) OVERRIDE { return MediaPlayer::InvalidPlayerState; }
164 #endif
165 };
166
167 static PassOwnPtr<MediaPlayerPrivateInterface> createNullMediaPlayer(MediaPlayer* player) 
168
169     return adoptPtr(new NullMediaPlayerPrivate(player)); 
170 }
171
172
173 // engine support
174
175 struct MediaPlayerFactory {
176     WTF_MAKE_NONCOPYABLE(MediaPlayerFactory); WTF_MAKE_FAST_ALLOCATED;
177 public:
178     MediaPlayerFactory(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsTypeAndCodecs,
179         MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite) 
180         : constructor(constructor)
181         , getSupportedTypes(getSupportedTypes)
182         , supportsTypeAndCodecs(supportsTypeAndCodecs)
183         , getSitesInMediaCache(getSitesInMediaCache)
184         , clearMediaCache(clearMediaCache)
185         , clearMediaCacheForSite(clearMediaCacheForSite)
186
187     { 
188     }
189
190     CreateMediaEnginePlayer constructor;
191     MediaEngineSupportedTypes getSupportedTypes;
192     MediaEngineSupportsType supportsTypeAndCodecs;
193     MediaEngineGetSitesInMediaCache getSitesInMediaCache;
194     MediaEngineClearMediaCache clearMediaCache;
195     MediaEngineClearMediaCacheForSite clearMediaCacheForSite;
196 };
197
198 static void addMediaEngine(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite);
199 static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, const String& keySystem, MediaPlayerFactory* current = 0);
200 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current);
201
202 static Vector<MediaPlayerFactory*>& installedMediaEngines() 
203 {
204     DEFINE_STATIC_LOCAL(Vector<MediaPlayerFactory*>, installedEngines, ());
205     static bool enginesQueried = false;
206
207     if (!enginesQueried) {
208         enginesQueried = true;
209
210 #if USE(AVFOUNDATION)
211         if (Settings::isAVFoundationEnabled()) {
212 #if PLATFORM(MAC)
213             MediaPlayerPrivateAVFoundationObjC::registerMediaEngine(addMediaEngine);
214 #elif PLATFORM(WIN)
215             MediaPlayerPrivateAVFoundationCF::registerMediaEngine(addMediaEngine);
216 #endif
217         }
218 #endif
219
220 #if defined(PlatformMediaEngineClassName)
221         PlatformMediaEngineClassName::registerMediaEngine(addMediaEngine);
222 #endif
223     }
224
225     return installedEngines;
226 }
227
228 static void addMediaEngine(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,
229     MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite)
230 {
231     ASSERT(constructor);
232     ASSERT(getSupportedTypes);
233     ASSERT(supportsType);
234
235     installedMediaEngines().append(new MediaPlayerFactory(constructor, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite));
236 }
237
238 static const AtomicString& applicationOctetStream()
239 {
240     DEFINE_STATIC_LOCAL(const AtomicString, applicationOctetStream, ("application/octet-stream"));
241     return applicationOctetStream;
242 }
243
244 static const AtomicString& textPlain()
245 {
246     DEFINE_STATIC_LOCAL(const AtomicString, textPlain, ("text/plain"));
247     return textPlain;
248 }
249
250 static const AtomicString& codecs()
251 {
252     DEFINE_STATIC_LOCAL(const AtomicString, codecs, ("codecs"));
253     return codecs;
254 }
255
256 static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, const String& keySystem, MediaPlayerFactory* current)
257 {
258     if (type.isEmpty())
259         return 0;
260
261     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
262     if (engines.isEmpty())
263         return 0;
264
265     // 4.8.10.3 MIME types - In the absence of a specification to the contrary, the MIME type "application/octet-stream" 
266     // when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows 
267     // it cannot render.
268     if (type == applicationOctetStream()) {
269         if (!codecs.isEmpty())
270             return 0;
271     }
272
273     MediaPlayerFactory* engine = 0;
274     MediaPlayer::SupportsType supported = MediaPlayer::IsNotSupported;
275     unsigned count = engines.size();
276     for (unsigned ndx = 0; ndx < count; ndx++) {
277         if (current) {
278             if (current == engines[ndx])
279                 current = 0;
280             continue;
281         }
282 #if ENABLE(ENCRYPTED_MEDIA)
283         MediaPlayer::SupportsType engineSupport = engines[ndx]->supportsTypeAndCodecs(type, codecs, keySystem);
284 #else
285         UNUSED_PARAM(keySystem);
286         ASSERT(keySystem.isEmpty());
287         MediaPlayer::SupportsType engineSupport = engines[ndx]->supportsTypeAndCodecs(type, codecs);
288 #endif
289         if (engineSupport > supported) {
290             supported = engineSupport;
291             engine = engines[ndx];
292         }
293     }
294
295     return engine;
296 }
297
298 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current)
299 {
300     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
301     if (engines.isEmpty())
302         return 0;
303
304     if (!current) 
305         return engines.first();
306
307     size_t currentIndex = engines.find(current);
308     if (currentIndex == WTF::notFound || currentIndex + 1 >= engines.size()) 
309         return 0;
310
311     return engines[currentIndex + 1];
312 }
313
314 // media player
315
316 MediaPlayer::MediaPlayer(MediaPlayerClient* client)
317     : m_mediaPlayerClient(client)
318     , m_reloadTimer(this, &MediaPlayer::reloadTimerFired)
319     , m_private(createNullMediaPlayer(this))
320     , m_currentMediaEngine(0)
321     , m_frameView(0)
322     , m_preload(Auto)
323     , m_visible(false)
324     , m_rate(1.0f)
325     , m_volume(1.0f)
326     , m_muted(false)
327     , m_preservesPitch(true)
328     , m_privateBrowsing(false)
329     , m_shouldPrepareToRender(false)
330     , m_contentMIMETypeWasInferredFromExtension(false)
331 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
332     , m_playerProxy(0)
333 #endif
334 {
335 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
336     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
337     if (!engines.isEmpty()) {
338         m_currentMediaEngine = engines[0];
339         m_private = engines[0]->constructor(this);
340         if (m_mediaPlayerClient)
341             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
342     }
343 #endif
344 }
345
346 MediaPlayer::~MediaPlayer()
347 {
348     m_mediaPlayerClient = 0;
349 }
350
351 bool MediaPlayer::load(const KURL& url, const ContentType& contentType, const String& keySystem)
352 {
353     m_contentMIMEType = contentType.type().lower();
354     m_contentTypeCodecs = contentType.parameter(codecs());
355     m_url = url.string();
356     m_keySystem = keySystem.lower();
357     m_contentMIMETypeWasInferredFromExtension = false;
358
359     // If the MIME type is missing or is not meaningful, try to figure it out from the URL.
360     if (m_contentMIMEType.isEmpty() || m_contentMIMEType == applicationOctetStream() || m_contentMIMEType == textPlain()) {
361         if (protocolIs(m_url, "data"))
362             m_contentMIMEType = mimeTypeFromDataURL(m_url);
363         else {
364             String lastPathComponent = url.lastPathComponent();
365             size_t pos = lastPathComponent.reverseFind('.');
366             if (pos != notFound) {
367                 String extension = lastPathComponent.substring(pos + 1);
368                 String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
369                 if (!mediaType.isEmpty()) {
370                     m_contentMIMEType = mediaType;
371                     m_contentMIMETypeWasInferredFromExtension = true;
372                 }
373             }
374         }
375     }
376
377     loadWithNextMediaEngine(0);
378     return m_currentMediaEngine;
379 }
380
381 void MediaPlayer::loadWithNextMediaEngine(MediaPlayerFactory* current)
382 {
383     MediaPlayerFactory* engine = 0;
384
385     if (!m_contentMIMEType.isEmpty())
386         engine = bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, m_keySystem, current);
387
388     // If no MIME type is specified or the type was inferred from the file extension, just use the next engine.
389     if (!engine && (m_contentMIMEType.isEmpty() || m_contentMIMETypeWasInferredFromExtension))
390         engine = nextMediaEngine(current);
391
392     // Don't delete and recreate the player unless it comes from a different engine.
393     if (!engine) {
394         LOG(Media, "MediaPlayer::loadWithNextMediaEngine - no media engine found for type \"%s\"", m_contentMIMEType.utf8().data());
395         m_currentMediaEngine = engine;
396         m_private = nullptr;
397     } else if (m_currentMediaEngine != engine) {
398         m_currentMediaEngine = engine;
399         m_private = engine->constructor(this);
400         if (m_mediaPlayerClient)
401             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
402 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
403         m_private->setMediaPlayerProxy(m_playerProxy);
404 #endif
405         m_private->setPrivateBrowsingMode(m_privateBrowsing);
406         m_private->setPreload(m_preload);
407         m_private->setPreservesPitch(preservesPitch());
408         if (m_shouldPrepareToRender)
409             m_private->prepareForRendering();
410     }
411
412     if (m_private)
413         m_private->load(m_url);
414     else {
415         m_private = createNullMediaPlayer(this);
416         if (m_mediaPlayerClient) {
417             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
418             m_mediaPlayerClient->mediaPlayerResourceNotSupported(this);
419         }
420     }
421 }    
422
423 bool MediaPlayer::hasAvailableVideoFrame() const
424 {
425     return m_private->hasAvailableVideoFrame();
426 }
427
428 void MediaPlayer::prepareForRendering()
429 {
430     m_shouldPrepareToRender = true;
431     m_private->prepareForRendering();
432 }
433
434 bool MediaPlayer::canLoadPoster() const
435 {
436     return m_private->canLoadPoster();
437 }
438
439 void MediaPlayer::setPoster(const String& url)
440 {
441     m_private->setPoster(url);
442 }    
443
444 void MediaPlayer::cancelLoad()
445 {
446     m_private->cancelLoad();
447 }    
448
449 void MediaPlayer::prepareToPlay()
450 {
451     m_private->prepareToPlay();
452 }
453
454 void MediaPlayer::play()
455 {
456     m_private->play();
457 }
458
459 void MediaPlayer::pause()
460 {
461     m_private->pause();
462 }
463
464 #if ENABLE(MEDIA_SOURCE)
465
466 MediaPlayer::AddIdStatus MediaPlayer::sourceAddId(const String& id, const String& type, const Vector<String>& codecs)
467 {
468     return m_private->sourceAddId(id, type, codecs);
469 }
470
471 PassRefPtr<TimeRanges> MediaPlayer::sourceBuffered(const String& id)
472 {
473     return m_private->sourceBuffered(id);
474 }
475
476 bool MediaPlayer::sourceRemoveId(const String& id)
477 {
478     return m_private->sourceRemoveId(id);
479 }
480
481 bool MediaPlayer::sourceAppend(const String& id, const unsigned char* data, unsigned length)
482 {
483     return m_private->sourceAppend(id, data, length);
484 }
485
486 bool MediaPlayer::sourceAbort(const String& id)
487 {
488     return m_private->sourceAbort(id);
489 }
490
491 void MediaPlayer::sourceEndOfStream(MediaPlayer::EndOfStreamStatus status)
492 {
493     return m_private->sourceEndOfStream(status);
494 }
495 #endif
496
497 #if ENABLE(ENCRYPTED_MEDIA)
498 MediaPlayer::MediaKeyException MediaPlayer::generateKeyRequest(const String& keySystem, const unsigned char* initData, unsigned initDataLength)
499 {
500     return m_private->generateKeyRequest(keySystem.lower(), initData, initDataLength);
501 }
502
503 MediaPlayer::MediaKeyException MediaPlayer::addKey(const String& keySystem, const unsigned char* key, unsigned keyLength, const unsigned char* initData, unsigned initDataLength, const String& sessionId)
504 {
505     return m_private->addKey(keySystem.lower(), key, keyLength, initData, initDataLength, sessionId);
506 }
507
508 MediaPlayer::MediaKeyException MediaPlayer::cancelKeyRequest(const String& keySystem, const String& sessionId)
509 {
510     return m_private->cancelKeyRequest(keySystem.lower(), sessionId);
511 }
512 #endif
513
514 float MediaPlayer::duration() const
515 {
516     return m_private->duration();
517 }
518
519 float MediaPlayer::startTime() const
520 {
521     return m_private->startTime();
522 }
523
524 double MediaPlayer::initialTime() const
525 {
526     return m_private->initialTime();
527 }
528
529 float MediaPlayer::currentTime() const
530 {
531     return m_private->currentTime();
532 }
533
534 void MediaPlayer::seek(float time)
535 {
536     m_private->seek(time);
537 }
538
539 bool MediaPlayer::paused() const
540 {
541     return m_private->paused();
542 }
543
544 bool MediaPlayer::seeking() const
545 {
546     return m_private->seeking();
547 }
548
549 bool MediaPlayer::supportsFullscreen() const
550 {
551     return m_private->supportsFullscreen();
552 }
553
554 bool MediaPlayer::supportsSave() const
555 {
556     return m_private->supportsSave();
557 }
558
559 bool MediaPlayer::supportsScanning() const
560 {
561     return m_private->supportsScanning();
562 }
563
564 IntSize MediaPlayer::naturalSize()
565 {
566     return m_private->naturalSize();
567 }
568
569 bool MediaPlayer::hasVideo() const
570 {
571     return m_private->hasVideo();
572 }
573
574 bool MediaPlayer::hasAudio() const
575 {
576     return m_private->hasAudio();
577 }
578
579 bool MediaPlayer::inMediaDocument()
580 {
581     Frame* frame = m_frameView ? m_frameView->frame() : 0;
582     Document* document = frame ? frame->document() : 0;
583
584     return document && document->isMediaDocument();
585 }
586
587 PlatformMedia MediaPlayer::platformMedia() const
588 {
589     return m_private->platformMedia();
590 }
591
592 #if USE(ACCELERATED_COMPOSITING)
593 PlatformLayer* MediaPlayer::platformLayer() const
594 {
595     return m_private->platformLayer();
596 }
597 #endif
598
599 MediaPlayer::NetworkState MediaPlayer::networkState()
600 {
601     return m_private->networkState();
602 }
603
604 MediaPlayer::ReadyState MediaPlayer::readyState()
605 {
606     return m_private->readyState();
607 }
608
609 float MediaPlayer::volume() const
610 {
611     return m_volume;
612 }
613
614 void MediaPlayer::setVolume(float volume)
615 {
616     m_volume = volume;
617
618     if (m_private->supportsMuting() || !m_muted)
619         m_private->setVolume(volume);
620 }
621
622 bool MediaPlayer::muted() const
623 {
624     return m_muted;
625 }
626
627 void MediaPlayer::setMuted(bool muted)
628 {
629     m_muted = muted;
630
631     if (m_private->supportsMuting())
632         m_private->setMuted(muted);
633     else
634         m_private->setVolume(muted ? 0 : m_volume);
635 }
636
637 bool MediaPlayer::hasClosedCaptions() const
638 {
639     return m_private->hasClosedCaptions();
640 }
641
642 void MediaPlayer::setClosedCaptionsVisible(bool closedCaptionsVisible)
643 {
644     m_private->setClosedCaptionsVisible(closedCaptionsVisible);
645 }
646
647 float MediaPlayer::rate() const
648 {
649     return m_rate;
650 }
651
652 void MediaPlayer::setRate(float rate)
653 {
654     m_rate = rate;
655     m_private->setRate(rate);   
656 }
657
658 bool MediaPlayer::preservesPitch() const
659 {
660     return m_preservesPitch;
661 }
662
663 void MediaPlayer::setPreservesPitch(bool preservesPitch)
664 {
665     m_preservesPitch = preservesPitch;
666     m_private->setPreservesPitch(preservesPitch);
667 }
668
669 PassRefPtr<TimeRanges> MediaPlayer::buffered()
670 {
671     return m_private->buffered();
672 }
673
674 PassRefPtr<TimeRanges> MediaPlayer::seekable()
675 {
676     return m_private->seekable();
677 }
678
679 float MediaPlayer::maxTimeSeekable()
680 {
681     return m_private->maxTimeSeekable();
682 }
683
684 unsigned MediaPlayer::bytesLoaded()
685 {
686     return m_private->bytesLoaded();
687 }
688
689 void MediaPlayer::setSize(const IntSize& size)
690
691     m_size = size;
692     m_private->setSize(size);
693 }
694
695 bool MediaPlayer::visible() const
696 {
697     return m_visible;
698 }
699
700 void MediaPlayer::setVisible(bool b)
701 {
702     m_visible = b;
703     m_private->setVisible(b);
704 }
705
706 MediaPlayer::Preload MediaPlayer::preload() const
707 {
708     return m_preload;
709 }
710
711 void MediaPlayer::setPreload(MediaPlayer::Preload preload)
712 {
713     m_preload = preload;
714     m_private->setPreload(preload);
715 }
716
717 void MediaPlayer::paint(GraphicsContext* p, const IntRect& r)
718 {
719     m_private->paint(p, r);
720 }
721
722 void MediaPlayer::paintCurrentFrameInContext(GraphicsContext* p, const IntRect& r)
723 {
724     m_private->paintCurrentFrameInContext(p, r);
725 }
726
727 MediaPlayer::SupportsType MediaPlayer::supportsType(const ContentType& contentType, const String& keySystem, const MediaPlayerSupportsTypeClient* client)
728 {
729     String type = contentType.type().lower();
730     // The codecs string is not lower-cased because MP4 values are case sensitive
731     // per http://tools.ietf.org/html/rfc4281#page-7.
732     String typeCodecs = contentType.parameter(codecs());
733     String system = keySystem.lower();
734
735     // 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the 
736     // user agent knows it cannot render or is the type "application/octet-stream"
737     if (type == applicationOctetStream())
738         return IsNotSupported;
739
740     MediaPlayerFactory* engine = bestMediaEngineForTypeAndCodecs(type, typeCodecs, system);
741     if (!engine)
742         return IsNotSupported;
743
744 #if PLATFORM(MAC)
745     // YouTube will ask if the HTMLMediaElement canPlayType video/webm, then
746     // video/x-flv, then finally video/mp4, and will then load a URL of the first type
747     // in that list which returns "probably". When Perian is installed,
748     // MediaPlayerPrivateQTKit claims to support both video/webm and video/x-flv, but
749     // due to a bug in Perian, loading media in these formats will sometimes fail on
750     // slow connections. <https://bugs.webkit.org/show_bug.cgi?id=86409>
751     if (client && client->mediaPlayerNeedsSiteSpecificHacks()) {
752         String host = client->mediaPlayerDocumentHost();
753         if ((host.endsWith(".youtube.com", false) || equalIgnoringCase("youtube.com", host))
754             && (contentType.type().startsWith("video/webm", false) || contentType.type().startsWith("video/x-flv", false)))
755             return IsNotSupported;
756     }
757 #endif
758
759 #if ENABLE(ENCRYPTED_MEDIA)
760     return engine->supportsTypeAndCodecs(type, typeCodecs, system);
761 #else
762     ASSERT(system.isEmpty());
763     return engine->supportsTypeAndCodecs(type, typeCodecs);
764 #endif
765 }
766
767 void MediaPlayer::getSupportedTypes(HashSet<String>& types)
768 {
769     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
770     if (engines.isEmpty())
771         return;
772
773     unsigned count = engines.size();
774     for (unsigned ndx = 0; ndx < count; ndx++)
775         engines[ndx]->getSupportedTypes(types);
776
777
778 bool MediaPlayer::isAvailable()
779 {
780     return !installedMediaEngines().isEmpty();
781
782
783 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
784 void MediaPlayer::deliverNotification(MediaPlayerProxyNotificationType notification)
785 {
786     m_private->deliverNotification(notification);
787 }
788
789 void MediaPlayer::setMediaPlayerProxy(WebMediaPlayerProxy* proxy)
790 {
791     m_playerProxy = proxy;
792     m_private->setMediaPlayerProxy(proxy);
793 }
794
795 void MediaPlayer::setControls(bool controls)
796 {
797     m_private->setControls(controls);
798 }
799 #endif
800
801 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO) || USE(NATIVE_FULLSCREEN_VIDEO)
802 void MediaPlayer::enterFullscreen()
803 {
804     m_private->enterFullscreen();
805 }
806
807 void MediaPlayer::exitFullscreen()
808 {
809     m_private->exitFullscreen();
810 }
811 #endif
812
813 #if USE(NATIVE_FULLSCREEN_VIDEO)
814 bool MediaPlayer::canEnterFullscreen() const
815 {
816     return m_private->canEnterFullscreen();
817 }
818 #endif
819
820 #if USE(ACCELERATED_COMPOSITING)
821 void MediaPlayer::acceleratedRenderingStateChanged()
822 {
823     m_private->acceleratedRenderingStateChanged();
824 }
825
826 bool MediaPlayer::supportsAcceleratedRendering() const
827 {
828     return m_private->supportsAcceleratedRendering();
829 }
830 #endif // USE(ACCELERATED_COMPOSITING)
831
832 bool MediaPlayer::hasSingleSecurityOrigin() const
833 {
834     return m_private->hasSingleSecurityOrigin();
835 }
836
837 MediaPlayer::MovieLoadType MediaPlayer::movieLoadType() const
838 {
839     return m_private->movieLoadType();
840 }
841
842 float MediaPlayer::mediaTimeForTimeValue(float timeValue) const
843 {
844     return m_private->mediaTimeForTimeValue(timeValue);
845 }
846
847 double MediaPlayer::maximumDurationToCacheMediaTime() const
848 {
849     return m_private->maximumDurationToCacheMediaTime();
850 }
851
852 unsigned MediaPlayer::decodedFrameCount() const
853 {
854     return m_private->decodedFrameCount();
855 }
856
857 unsigned MediaPlayer::droppedFrameCount() const
858 {
859     return m_private->droppedFrameCount();
860 }
861
862 unsigned MediaPlayer::audioDecodedByteCount() const
863 {
864     return m_private->audioDecodedByteCount();
865 }
866
867 unsigned MediaPlayer::videoDecodedByteCount() const
868 {
869     return m_private->videoDecodedByteCount();
870 }
871
872 void MediaPlayer::reloadTimerFired(Timer<MediaPlayer>*)
873 {
874     m_private->cancelLoad();
875     loadWithNextMediaEngine(m_currentMediaEngine);
876 }
877
878 void MediaPlayer::getSitesInMediaCache(Vector<String>& sites)
879 {
880     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
881     unsigned size = engines.size();
882     for (unsigned i = 0; i < size; i++) {
883         if (!engines[i]->getSitesInMediaCache)
884             continue;
885         Vector<String> engineSites;
886         engines[i]->getSitesInMediaCache(engineSites);
887         sites.append(engineSites);
888     }
889 }
890
891 void MediaPlayer::clearMediaCache()
892 {
893     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
894     unsigned size = engines.size();
895     for (unsigned i = 0; i < size; i++) {
896         if (engines[i]->clearMediaCache)
897             engines[i]->clearMediaCache();
898     }
899 }
900
901 void MediaPlayer::clearMediaCacheForSite(const String& site)
902 {
903     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
904     unsigned size = engines.size();
905     for (unsigned i = 0; i < size; i++) {
906         if (engines[i]->clearMediaCacheForSite)
907             engines[i]->clearMediaCacheForSite(site);
908     }
909 }
910
911 void MediaPlayer::setPrivateBrowsingMode(bool privateBrowsingMode)
912 {
913     m_privateBrowsing = privateBrowsingMode;
914     m_private->setPrivateBrowsingMode(m_privateBrowsing);
915 }
916
917 #if ENABLE(MEDIA_SOURCE)
918 void MediaPlayer::sourceOpened()
919 {
920     if (m_mediaPlayerClient)
921         m_mediaPlayerClient->mediaPlayerSourceOpened();
922 }
923
924 String MediaPlayer::sourceURL() const
925 {
926     if (m_mediaPlayerClient)
927         return m_mediaPlayerClient->mediaPlayerSourceURL();
928     return String();
929 }
930 #endif
931
932 // Client callbacks.
933 void MediaPlayer::networkStateChanged()
934 {
935     // If more than one media engine is installed and this one failed before finding metadata,
936     // let the next engine try.
937     if (m_private->networkState() >= FormatError
938         && m_private->readyState() < HaveMetadata
939         && installedMediaEngines().size() > 1) {
940         if (m_contentMIMEType.isEmpty() || bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, m_keySystem, m_currentMediaEngine)) {
941             m_reloadTimer.startOneShot(0);
942             return;
943         }
944     }
945     if (m_mediaPlayerClient)
946         m_mediaPlayerClient->mediaPlayerNetworkStateChanged(this);
947 }
948
949 void MediaPlayer::readyStateChanged()
950 {
951     if (m_mediaPlayerClient)
952         m_mediaPlayerClient->mediaPlayerReadyStateChanged(this);
953 }
954
955 void MediaPlayer::volumeChanged(float newVolume)
956 {
957     m_volume = newVolume;
958     if (m_mediaPlayerClient)
959         m_mediaPlayerClient->mediaPlayerVolumeChanged(this);
960 }
961
962 void MediaPlayer::muteChanged(bool newMuted)
963 {
964     m_muted = newMuted;
965     if (m_mediaPlayerClient)
966         m_mediaPlayerClient->mediaPlayerMuteChanged(this);
967 }
968
969 void MediaPlayer::timeChanged()
970 {
971     if (m_mediaPlayerClient)
972         m_mediaPlayerClient->mediaPlayerTimeChanged(this);
973 }
974
975 void MediaPlayer::sizeChanged()
976 {
977     if (m_mediaPlayerClient)
978         m_mediaPlayerClient->mediaPlayerSizeChanged(this);
979 }
980
981 void MediaPlayer::repaint()
982 {
983     if (m_mediaPlayerClient)
984         m_mediaPlayerClient->mediaPlayerRepaint(this);
985 }
986
987 void MediaPlayer::durationChanged()
988 {
989     if (m_mediaPlayerClient)
990         m_mediaPlayerClient->mediaPlayerDurationChanged(this);
991 }
992
993 void MediaPlayer::rateChanged()
994 {
995     if (m_mediaPlayerClient)
996         m_mediaPlayerClient->mediaPlayerRateChanged(this);
997 }
998
999 void MediaPlayer::playbackStateChanged()
1000 {
1001     if (m_mediaPlayerClient)
1002         m_mediaPlayerClient->mediaPlayerPlaybackStateChanged(this);
1003 }
1004
1005 void MediaPlayer::firstVideoFrameAvailable()
1006 {
1007     if (m_mediaPlayerClient)
1008         m_mediaPlayerClient->mediaPlayerFirstVideoFrameAvailable(this);
1009 }
1010
1011 void MediaPlayer::characteristicChanged()
1012 {
1013     if (m_mediaPlayerClient)
1014         m_mediaPlayerClient->mediaPlayerCharacteristicChanged(this);
1015 }
1016
1017 #if ENABLE(WEB_AUDIO)
1018 AudioSourceProvider* MediaPlayer::audioSourceProvider()
1019 {
1020     return m_private->audioSourceProvider();
1021 }
1022 #endif // WEB_AUDIO
1023
1024 #if ENABLE(ENCRYPTED_MEDIA)
1025 void MediaPlayer::keyAdded(const String& keySystem, const String& sessionId)
1026 {
1027     if (m_mediaPlayerClient)
1028         m_mediaPlayerClient->mediaPlayerKeyAdded(this, keySystem, sessionId);
1029 }
1030
1031 void MediaPlayer::keyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode errorCode, unsigned short systemCode)
1032 {
1033     if (m_mediaPlayerClient)
1034         m_mediaPlayerClient->mediaPlayerKeyError(this, keySystem, sessionId, errorCode, systemCode);
1035 }
1036
1037 void MediaPlayer::keyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength)
1038 {
1039     if (m_mediaPlayerClient)
1040         m_mediaPlayerClient->mediaPlayerKeyMessage(this, keySystem, sessionId, message, messageLength);
1041 }
1042
1043 void MediaPlayer::keyNeeded(const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength)
1044 {
1045     if (m_mediaPlayerClient)
1046         m_mediaPlayerClient->mediaPlayerKeyNeeded(this, keySystem, sessionId, initData, initDataLength);
1047 }
1048 #endif
1049
1050 String MediaPlayer::referrer() const
1051 {
1052     if (!m_mediaPlayerClient)
1053         return String();
1054
1055     return m_mediaPlayerClient->mediaPlayerReferrer();
1056 }
1057
1058 String MediaPlayer::userAgent() const
1059 {
1060     if (!m_mediaPlayerClient)
1061         return String();
1062     
1063     return m_mediaPlayerClient->mediaPlayerUserAgent();
1064 }
1065
1066 }
1067
1068 #endif