Remove remaining PLATFORM(CHROMIUM)-guarded code in WebCore
[WebKit-https.git] / Source / WebCore / platform / graphics / MediaPlayer.cpp
1 /*
2  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #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 ENABLE(VIDEO_TRACK)
44 #include "InbandTextTrackPrivate.h"
45 #endif
46
47 #if ENABLE(MEDIA_SOURCE)
48 #include "MediaSource.h"
49 #endif
50
51 #if PLATFORM(QT)
52 #include <QtGlobal>
53 #endif
54
55 #if USE(GSTREAMER)
56 #include "MediaPlayerPrivateGStreamer.h"
57 #define PlatformMediaEngineClassName MediaPlayerPrivateGStreamer
58 #endif
59
60 #if PLATFORM(MAC) || (PLATFORM(QT) && USE(QTKIT))
61 #include "MediaPlayerPrivateQTKit.h"
62 #if USE(AVFOUNDATION)
63 #include "MediaPlayerPrivateAVFoundationObjC.h"
64 #endif
65 #elif OS(WINCE) && !PLATFORM(QT)
66 #include "MediaPlayerPrivateWinCE.h"
67 #define PlatformMediaEngineClassName MediaPlayerPrivate
68 #elif PLATFORM(WIN)
69 #include "MediaPlayerPrivateQuickTimeVisualContext.h"
70 #define PlatformMediaEngineClassName MediaPlayerPrivateQuickTimeVisualContext
71 #if USE(AVFOUNDATION)
72 #include "MediaPlayerPrivateAVFoundationCF.h"
73 #endif
74 #elif PLATFORM(QT)
75 #if USE(QT_MULTIMEDIA) && !USE(GSTREAMER)
76 #include "MediaPlayerPrivateQt.h"
77 #define PlatformMediaEngineClassName MediaPlayerPrivateQt
78 #endif
79 #elif PLATFORM(BLACKBERRY)
80 #include "MediaPlayerPrivateBlackBerry.h"
81 #define PlatformMediaEngineClassName MediaPlayerPrivate
82 #endif
83
84 namespace WebCore {
85
86 const PlatformMedia NoPlatformMedia = { PlatformMedia::None, {0} };
87
88 // a null player to make MediaPlayer logic simpler
89
90 class NullMediaPlayerPrivate : public MediaPlayerPrivateInterface {
91 public:
92     NullMediaPlayerPrivate(MediaPlayer*) { }
93
94     virtual void load(const String&) { }
95 #if ENABLE(MEDIA_SOURCE)
96     virtual void load(const String&, PassRefPtr<MediaSource>) { }
97 #endif
98     virtual void cancelLoad() { }
99
100     virtual void prepareToPlay() { }
101     virtual void play() { }
102     virtual void pause() { }    
103
104     virtual PlatformMedia platformMedia() const { return NoPlatformMedia; }
105 #if USE(ACCELERATED_COMPOSITING)
106     virtual PlatformLayer* platformLayer() const { return 0; }
107 #endif
108
109     virtual IntSize naturalSize() const { return IntSize(0, 0); }
110
111     virtual bool hasVideo() const { return false; }
112     virtual bool hasAudio() const { return false; }
113
114     virtual void setVisible(bool) { }
115
116     virtual float duration() const { return 0; }
117
118     virtual float currentTime() const { return 0; }
119     virtual void seek(float) { }
120     virtual bool seeking() const { return false; }
121
122     virtual void setRate(float) { }
123     virtual void setPreservesPitch(bool) { }
124     virtual bool paused() const { return false; }
125
126     virtual void setVolume(float) { }
127
128     virtual bool supportsMuting() const { return false; }
129     virtual void setMuted(bool) { }
130
131     virtual bool hasClosedCaptions() const { return false; }
132     virtual void setClosedCaptionsVisible(bool) { };
133
134     virtual MediaPlayer::NetworkState networkState() const { return MediaPlayer::Empty; }
135     virtual MediaPlayer::ReadyState readyState() const { return MediaPlayer::HaveNothing; }
136
137     virtual float maxTimeSeekable() const { return 0; }
138     virtual PassRefPtr<TimeRanges> buffered() const { return TimeRanges::create(); }
139
140     virtual unsigned totalBytes() const { return 0; }
141     virtual bool didLoadingProgress() const { return false; }
142
143     virtual void setSize(const IntSize&) { }
144
145     virtual void paint(GraphicsContext*, const IntRect&) { }
146
147     virtual bool canLoadPoster() const { return false; }
148     virtual void setPoster(const String&) { }
149
150 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
151     virtual void deliverNotification(MediaPlayerProxyNotificationType) { }
152     virtual void setMediaPlayerProxy(WebMediaPlayerProxy*) { }
153     virtual void setControls(bool) { }
154 #endif
155
156     virtual bool hasSingleSecurityOrigin() const { return true; }
157
158 #if ENABLE(ENCRYPTED_MEDIA)
159     virtual MediaPlayer::MediaKeyException generateKeyRequest(const String&, const unsigned char*, unsigned) OVERRIDE { return MediaPlayer::InvalidPlayerState; }
160     virtual MediaPlayer::MediaKeyException addKey(const String&, const unsigned char*, unsigned, const unsigned char*, unsigned, const String&) OVERRIDE { return MediaPlayer::InvalidPlayerState; }
161     virtual MediaPlayer::MediaKeyException cancelKeyRequest(const String&, const String&) OVERRIDE { return MediaPlayer::InvalidPlayerState; }
162 #endif
163 };
164
165 static PassOwnPtr<MediaPlayerPrivateInterface> createNullMediaPlayer(MediaPlayer* player) 
166
167     return adoptPtr(new NullMediaPlayerPrivate(player)); 
168 }
169
170
171 // engine support
172
173 struct MediaPlayerFactory {
174     WTF_MAKE_NONCOPYABLE(MediaPlayerFactory); WTF_MAKE_FAST_ALLOCATED;
175 public:
176     MediaPlayerFactory(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsTypeAndCodecs,
177         MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite)
178         : constructor(constructor)
179         , getSupportedTypes(getSupportedTypes)
180         , supportsTypeAndCodecs(supportsTypeAndCodecs)
181         , getSitesInMediaCache(getSitesInMediaCache)
182         , clearMediaCache(clearMediaCache)
183         , clearMediaCacheForSite(clearMediaCacheForSite)
184     {
185     }
186
187     CreateMediaEnginePlayer constructor;
188     MediaEngineSupportedTypes getSupportedTypes;
189     MediaEngineSupportsType supportsTypeAndCodecs;
190     MediaEngineGetSitesInMediaCache getSitesInMediaCache;
191     MediaEngineClearMediaCache clearMediaCache;
192     MediaEngineClearMediaCacheForSite clearMediaCacheForSite;
193 };
194
195 static void addMediaEngine(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite);
196
197 static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, const String& keySystem, const KURL&, MediaPlayerFactory* current = 0);
198 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current);
199
200 enum RequeryEngineOptions { DoNotResetEngines, ResetEngines };
201 static Vector<MediaPlayerFactory*>& installedMediaEngines(RequeryEngineOptions requeryFlags = DoNotResetEngines )
202 {
203     DEFINE_STATIC_LOCAL(Vector<MediaPlayerFactory*>, installedEngines, ());
204     static bool enginesQueried = false;
205
206     if (requeryFlags == ResetEngines) {
207         installedEngines.clear();
208         enginesQueried = false;
209         return installedEngines;
210     }
211
212     if (!enginesQueried) {
213         enginesQueried = true;
214
215 #if USE(AVFOUNDATION)
216         if (Settings::isAVFoundationEnabled()) {
217 #if PLATFORM(MAC)
218             MediaPlayerPrivateAVFoundationObjC::registerMediaEngine(addMediaEngine);
219 #elif PLATFORM(WIN)
220             MediaPlayerPrivateAVFoundationCF::registerMediaEngine(addMediaEngine);
221 #endif
222         }
223 #endif
224
225 #if PLATFORM(MAC) || (PLATFORM(QT) && USE(QTKIT))
226         if (Settings::isQTKitEnabled())
227             MediaPlayerPrivateQTKit::registerMediaEngine(addMediaEngine);
228 #endif
229
230 #if defined(PlatformMediaEngineClassName)
231         PlatformMediaEngineClassName::registerMediaEngine(addMediaEngine);
232 #endif
233     }
234
235     return installedEngines;
236 }
237
238 static void addMediaEngine(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,
239     MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite)
240 {
241     ASSERT(constructor);
242     ASSERT(getSupportedTypes);
243     ASSERT(supportsType);
244
245     installedMediaEngines().append(new MediaPlayerFactory(constructor, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite));
246 }
247
248 static const AtomicString& applicationOctetStream()
249 {
250     DEFINE_STATIC_LOCAL(const AtomicString, applicationOctetStream, ("application/octet-stream", AtomicString::ConstructFromLiteral));
251     return applicationOctetStream;
252 }
253
254 static const AtomicString& textPlain()
255 {
256     DEFINE_STATIC_LOCAL(const AtomicString, textPlain, ("text/plain", AtomicString::ConstructFromLiteral));
257     return textPlain;
258 }
259
260 static const AtomicString& codecs()
261 {
262     DEFINE_STATIC_LOCAL(const AtomicString, codecs, ("codecs", AtomicString::ConstructFromLiteral));
263     return codecs;
264 }
265
266 static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, const String& keySystem, const KURL& url, MediaPlayerFactory* current)
267 {
268     if (type.isEmpty())
269         return 0;
270
271     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
272     if (engines.isEmpty())
273         return 0;
274
275     // 4.8.10.3 MIME types - In the absence of a specification to the contrary, the MIME type "application/octet-stream" 
276     // when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows 
277     // it cannot render.
278     if (type == applicationOctetStream()) {
279         if (!codecs.isEmpty())
280             return 0;
281     }
282
283     MediaPlayerFactory* engine = 0;
284     MediaPlayer::SupportsType supported = MediaPlayer::IsNotSupported;
285     unsigned count = engines.size();
286     for (unsigned ndx = 0; ndx < count; ndx++) {
287         if (current) {
288             if (current == engines[ndx])
289                 current = 0;
290             continue;
291         }
292 #if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
293         MediaPlayer::SupportsType engineSupport = engines[ndx]->supportsTypeAndCodecs(type, codecs, keySystem, url);
294 #else
295         UNUSED_PARAM(keySystem);
296         ASSERT(keySystem.isEmpty());
297         MediaPlayer::SupportsType engineSupport = engines[ndx]->supportsTypeAndCodecs(type, codecs, url);
298 #endif
299         if (engineSupport > supported) {
300             supported = engineSupport;
301             engine = engines[ndx];
302         }
303     }
304
305     return engine;
306 }
307
308 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current)
309 {
310     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
311     if (engines.isEmpty())
312         return 0;
313
314     if (!current) 
315         return engines.first();
316
317     size_t currentIndex = engines.find(current);
318     if (currentIndex == WTF::notFound || currentIndex + 1 >= engines.size()) 
319         return 0;
320
321     return engines[currentIndex + 1];
322 }
323
324 // media player
325
326 MediaPlayer::MediaPlayer(MediaPlayerClient* client)
327     : m_mediaPlayerClient(client)
328     , m_reloadTimer(this, &MediaPlayer::reloadTimerFired)
329     , m_private(createNullMediaPlayer(this))
330     , m_currentMediaEngine(0)
331     , m_frameView(0)
332     , m_preload(Auto)
333     , m_visible(false)
334     , m_rate(1.0f)
335     , m_volume(1.0f)
336     , m_muted(false)
337     , m_preservesPitch(true)
338     , m_privateBrowsing(false)
339     , m_shouldPrepareToRender(false)
340     , m_contentMIMETypeWasInferredFromExtension(false)
341 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
342     , m_playerProxy(0)
343 #endif
344 {
345 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
346     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
347     if (!engines.isEmpty()) {
348         m_currentMediaEngine = engines[0];
349         m_private = engines[0]->constructor(this);
350         if (m_mediaPlayerClient)
351             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
352     }
353 #endif
354 }
355
356 MediaPlayer::~MediaPlayer()
357 {
358     m_mediaPlayerClient = 0;
359 }
360
361 bool MediaPlayer::load(const KURL& url, const ContentType& contentType, const String& keySystem)
362 {
363     m_contentMIMEType = contentType.type().lower();
364     m_contentTypeCodecs = contentType.parameter(codecs());
365     m_url = url;
366     m_keySystem = keySystem.lower();
367     m_contentMIMETypeWasInferredFromExtension = false;
368
369 #if ENABLE(MEDIA_SOURCE)
370     m_mediaSource = 0;
371 #endif
372
373     // If the MIME type is missing or is not meaningful, try to figure it out from the URL.
374     if (m_contentMIMEType.isEmpty() || m_contentMIMEType == applicationOctetStream() || m_contentMIMEType == textPlain()) {
375         if (m_url.protocolIsData())
376             m_contentMIMEType = mimeTypeFromDataURL(m_url.string());
377         else {
378             String lastPathComponent = url.lastPathComponent();
379             size_t pos = lastPathComponent.reverseFind('.');
380             if (pos != notFound) {
381                 String extension = lastPathComponent.substring(pos + 1);
382                 String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
383                 if (!mediaType.isEmpty()) {
384                     m_contentMIMEType = mediaType;
385                     m_contentMIMETypeWasInferredFromExtension = true;
386                 }
387             }
388         }
389     }
390
391     loadWithNextMediaEngine(0);
392     return m_currentMediaEngine;
393 }
394
395 #if ENABLE(MEDIA_SOURCE)
396 bool MediaPlayer::load(const KURL& url, PassRefPtr<MediaSource> mediaSource)
397 {
398     m_mediaSource = mediaSource;
399     m_contentMIMEType = "";
400     m_contentTypeCodecs = "";
401     m_url = url;
402     m_keySystem = "";
403     m_contentMIMETypeWasInferredFromExtension = false;
404     loadWithNextMediaEngine(0);
405     return m_currentMediaEngine;
406 }
407 #endif
408
409 void MediaPlayer::loadWithNextMediaEngine(MediaPlayerFactory* current)
410 {
411     MediaPlayerFactory* engine = 0;
412
413     if (!m_contentMIMEType.isEmpty())
414         engine = bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, m_keySystem, m_url, current);
415
416     // If no MIME type is specified or the type was inferred from the file extension, just use the next engine.
417     if (!engine && (m_contentMIMEType.isEmpty() || m_contentMIMETypeWasInferredFromExtension))
418         engine = nextMediaEngine(current);
419
420     // Don't delete and recreate the player unless it comes from a different engine.
421     if (!engine) {
422         LOG(Media, "MediaPlayer::loadWithNextMediaEngine - no media engine found for type \"%s\"", m_contentMIMEType.utf8().data());
423         m_currentMediaEngine = engine;
424         m_private = nullptr;
425     } else if (m_currentMediaEngine != engine) {
426         m_currentMediaEngine = engine;
427         m_private = engine->constructor(this);
428         if (m_mediaPlayerClient)
429             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
430 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
431         m_private->setMediaPlayerProxy(m_playerProxy);
432 #endif
433         m_private->setPrivateBrowsingMode(m_privateBrowsing);
434         m_private->setPreload(m_preload);
435         m_private->setPreservesPitch(preservesPitch());
436         if (m_shouldPrepareToRender)
437             m_private->prepareForRendering();
438     }
439
440     if (m_private) {
441 #if ENABLE(MEDIA_SOURCE)
442         if (m_mediaSource)
443             m_private->load(m_url.string(), m_mediaSource);
444         else
445 #endif
446         m_private->load(m_url.string());
447     } else {
448         m_private = createNullMediaPlayer(this);
449         if (m_mediaPlayerClient) {
450             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
451             m_mediaPlayerClient->mediaPlayerResourceNotSupported(this);
452         }
453     }
454 }
455
456 bool MediaPlayer::hasAvailableVideoFrame() const
457 {
458     return m_private->hasAvailableVideoFrame();
459 }
460
461 void MediaPlayer::prepareForRendering()
462 {
463     m_shouldPrepareToRender = true;
464     m_private->prepareForRendering();
465 }
466
467 bool MediaPlayer::canLoadPoster() const
468 {
469     return m_private->canLoadPoster();
470 }
471
472 void MediaPlayer::setPoster(const String& url)
473 {
474     m_private->setPoster(url);
475 }    
476
477 void MediaPlayer::cancelLoad()
478 {
479     m_private->cancelLoad();
480 }    
481
482 void MediaPlayer::prepareToPlay()
483 {
484     m_private->prepareToPlay();
485 }
486
487 void MediaPlayer::play()
488 {
489     m_private->play();
490 }
491
492 void MediaPlayer::pause()
493 {
494     m_private->pause();
495 }
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 bool MediaPlayer::didLoadingProgress()
685 {
686     return m_private->didLoadingProgress();
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 bool MediaPlayer::copyVideoTextureToPlatformTexture(GraphicsContext3D* context, Platform3DObject texture, GC3Dint level, GC3Denum type, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY)
728 {
729     return m_private->copyVideoTextureToPlatformTexture(context, texture, level, type, internalFormat, premultiplyAlpha, flipY);
730 }
731
732 MediaPlayer::SupportsType MediaPlayer::supportsType(const ContentType& contentType, const String& keySystem, const KURL& url, const MediaPlayerSupportsTypeClient* client)
733 {
734     String type = contentType.type().lower();
735     // The codecs string is not lower-cased because MP4 values are case sensitive
736     // per http://tools.ietf.org/html/rfc4281#page-7.
737     String typeCodecs = contentType.parameter(codecs());
738     String system = keySystem.lower();
739
740     // 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the 
741     // user agent knows it cannot render or is the type "application/octet-stream"
742     if (type == applicationOctetStream())
743         return IsNotSupported;
744
745     MediaPlayerFactory* engine = bestMediaEngineForTypeAndCodecs(type, typeCodecs, system, url);
746     if (!engine)
747         return IsNotSupported;
748
749 #if PLATFORM(MAC)
750     // YouTube will ask if the HTMLMediaElement canPlayType video/webm, then
751     // video/x-flv, then finally video/mp4, and will then load a URL of the first type
752     // in that list which returns "probably". When Perian is installed,
753     // MediaPlayerPrivateQTKit claims to support both video/webm and video/x-flv, but
754     // due to a bug in Perian, loading media in these formats will sometimes fail on
755     // slow connections. <https://bugs.webkit.org/show_bug.cgi?id=86409>
756     if (client && client->mediaPlayerNeedsSiteSpecificHacks()) {
757         String host = client->mediaPlayerDocumentHost();
758         if ((host.endsWith(".youtube.com", false) || equalIgnoringCase("youtube.com", host))
759             && (contentType.type().startsWith("video/webm", false) || contentType.type().startsWith("video/x-flv", false)))
760             return IsNotSupported;
761     }
762 #else
763     UNUSED_PARAM(client);
764 #endif
765
766 #if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
767     return engine->supportsTypeAndCodecs(type, typeCodecs, system, url);
768 #else
769     ASSERT(system.isEmpty());
770     return engine->supportsTypeAndCodecs(type, typeCodecs, url);
771 #endif
772 }
773
774 void MediaPlayer::getSupportedTypes(HashSet<String>& types)
775 {
776     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
777     if (engines.isEmpty())
778         return;
779
780     unsigned count = engines.size();
781     for (unsigned ndx = 0; ndx < count; ndx++)
782         engines[ndx]->getSupportedTypes(types);
783
784
785 bool MediaPlayer::isAvailable()
786 {
787     return !installedMediaEngines().isEmpty();
788
789
790 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
791 void MediaPlayer::deliverNotification(MediaPlayerProxyNotificationType notification)
792 {
793     m_private->deliverNotification(notification);
794 }
795
796 void MediaPlayer::setMediaPlayerProxy(WebMediaPlayerProxy* proxy)
797 {
798     m_playerProxy = proxy;
799     m_private->setMediaPlayerProxy(proxy);
800 }
801
802 void MediaPlayer::setControls(bool controls)
803 {
804     m_private->setControls(controls);
805 }
806 #endif
807
808 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO) || USE(NATIVE_FULLSCREEN_VIDEO)
809 void MediaPlayer::enterFullscreen()
810 {
811     m_private->enterFullscreen();
812 }
813
814 void MediaPlayer::exitFullscreen()
815 {
816     m_private->exitFullscreen();
817 }
818 #endif
819
820 #if USE(NATIVE_FULLSCREEN_VIDEO)
821 bool MediaPlayer::canEnterFullscreen() const
822 {
823     return m_private->canEnterFullscreen();
824 }
825 #endif
826
827 #if USE(ACCELERATED_COMPOSITING)
828 void MediaPlayer::acceleratedRenderingStateChanged()
829 {
830     m_private->acceleratedRenderingStateChanged();
831 }
832
833 bool MediaPlayer::supportsAcceleratedRendering() const
834 {
835     return m_private->supportsAcceleratedRendering();
836 }
837 #endif // USE(ACCELERATED_COMPOSITING)
838
839 bool MediaPlayer::hasSingleSecurityOrigin() const
840 {
841     return m_private->hasSingleSecurityOrigin();
842 }
843
844 bool MediaPlayer::didPassCORSAccessCheck() const
845 {
846     return m_private->didPassCORSAccessCheck();
847 }
848
849 MediaPlayer::MovieLoadType MediaPlayer::movieLoadType() const
850 {
851     return m_private->movieLoadType();
852 }
853
854 float MediaPlayer::mediaTimeForTimeValue(float timeValue) const
855 {
856     return m_private->mediaTimeForTimeValue(timeValue);
857 }
858
859 double MediaPlayer::maximumDurationToCacheMediaTime() const
860 {
861     return m_private->maximumDurationToCacheMediaTime();
862 }
863
864 unsigned MediaPlayer::decodedFrameCount() const
865 {
866     return m_private->decodedFrameCount();
867 }
868
869 unsigned MediaPlayer::droppedFrameCount() const
870 {
871     return m_private->droppedFrameCount();
872 }
873
874 unsigned MediaPlayer::audioDecodedByteCount() const
875 {
876     return m_private->audioDecodedByteCount();
877 }
878
879 unsigned MediaPlayer::videoDecodedByteCount() const
880 {
881     return m_private->videoDecodedByteCount();
882 }
883
884 void MediaPlayer::reloadTimerFired(Timer<MediaPlayer>*)
885 {
886     m_private->cancelLoad();
887     loadWithNextMediaEngine(m_currentMediaEngine);
888 }
889
890 void MediaPlayer::getSitesInMediaCache(Vector<String>& sites)
891 {
892     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
893     unsigned size = engines.size();
894     for (unsigned i = 0; i < size; i++) {
895         if (!engines[i]->getSitesInMediaCache)
896             continue;
897         Vector<String> engineSites;
898         engines[i]->getSitesInMediaCache(engineSites);
899         sites.append(engineSites);
900     }
901 }
902
903 void MediaPlayer::clearMediaCache()
904 {
905     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
906     unsigned size = engines.size();
907     for (unsigned i = 0; i < size; i++) {
908         if (engines[i]->clearMediaCache)
909             engines[i]->clearMediaCache();
910     }
911 }
912
913 void MediaPlayer::clearMediaCacheForSite(const String& site)
914 {
915     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
916     unsigned size = engines.size();
917     for (unsigned i = 0; i < size; i++) {
918         if (engines[i]->clearMediaCacheForSite)
919             engines[i]->clearMediaCacheForSite(site);
920     }
921 }
922
923 void MediaPlayer::setPrivateBrowsingMode(bool privateBrowsingMode)
924 {
925     m_privateBrowsing = privateBrowsingMode;
926     m_private->setPrivateBrowsingMode(m_privateBrowsing);
927 }
928
929 // Client callbacks.
930 void MediaPlayer::networkStateChanged()
931 {
932     // If more than one media engine is installed and this one failed before finding metadata,
933     // let the next engine try.
934     if (m_private->networkState() >= FormatError
935         && m_private->readyState() < HaveMetadata
936         && installedMediaEngines().size() > 1) {
937         if (m_contentMIMEType.isEmpty() || bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, m_keySystem, m_url, m_currentMediaEngine)) {
938             m_reloadTimer.startOneShot(0);
939             return;
940         }
941     }
942     if (m_mediaPlayerClient)
943         m_mediaPlayerClient->mediaPlayerNetworkStateChanged(this);
944 }
945
946 void MediaPlayer::readyStateChanged()
947 {
948     if (m_mediaPlayerClient)
949         m_mediaPlayerClient->mediaPlayerReadyStateChanged(this);
950 }
951
952 void MediaPlayer::volumeChanged(float newVolume)
953 {
954     m_volume = newVolume;
955     if (m_mediaPlayerClient)
956         m_mediaPlayerClient->mediaPlayerVolumeChanged(this);
957 }
958
959 void MediaPlayer::muteChanged(bool newMuted)
960 {
961     m_muted = newMuted;
962     if (m_mediaPlayerClient)
963         m_mediaPlayerClient->mediaPlayerMuteChanged(this);
964 }
965
966 void MediaPlayer::timeChanged()
967 {
968     if (m_mediaPlayerClient)
969         m_mediaPlayerClient->mediaPlayerTimeChanged(this);
970 }
971
972 void MediaPlayer::sizeChanged()
973 {
974     if (m_mediaPlayerClient)
975         m_mediaPlayerClient->mediaPlayerSizeChanged(this);
976 }
977
978 void MediaPlayer::repaint()
979 {
980     if (m_mediaPlayerClient)
981         m_mediaPlayerClient->mediaPlayerRepaint(this);
982 }
983
984 void MediaPlayer::durationChanged()
985 {
986     if (m_mediaPlayerClient)
987         m_mediaPlayerClient->mediaPlayerDurationChanged(this);
988 }
989
990 void MediaPlayer::rateChanged()
991 {
992     if (m_mediaPlayerClient)
993         m_mediaPlayerClient->mediaPlayerRateChanged(this);
994 }
995
996 void MediaPlayer::playbackStateChanged()
997 {
998     if (m_mediaPlayerClient)
999         m_mediaPlayerClient->mediaPlayerPlaybackStateChanged(this);
1000 }
1001
1002 void MediaPlayer::firstVideoFrameAvailable()
1003 {
1004     if (m_mediaPlayerClient)
1005         m_mediaPlayerClient->mediaPlayerFirstVideoFrameAvailable(this);
1006 }
1007
1008 void MediaPlayer::characteristicChanged()
1009 {
1010     if (m_mediaPlayerClient)
1011         m_mediaPlayerClient->mediaPlayerCharacteristicChanged(this);
1012 }
1013
1014 #if ENABLE(WEB_AUDIO)
1015 AudioSourceProvider* MediaPlayer::audioSourceProvider()
1016 {
1017     return m_private->audioSourceProvider();
1018 }
1019 #endif // WEB_AUDIO
1020
1021 #if ENABLE(ENCRYPTED_MEDIA)
1022 void MediaPlayer::keyAdded(const String& keySystem, const String& sessionId)
1023 {
1024     if (m_mediaPlayerClient)
1025         m_mediaPlayerClient->mediaPlayerKeyAdded(this, keySystem, sessionId);
1026 }
1027
1028 void MediaPlayer::keyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode errorCode, unsigned short systemCode)
1029 {
1030     if (m_mediaPlayerClient)
1031         m_mediaPlayerClient->mediaPlayerKeyError(this, keySystem, sessionId, errorCode, systemCode);
1032 }
1033
1034 void MediaPlayer::keyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const KURL& defaultURL)
1035 {
1036     if (m_mediaPlayerClient)
1037         m_mediaPlayerClient->mediaPlayerKeyMessage(this, keySystem, sessionId, message, messageLength, defaultURL);
1038 }
1039
1040 bool MediaPlayer::keyNeeded(const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength)
1041 {
1042     if (m_mediaPlayerClient)
1043         return m_mediaPlayerClient->mediaPlayerKeyNeeded(this, keySystem, sessionId, initData, initDataLength);
1044     return false;
1045 }
1046 #endif
1047
1048 #if ENABLE(ENCRYPTED_MEDIA_V2)
1049 bool MediaPlayer::keyNeeded(Uint8Array* initData)
1050 {
1051     if (m_mediaPlayerClient)
1052         return m_mediaPlayerClient->mediaPlayerKeyNeeded(this, initData);
1053     return false;
1054 }
1055 #endif
1056
1057 String MediaPlayer::referrer() const
1058 {
1059     if (!m_mediaPlayerClient)
1060         return String();
1061
1062     return m_mediaPlayerClient->mediaPlayerReferrer();
1063 }
1064
1065 String MediaPlayer::userAgent() const
1066 {
1067     if (!m_mediaPlayerClient)
1068         return String();
1069     
1070     return m_mediaPlayerClient->mediaPlayerUserAgent();
1071 }
1072
1073 String MediaPlayer::engineDescription() const
1074 {
1075     if (!m_private)
1076         return String();
1077
1078     return m_private->engineDescription();
1079 }
1080
1081 #if PLATFORM(WIN) && USE(AVFOUNDATION)
1082 GraphicsDeviceAdapter* MediaPlayer::graphicsDeviceAdapter() const
1083 {
1084     if (!m_mediaPlayerClient)
1085         return 0;
1086     
1087     return m_mediaPlayerClient->mediaPlayerGraphicsDeviceAdapter(this);
1088 }
1089 #endif
1090
1091 CachedResourceLoader* MediaPlayer::cachedResourceLoader()
1092 {
1093     if (!m_mediaPlayerClient)
1094         return 0;
1095
1096     return m_mediaPlayerClient->mediaPlayerCachedResourceLoader();
1097 }
1098
1099 #if ENABLE(VIDEO_TRACK)
1100 void MediaPlayer::addTextTrack(PassRefPtr<InbandTextTrackPrivate> track)
1101 {
1102     if (!m_mediaPlayerClient)
1103         return;
1104
1105     m_mediaPlayerClient->mediaPlayerDidAddTrack(track);
1106 }
1107
1108 void MediaPlayer::removeTextTrack(PassRefPtr<InbandTextTrackPrivate> track)
1109 {
1110     if (!m_mediaPlayerClient)
1111         return;
1112
1113     m_mediaPlayerClient->mediaPlayerDidRemoveTrack(track);
1114 }
1115
1116 bool MediaPlayer::requiresTextTrackRepresentation() const
1117 {
1118     return m_private->requiresTextTrackRepresentation();
1119 }
1120
1121 void MediaPlayer::setTextTrackRepresentation(TextTrackRepresentation* representation)
1122 {
1123     m_private->setTextTrackRepresentation(representation);
1124 }
1125 #endif // ENABLE(VIDEO_TRACK)
1126
1127 #if USE(PLATFORM_TEXT_TRACK_MENU)
1128 bool MediaPlayer::implementsTextTrackControls() const
1129 {
1130     return m_private->implementsTextTrackControls();
1131 }
1132
1133 PassRefPtr<PlatformTextTrackMenuInterface> MediaPlayer::textTrackMenu()
1134 {
1135     return m_private->textTrackMenu();
1136 }
1137 #endif // USE(PLATFORM_TEXT_TRACK_MENU)
1138
1139 void MediaPlayer::resetMediaEngines()
1140 {
1141     installedMediaEngines(ResetEngines);
1142 }
1143
1144 #if USE(GSTREAMER)
1145 void MediaPlayer::simulateAudioInterruption()
1146 {
1147     if (!m_private)
1148         return;
1149
1150     m_private->simulateAudioInterruption();
1151 }
1152 #endif
1153
1154 String MediaPlayer::languageOfPrimaryAudioTrack() const
1155 {
1156     if (!m_private)
1157         return emptyString();
1158     
1159     return m_private->languageOfPrimaryAudioTrack();
1160 }
1161 }
1162
1163 #endif