fd31e7a28f4dcca7ecedae3f34ec8032019c85d3
[WebKit-https.git] / Source / WebCore / platform / graphics / MediaPlayer.cpp
1 /*
2  * Copyright (C) 2007-2014 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 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 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 "IntRect.h"
34 #include "Logging.h"
35 #include "MIMETypeRegistry.h"
36 #include "MediaPlayerPrivate.h"
37 #include "PlatformTimeRanges.h"
38 #include "Settings.h"
39 #include <wtf/text/CString.h>
40
41 #if ENABLE(VIDEO_TRACK)
42 #include "InbandTextTrackPrivate.h"
43 #endif
44
45 #if ENABLE(MEDIA_SOURCE)
46 #include "MediaSourcePrivateClient.h"
47 #endif
48
49 #if USE(GSTREAMER)
50 #include "MediaPlayerPrivateGStreamer.h"
51 #define PlatformMediaEngineClassName MediaPlayerPrivateGStreamer
52 #endif
53
54 #if USE(MEDIA_FOUNDATION)
55 #include "MediaPlayerPrivateMediaFoundation.h"
56 #define PlatformMediaEngineClassName MediaPlayerPrivateMediaFoundation
57 #endif
58
59 #if PLATFORM(COCOA)
60 #include "MediaPlayerPrivateQTKit.h"
61 #if USE(AVFOUNDATION)
62 #include "MediaPlayerPrivateAVFoundationObjC.h"
63 #if ENABLE(MEDIA_SOURCE)
64 #include "MediaPlayerPrivateMediaSourceAVFObjC.h"
65 #endif
66 #endif
67 #elif PLATFORM(WIN) && !USE(GSTREAMER)
68 #if USE(AVFOUNDATION)
69 #include "MediaPlayerPrivateAVFoundationCF.h"
70 #endif // USE(AVFOUNDATION)
71 #endif
72
73 namespace WebCore {
74
75 const PlatformMedia NoPlatformMedia = { PlatformMedia::None, {0} };
76
77 // a null player to make MediaPlayer logic simpler
78
79 class NullMediaPlayerPrivate : public MediaPlayerPrivateInterface {
80 public:
81     NullMediaPlayerPrivate(MediaPlayer*) { }
82
83     virtual void load(const String&) { }
84 #if ENABLE(MEDIA_SOURCE)
85     virtual void load(const String&, MediaSourcePrivateClient*) { }
86 #endif
87     virtual void cancelLoad() { }
88
89     virtual void prepareToPlay() { }
90     virtual void play() { }
91     virtual void pause() { }    
92
93     virtual PlatformMedia platformMedia() const { return NoPlatformMedia; }
94     virtual PlatformLayer* platformLayer() const { return 0; }
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 double durationDouble() const { return 0; }
104
105     virtual double currentTimeDouble() const { return 0; }
106     virtual void seekDouble(double) { }
107     virtual bool seeking() const { return false; }
108
109     virtual void setRateDouble(double) { }
110     virtual void setPreservesPitch(bool) { }
111     virtual bool paused() const { return false; }
112
113     virtual void setVolumeDouble(double) { }
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 double maxTimeSeekableDouble() const { return 0; }
125     virtual double minTimeSeekable() const { return 0; }
126     virtual std::unique_ptr<PlatformTimeRanges> buffered() const { return PlatformTimeRanges::create(); }
127
128     virtual unsigned long long totalBytes() const { return 0; }
129     virtual bool didLoadingProgress() const { return false; }
130
131     virtual void setSize(const IntSize&) { }
132
133     virtual void paint(GraphicsContext*, const IntRect&) { }
134
135     virtual bool canLoadPoster() const { return false; }
136     virtual void setPoster(const String&) { }
137
138     virtual bool hasSingleSecurityOrigin() const { return true; }
139
140 #if ENABLE(ENCRYPTED_MEDIA)
141     virtual MediaPlayer::MediaKeyException generateKeyRequest(const String&, const unsigned char*, unsigned) override { return MediaPlayer::InvalidPlayerState; }
142     virtual MediaPlayer::MediaKeyException addKey(const String&, const unsigned char*, unsigned, const unsigned char*, unsigned, const String&) override { return MediaPlayer::InvalidPlayerState; }
143     virtual MediaPlayer::MediaKeyException cancelKeyRequest(const String&, const String&) override { return MediaPlayer::InvalidPlayerState; }
144 #endif
145 };
146
147 static PassOwnPtr<MediaPlayerPrivateInterface> createNullMediaPlayer(MediaPlayer* player) 
148
149     return adoptPtr(new NullMediaPlayerPrivate(player)); 
150 }
151
152
153 // engine support
154
155 struct MediaPlayerFactory {
156     WTF_MAKE_NONCOPYABLE(MediaPlayerFactory); WTF_MAKE_FAST_ALLOCATED;
157 public:
158     MediaPlayerFactory(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsTypeAndCodecs,
159         MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite, MediaEngineSupportsKeySystem supportsKeySystem)
160         : constructor(constructor)
161         , getSupportedTypes(getSupportedTypes)
162         , supportsTypeAndCodecs(supportsTypeAndCodecs)
163         , getSitesInMediaCache(getSitesInMediaCache)
164         , clearMediaCache(clearMediaCache)
165         , clearMediaCacheForSite(clearMediaCacheForSite)
166         , supportsKeySystem(supportsKeySystem)
167     {
168     }
169
170     CreateMediaEnginePlayer constructor;
171     MediaEngineSupportedTypes getSupportedTypes;
172     MediaEngineSupportsType supportsTypeAndCodecs;
173     MediaEngineGetSitesInMediaCache getSitesInMediaCache;
174     MediaEngineClearMediaCache clearMediaCache;
175     MediaEngineClearMediaCacheForSite clearMediaCacheForSite;
176     MediaEngineSupportsKeySystem supportsKeySystem;
177 };
178
179 static void addMediaEngine(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite, MediaEngineSupportsKeySystem);
180
181 static MediaPlayerFactory* bestMediaEngineForSupportParameters(const MediaEngineSupportParameters&, MediaPlayerFactory* current = 0);
182 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current);
183
184 enum RequeryEngineOptions { DoNotResetEngines, ResetEngines };
185 static Vector<MediaPlayerFactory*>& installedMediaEngines(RequeryEngineOptions requeryFlags = DoNotResetEngines )
186 {
187     DEPRECATED_DEFINE_STATIC_LOCAL(Vector<MediaPlayerFactory*>, installedEngines, ());
188     static bool enginesQueried = false;
189
190     if (requeryFlags == ResetEngines) {
191         installedEngines.clear();
192         enginesQueried = false;
193         return installedEngines;
194     }
195
196     if (enginesQueried)
197         return installedEngines;
198
199     enginesQueried = true;
200
201 #if USE(AVFOUNDATION)
202     if (Settings::isAVFoundationEnabled()) {
203 #if PLATFORM(COCOA)
204         MediaPlayerPrivateAVFoundationObjC::registerMediaEngine(addMediaEngine);
205 #if ENABLE(MEDIA_SOURCE)
206         MediaPlayerPrivateMediaSourceAVFObjC::registerMediaEngine(addMediaEngine);
207 #endif
208 #elif PLATFORM(WIN)
209         MediaPlayerPrivateAVFoundationCF::registerMediaEngine(addMediaEngine);
210 #endif
211     }
212 #endif
213
214 #if PLATFORM(MAC)
215     if (Settings::isQTKitEnabled())
216         MediaPlayerPrivateQTKit::registerMediaEngine(addMediaEngine);
217 #endif
218
219 #if defined(PlatformMediaEngineClassName)
220     PlatformMediaEngineClassName::registerMediaEngine(addMediaEngine);
221 #endif
222
223     return installedEngines;
224 }
225
226 static void addMediaEngine(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,
227     MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite, MediaEngineSupportsKeySystem supportsKeySystem)
228 {
229     ASSERT(constructor);
230     ASSERT(getSupportedTypes);
231     ASSERT(supportsType);
232
233     installedMediaEngines().append(new MediaPlayerFactory(constructor, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite, supportsKeySystem));
234 }
235
236 static const AtomicString& applicationOctetStream()
237 {
238     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, applicationOctetStream, ("application/octet-stream", AtomicString::ConstructFromLiteral));
239     return applicationOctetStream;
240 }
241
242 static const AtomicString& textPlain()
243 {
244     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, textPlain, ("text/plain", AtomicString::ConstructFromLiteral));
245     return textPlain;
246 }
247
248 static const AtomicString& codecs()
249 {
250     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, codecs, ("codecs", AtomicString::ConstructFromLiteral));
251     return codecs;
252 }
253
254 static MediaPlayerFactory* bestMediaEngineForSupportParameters(const MediaEngineSupportParameters& parameters, MediaPlayerFactory* current)
255 {
256     if (parameters.type.isEmpty())
257         return 0;
258
259     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
260     if (engines.isEmpty())
261         return 0;
262
263     // 4.8.10.3 MIME types - In the absence of a specification to the contrary, the MIME type "application/octet-stream" 
264     // when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows 
265     // it cannot render.
266     if (parameters.type == applicationOctetStream()) {
267         if (!parameters.codecs.isEmpty())
268             return 0;
269     }
270
271     MediaPlayerFactory* engine = 0;
272     MediaPlayer::SupportsType supported = MediaPlayer::IsNotSupported;
273     unsigned count = engines.size();
274     for (unsigned ndx = 0; ndx < count; ndx++) {
275         if (current) {
276             if (current == engines[ndx])
277                 current = 0;
278             continue;
279         }
280         MediaPlayer::SupportsType engineSupport = engines[ndx]->supportsTypeAndCodecs(parameters);
281         if (engineSupport > supported) {
282             supported = engineSupport;
283             engine = engines[ndx];
284         }
285     }
286
287     return engine;
288 }
289
290 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current)
291 {
292     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
293     if (engines.isEmpty())
294         return 0;
295
296     if (!current) 
297         return engines.first();
298
299     size_t currentIndex = engines.find(current);
300     if (currentIndex == WTF::notFound || currentIndex + 1 >= engines.size()) 
301         return 0;
302
303     return engines[currentIndex + 1];
304 }
305
306 // media player
307
308 MediaPlayer::MediaPlayer(MediaPlayerClient& client)
309     : m_client(client)
310     , m_reloadTimer(this, &MediaPlayer::reloadTimerFired)
311     , m_private(createNullMediaPlayer(this))
312     , m_currentMediaEngine(0)
313     , m_preload(Auto)
314     , m_visible(false)
315     , m_rate(1.0f)
316     , m_volume(1.0f)
317     , m_muted(false)
318     , m_preservesPitch(true)
319     , m_privateBrowsing(false)
320     , m_shouldPrepareToRender(false)
321     , m_contentMIMETypeWasInferredFromExtension(false)
322 {
323 }
324
325 MediaPlayer::~MediaPlayer()
326 {
327 }
328
329 bool MediaPlayer::load(const URL& url, const ContentType& contentType, const String& keySystem)
330 {
331     m_contentMIMEType = contentType.type().lower();
332     m_contentTypeCodecs = contentType.parameter(codecs());
333     m_url = url;
334     m_keySystem = keySystem.lower();
335     m_contentMIMETypeWasInferredFromExtension = false;
336
337 #if ENABLE(MEDIA_SOURCE)
338     m_mediaSource = 0;
339 #endif
340
341     // If the MIME type is missing or is not meaningful, try to figure it out from the URL.
342     if (m_contentMIMEType.isEmpty() || m_contentMIMEType == applicationOctetStream() || m_contentMIMEType == textPlain()) {
343         if (m_url.protocolIsData())
344             m_contentMIMEType = mimeTypeFromDataURL(m_url.string());
345         else {
346             String lastPathComponent = url.lastPathComponent();
347             size_t pos = lastPathComponent.reverseFind('.');
348             if (pos != notFound) {
349                 String extension = lastPathComponent.substring(pos + 1);
350                 String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
351                 if (!mediaType.isEmpty()) {
352                     m_contentMIMEType = mediaType;
353                     m_contentMIMETypeWasInferredFromExtension = true;
354                 }
355             }
356         }
357     }
358
359     loadWithNextMediaEngine(0);
360     return m_currentMediaEngine;
361 }
362
363 #if ENABLE(MEDIA_SOURCE)
364 bool MediaPlayer::load(const URL& url, const ContentType& contentType, MediaSourcePrivateClient* mediaSource)
365 {
366     ASSERT(mediaSource);
367     m_mediaSource = mediaSource;
368     m_contentMIMEType = contentType.type().lower();
369     m_contentTypeCodecs = contentType.parameter(codecs());
370     m_url = url;
371     m_keySystem = "";
372     m_contentMIMETypeWasInferredFromExtension = false;
373     loadWithNextMediaEngine(0);
374     return m_currentMediaEngine;
375 }
376 #endif
377
378 MediaPlayerFactory* MediaPlayer::nextBestMediaEngine(MediaPlayerFactory* current) const
379 {
380     MediaEngineSupportParameters parameters;
381     parameters.type = m_contentMIMEType;
382     parameters.codecs = m_contentTypeCodecs;
383     parameters.url = m_url;
384 #if ENABLE(ENCRYPTED_MEDIA)
385     parameters.keySystem = m_keySystem;
386 #endif
387 #if ENABLE(MEDIA_SOURCE)
388     parameters.isMediaSource = !!m_mediaSource;
389 #endif
390
391     return bestMediaEngineForSupportParameters(parameters, current);
392 }
393
394 void MediaPlayer::loadWithNextMediaEngine(MediaPlayerFactory* current)
395 {
396     MediaPlayerFactory* engine = 0;
397
398     if (!m_contentMIMEType.isEmpty())
399         engine = nextBestMediaEngine(current);
400
401     // If no MIME type is specified or the type was inferred from the file extension, just use the next engine.
402     if (!engine && (m_contentMIMEType.isEmpty() || m_contentMIMETypeWasInferredFromExtension))
403         engine = nextMediaEngine(current);
404
405     // Don't delete and recreate the player unless it comes from a different engine.
406     if (!engine) {
407         LOG(Media, "MediaPlayer::loadWithNextMediaEngine - no media engine found for type \"%s\"", m_contentMIMEType.utf8().data());
408         m_currentMediaEngine = engine;
409         m_private = nullptr;
410     } else if (m_currentMediaEngine != engine) {
411         m_currentMediaEngine = engine;
412         m_private = engine->constructor(this);
413         m_client.mediaPlayerEngineUpdated(this);
414         m_private->setPrivateBrowsingMode(m_privateBrowsing);
415         m_private->setPreload(m_preload);
416         m_private->setPreservesPitch(preservesPitch());
417         if (m_shouldPrepareToRender)
418             m_private->prepareForRendering();
419     }
420
421     if (m_private) {
422 #if ENABLE(MEDIA_SOURCE)
423         if (m_mediaSource)
424             m_private->load(m_url.string(), m_mediaSource.get());
425         else
426 #endif
427         m_private->load(m_url.string());
428     } else {
429         m_private = createNullMediaPlayer(this);
430         m_client.mediaPlayerEngineUpdated(this);
431         m_client.mediaPlayerResourceNotSupported(this);
432     }
433 }
434
435 bool MediaPlayer::hasAvailableVideoFrame() const
436 {
437     return m_private->hasAvailableVideoFrame();
438 }
439
440 void MediaPlayer::prepareForRendering()
441 {
442     m_shouldPrepareToRender = true;
443     m_private->prepareForRendering();
444 }
445
446 bool MediaPlayer::canLoadPoster() const
447 {
448     return m_private->canLoadPoster();
449 }
450
451 void MediaPlayer::setPoster(const String& url)
452 {
453     m_private->setPoster(url);
454 }    
455
456 void MediaPlayer::cancelLoad()
457 {
458     m_private->cancelLoad();
459 }    
460
461 void MediaPlayer::prepareToPlay()
462 {
463     m_private->prepareToPlay();
464 }
465
466 void MediaPlayer::play()
467 {
468     m_private->play();
469 }
470
471 void MediaPlayer::pause()
472 {
473     m_private->pause();
474 }
475
476 void MediaPlayer::setShouldBufferData(bool shouldBuffer)
477 {
478     m_private->setShouldBufferData(shouldBuffer);
479 }
480
481 #if ENABLE(ENCRYPTED_MEDIA)
482 MediaPlayer::MediaKeyException MediaPlayer::generateKeyRequest(const String& keySystem, const unsigned char* initData, unsigned initDataLength)
483 {
484     return m_private->generateKeyRequest(keySystem.lower(), initData, initDataLength);
485 }
486
487 MediaPlayer::MediaKeyException MediaPlayer::addKey(const String& keySystem, const unsigned char* key, unsigned keyLength, const unsigned char* initData, unsigned initDataLength, const String& sessionId)
488 {
489     return m_private->addKey(keySystem.lower(), key, keyLength, initData, initDataLength, sessionId);
490 }
491
492 MediaPlayer::MediaKeyException MediaPlayer::cancelKeyRequest(const String& keySystem, const String& sessionId)
493 {
494     return m_private->cancelKeyRequest(keySystem.lower(), sessionId);
495 }
496 #endif
497
498 #if ENABLE(ENCRYPTED_MEDIA_V2)
499 std::unique_ptr<CDMSession> MediaPlayer::createSession(const String& keySystem)
500 {
501     return m_private->createSession(keySystem);
502 }
503
504 void MediaPlayer::setCDMSession(CDMSession* session)
505 {
506     m_private->setCDMSession(session);
507 }
508 #endif
509     
510 MediaTime MediaPlayer::duration() const
511 {
512     return m_private->durationMediaTime();
513 }
514
515 MediaTime MediaPlayer::startTime() const
516 {
517     return m_private->startTime();
518 }
519
520 MediaTime MediaPlayer::initialTime() const
521 {
522     return m_private->initialTime();
523 }
524
525 MediaTime MediaPlayer::currentTime() const
526 {
527     return m_private->currentMediaTime();
528 }
529
530 void MediaPlayer::seekWithTolerance(const MediaTime& time, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance)
531 {
532     m_private->seekWithTolerance(time, negativeTolerance, positiveTolerance);
533 }
534
535 void MediaPlayer::seek(const MediaTime& time)
536 {
537     m_private->seek(time);
538 }
539
540 bool MediaPlayer::paused() const
541 {
542     return m_private->paused();
543 }
544
545 bool MediaPlayer::seeking() const
546 {
547     return m_private->seeking();
548 }
549
550 bool MediaPlayer::supportsFullscreen() const
551 {
552     return m_private->supportsFullscreen();
553 }
554
555 bool MediaPlayer::canSaveMediaData() const
556 {
557     return m_private->canSaveMediaData();
558 }
559
560 bool MediaPlayer::supportsScanning() const
561 {
562     return m_private->supportsScanning();
563 }
564
565 bool MediaPlayer::requiresImmediateCompositing() const
566 {
567     return m_private->requiresImmediateCompositing();
568 }
569
570 IntSize MediaPlayer::naturalSize()
571 {
572     return m_private->naturalSize();
573 }
574
575 bool MediaPlayer::hasVideo() const
576 {
577     return m_private->hasVideo();
578 }
579
580 bool MediaPlayer::hasAudio() const
581 {
582     return m_private->hasAudio();
583 }
584
585 bool MediaPlayer::inMediaDocument() const
586 {
587     return m_visible && m_client.mediaPlayerIsInMediaDocument();
588 }
589
590 PlatformMedia MediaPlayer::platformMedia() const
591 {
592     return m_private->platformMedia();
593 }
594
595 PlatformLayer* MediaPlayer::platformLayer() const
596 {
597     return m_private->platformLayer();
598 }
599     
600 #if PLATFORM(IOS)
601 void MediaPlayer::setVideoFullscreenLayer(PlatformLayer* layer)
602 {
603     m_private->setVideoFullscreenLayer(layer);
604 }
605
606 void MediaPlayer::setVideoFullscreenFrame(FloatRect frame)
607 {
608     m_private->setVideoFullscreenFrame(frame);
609 }
610
611 void MediaPlayer::setVideoFullscreenGravity(MediaPlayer::VideoGravity gravity)
612 {
613     m_private->setVideoFullscreenGravity(gravity);
614 }
615
616 NSArray* MediaPlayer::timedMetadata() const
617 {
618     return m_private->timedMetadata();
619 }
620
621 String MediaPlayer::accessLog() const
622 {
623     return m_private->accessLog();
624 }
625
626 String MediaPlayer::errorLog() const
627 {
628     return m_private->errorLog();
629 }
630 #endif
631
632 MediaPlayer::NetworkState MediaPlayer::networkState()
633 {
634     return m_private->networkState();
635 }
636
637 MediaPlayer::ReadyState MediaPlayer::readyState()
638 {
639     return m_private->readyState();
640 }
641
642 double MediaPlayer::volume() const
643 {
644     return m_volume;
645 }
646
647 void MediaPlayer::setVolume(double volume)
648 {
649     m_volume = volume;
650
651     if (m_private->supportsMuting() || !m_muted)
652         m_private->setVolumeDouble(volume);
653 }
654
655 bool MediaPlayer::muted() const
656 {
657     return m_muted;
658 }
659
660 void MediaPlayer::setMuted(bool muted)
661 {
662     m_muted = muted;
663
664     if (m_private->supportsMuting())
665         m_private->setMuted(muted);
666     else
667         m_private->setVolume(muted ? 0 : m_volume);
668 }
669
670 bool MediaPlayer::hasClosedCaptions() const
671 {
672     return m_private->hasClosedCaptions();
673 }
674
675 void MediaPlayer::setClosedCaptionsVisible(bool closedCaptionsVisible)
676 {
677     m_private->setClosedCaptionsVisible(closedCaptionsVisible);
678 }
679
680 double MediaPlayer::rate() const
681 {
682     return m_rate;
683 }
684
685 void MediaPlayer::setRate(double rate)
686 {
687     m_rate = rate;
688     m_private->setRateDouble(rate);
689 }
690
691 bool MediaPlayer::preservesPitch() const
692 {
693     return m_preservesPitch;
694 }
695
696 void MediaPlayer::setPreservesPitch(bool preservesPitch)
697 {
698     m_preservesPitch = preservesPitch;
699     m_private->setPreservesPitch(preservesPitch);
700 }
701
702 std::unique_ptr<PlatformTimeRanges> MediaPlayer::buffered()
703 {
704     return m_private->buffered();
705 }
706
707 std::unique_ptr<PlatformTimeRanges> MediaPlayer::seekable()
708 {
709     return m_private->seekable();
710 }
711
712 MediaTime MediaPlayer::maxTimeSeekable()
713 {
714     return m_private->maxMediaTimeSeekable();
715 }
716
717 MediaTime MediaPlayer::minTimeSeekable()
718 {
719     return m_private->minMediaTimeSeekable();
720 }
721
722 bool MediaPlayer::didLoadingProgress()
723 {
724     return m_private->didLoadingProgress();
725 }
726
727 void MediaPlayer::setSize(const IntSize& size)
728
729     m_size = size;
730     m_private->setSize(size);
731 }
732
733 bool MediaPlayer::visible() const
734 {
735     return m_visible;
736 }
737
738 void MediaPlayer::setVisible(bool b)
739 {
740     m_visible = b;
741     m_private->setVisible(b);
742 }
743
744 MediaPlayer::Preload MediaPlayer::preload() const
745 {
746     return m_preload;
747 }
748
749 void MediaPlayer::setPreload(MediaPlayer::Preload preload)
750 {
751     m_preload = preload;
752     m_private->setPreload(preload);
753 }
754
755 void MediaPlayer::paint(GraphicsContext* p, const IntRect& r)
756 {
757     m_private->paint(p, r);
758 }
759
760 void MediaPlayer::paintCurrentFrameInContext(GraphicsContext* p, const IntRect& r)
761 {
762     m_private->paintCurrentFrameInContext(p, r);
763 }
764
765 bool MediaPlayer::copyVideoTextureToPlatformTexture(GraphicsContext3D* context, Platform3DObject texture, GC3Dint level, GC3Denum type, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY)
766 {
767     return m_private->copyVideoTextureToPlatformTexture(context, texture, level, type, internalFormat, premultiplyAlpha, flipY);
768 }
769
770 PassNativeImagePtr MediaPlayer::nativeImageForCurrentTime()
771 {
772     return m_private->nativeImageForCurrentTime();
773 }
774
775 MediaPlayer::SupportsType MediaPlayer::supportsType(const MediaEngineSupportParameters& parameters, const MediaPlayerSupportsTypeClient* client)
776 {
777     // 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the 
778     // user agent knows it cannot render or is the type "application/octet-stream"
779     if (parameters.type == applicationOctetStream())
780         return IsNotSupported;
781
782     MediaPlayerFactory* engine = bestMediaEngineForSupportParameters(parameters);
783     if (!engine)
784         return IsNotSupported;
785
786 #if PLATFORM(COCOA)
787     // YouTube will ask if the HTMLMediaElement canPlayType video/webm, then
788     // video/x-flv, then finally video/mp4, and will then load a URL of the first type
789     // in that list which returns "probably". When Perian is installed,
790     // MediaPlayerPrivateQTKit claims to support both video/webm and video/x-flv, but
791     // due to a bug in Perian, loading media in these formats will sometimes fail on
792     // slow connections. <https://bugs.webkit.org/show_bug.cgi?id=86409>
793     if (client && client->mediaPlayerNeedsSiteSpecificHacks()) {
794         String host = client->mediaPlayerDocumentHost();
795         if ((host.endsWith(".youtube.com", false) || equalIgnoringCase("youtube.com", host))
796             && (parameters.type.startsWith("video/webm", false) || parameters.type.startsWith("video/x-flv", false)))
797             return IsNotSupported;
798     }
799 #else
800     UNUSED_PARAM(client);
801 #endif
802
803     return engine->supportsTypeAndCodecs(parameters);
804 }
805
806 void MediaPlayer::getSupportedTypes(HashSet<String>& types)
807 {
808     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
809     if (engines.isEmpty())
810         return;
811
812     unsigned count = engines.size();
813     for (unsigned ndx = 0; ndx < count; ndx++)
814         engines[ndx]->getSupportedTypes(types);
815
816
817 bool MediaPlayer::isAvailable()
818 {
819     return !installedMediaEngines().isEmpty();
820
821
822 #if USE(NATIVE_FULLSCREEN_VIDEO)
823 void MediaPlayer::enterFullscreen()
824 {
825     m_private->enterFullscreen();
826 }
827
828 void MediaPlayer::exitFullscreen()
829 {
830     m_private->exitFullscreen();
831 }
832 #endif
833
834 #if ENABLE(IOS_AIRPLAY)
835 bool MediaPlayer::isCurrentPlaybackTargetWireless() const
836 {
837     return m_private->isCurrentPlaybackTargetWireless();
838 }
839
840 String MediaPlayer::wirelessPlaybackTargetName() const
841 {
842     return m_private->wirelessPlaybackTargetName();
843 }
844
845 MediaPlayer::WirelessPlaybackTargetType MediaPlayer::wirelessPlaybackTargetType() const
846 {
847     return m_private->wirelessPlaybackTargetType();
848 }
849
850 void MediaPlayer::showPlaybackTargetPicker()
851 {
852     m_private->showPlaybackTargetPicker();
853 }
854
855 bool MediaPlayer::hasWirelessPlaybackTargets() const
856 {
857     return m_private->hasWirelessPlaybackTargets();
858 }
859
860 bool MediaPlayer::wirelessVideoPlaybackDisabled() const
861 {
862     return m_private->wirelessVideoPlaybackDisabled();
863 }
864
865 void MediaPlayer::setWirelessVideoPlaybackDisabled(bool disabled)
866 {
867     m_private->setWirelessVideoPlaybackDisabled(disabled);
868 }
869
870 void MediaPlayer::currentPlaybackTargetIsWirelessChanged()
871 {
872     m_client.mediaPlayerCurrentPlaybackTargetIsWirelessChanged(this);
873 }
874 #endif
875
876 double MediaPlayer::maxFastForwardRate() const
877 {
878     return m_private->maxFastForwardRate();
879 }
880
881 double MediaPlayer::minFastReverseRate() const
882 {
883     return m_private->minFastReverseRate();
884 }
885
886 #if USE(NATIVE_FULLSCREEN_VIDEO)
887 bool MediaPlayer::canEnterFullscreen() const
888 {
889     return m_private->canEnterFullscreen();
890 }
891 #endif
892
893 void MediaPlayer::acceleratedRenderingStateChanged()
894 {
895     m_private->acceleratedRenderingStateChanged();
896 }
897
898 bool MediaPlayer::supportsAcceleratedRendering() const
899 {
900     return m_private->supportsAcceleratedRendering();
901 }
902
903 bool MediaPlayer::shouldMaintainAspectRatio() const
904 {
905     return m_private->shouldMaintainAspectRatio();
906 }
907
908 void MediaPlayer::setShouldMaintainAspectRatio(bool maintainAspectRatio)
909 {
910     m_private->setShouldMaintainAspectRatio(maintainAspectRatio);
911 }
912
913 bool MediaPlayer::hasSingleSecurityOrigin() const
914 {
915     return m_private->hasSingleSecurityOrigin();
916 }
917
918 bool MediaPlayer::didPassCORSAccessCheck() const
919 {
920     return m_private->didPassCORSAccessCheck();
921 }
922
923 MediaPlayer::MovieLoadType MediaPlayer::movieLoadType() const
924 {
925     return m_private->movieLoadType();
926 }
927
928 MediaTime MediaPlayer::mediaTimeForTimeValue(const MediaTime& timeValue) const
929 {
930     return m_private->mediaTimeForTimeValue(timeValue);
931 }
932
933 double MediaPlayer::maximumDurationToCacheMediaTime() const
934 {
935     return m_private->maximumDurationToCacheMediaTime();
936 }
937
938 unsigned MediaPlayer::decodedFrameCount() const
939 {
940     return m_private->decodedFrameCount();
941 }
942
943 unsigned MediaPlayer::droppedFrameCount() const
944 {
945     return m_private->droppedFrameCount();
946 }
947
948 unsigned MediaPlayer::audioDecodedByteCount() const
949 {
950     return m_private->audioDecodedByteCount();
951 }
952
953 unsigned MediaPlayer::videoDecodedByteCount() const
954 {
955     return m_private->videoDecodedByteCount();
956 }
957
958 void MediaPlayer::reloadTimerFired(Timer&)
959 {
960     m_private->cancelLoad();
961     loadWithNextMediaEngine(m_currentMediaEngine);
962 }
963
964 void MediaPlayer::getSitesInMediaCache(Vector<String>& sites)
965 {
966     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
967     unsigned size = engines.size();
968     for (unsigned i = 0; i < size; i++) {
969         if (!engines[i]->getSitesInMediaCache)
970             continue;
971         Vector<String> engineSites;
972         engines[i]->getSitesInMediaCache(engineSites);
973         sites.appendVector(engineSites);
974     }
975 }
976
977 void MediaPlayer::clearMediaCache()
978 {
979     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
980     unsigned size = engines.size();
981     for (unsigned i = 0; i < size; i++) {
982         if (engines[i]->clearMediaCache)
983             engines[i]->clearMediaCache();
984     }
985 }
986
987 void MediaPlayer::clearMediaCacheForSite(const String& site)
988 {
989     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
990     unsigned size = engines.size();
991     for (unsigned i = 0; i < size; i++) {
992         if (engines[i]->clearMediaCacheForSite)
993             engines[i]->clearMediaCacheForSite(site);
994     }
995 }
996
997 bool MediaPlayer::supportsKeySystem(const String& keySystem, const String& mimeType)
998 {
999     for (auto& engine : installedMediaEngines()) {
1000         if (engine->supportsKeySystem && engine->supportsKeySystem(keySystem, mimeType))
1001             return true;
1002     }
1003     return false;
1004 }
1005
1006 void MediaPlayer::setPrivateBrowsingMode(bool privateBrowsingMode)
1007 {
1008     m_privateBrowsing = privateBrowsingMode;
1009     m_private->setPrivateBrowsingMode(m_privateBrowsing);
1010 }
1011
1012 // Client callbacks.
1013 void MediaPlayer::networkStateChanged()
1014 {
1015     // If more than one media engine is installed and this one failed before finding metadata,
1016     // let the next engine try.
1017     if (m_private->networkState() >= FormatError && m_private->readyState() < HaveMetadata) {
1018         m_client.mediaPlayerEngineFailedToLoad();
1019         if (installedMediaEngines().size() > 1 && (m_contentMIMEType.isEmpty() || nextBestMediaEngine(m_currentMediaEngine))) {
1020             m_reloadTimer.startOneShot(0);
1021             return;
1022         }
1023     }
1024     m_client.mediaPlayerNetworkStateChanged(this);
1025 }
1026
1027 void MediaPlayer::readyStateChanged()
1028 {
1029     m_client.mediaPlayerReadyStateChanged(this);
1030 }
1031
1032 void MediaPlayer::volumeChanged(double newVolume)
1033 {
1034 #if PLATFORM(IOS)
1035     UNUSED_PARAM(newVolume);
1036     m_volume = m_private->volume();
1037 #else
1038     m_volume = newVolume;
1039 #endif
1040     m_client.mediaPlayerVolumeChanged(this);
1041 }
1042
1043 void MediaPlayer::muteChanged(bool newMuted)
1044 {
1045     m_muted = newMuted;
1046     m_client.mediaPlayerMuteChanged(this);
1047 }
1048
1049 void MediaPlayer::timeChanged()
1050 {
1051     m_client.mediaPlayerTimeChanged(this);
1052 }
1053
1054 void MediaPlayer::sizeChanged()
1055 {
1056     m_client.mediaPlayerSizeChanged(this);
1057 }
1058
1059 void MediaPlayer::repaint()
1060 {
1061     m_client.mediaPlayerRepaint(this);
1062 }
1063
1064 void MediaPlayer::durationChanged()
1065 {
1066     m_client.mediaPlayerDurationChanged(this);
1067 }
1068
1069 void MediaPlayer::rateChanged()
1070 {
1071     m_client.mediaPlayerRateChanged(this);
1072 }
1073
1074 void MediaPlayer::playbackStateChanged()
1075 {
1076     m_client.mediaPlayerPlaybackStateChanged(this);
1077 }
1078
1079 void MediaPlayer::firstVideoFrameAvailable()
1080 {
1081     m_client.mediaPlayerFirstVideoFrameAvailable(this);
1082 }
1083
1084 void MediaPlayer::characteristicChanged()
1085 {
1086     m_client.mediaPlayerCharacteristicChanged(this);
1087 }
1088
1089 #if ENABLE(WEB_AUDIO)
1090 AudioSourceProvider* MediaPlayer::audioSourceProvider()
1091 {
1092     return m_private->audioSourceProvider();
1093 }
1094 #endif // WEB_AUDIO
1095
1096 #if ENABLE(ENCRYPTED_MEDIA)
1097 void MediaPlayer::keyAdded(const String& keySystem, const String& sessionId)
1098 {
1099     m_client.mediaPlayerKeyAdded(this, keySystem, sessionId);
1100 }
1101
1102 void MediaPlayer::keyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode errorCode, unsigned short systemCode)
1103 {
1104     m_client.mediaPlayerKeyError(this, keySystem, sessionId, errorCode, systemCode);
1105 }
1106
1107 void MediaPlayer::keyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL)
1108 {
1109     m_client.mediaPlayerKeyMessage(this, keySystem, sessionId, message, messageLength, defaultURL);
1110 }
1111
1112 bool MediaPlayer::keyNeeded(const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength)
1113 {
1114     return m_client.mediaPlayerKeyNeeded(this, keySystem, sessionId, initData, initDataLength);
1115 }
1116 #endif
1117
1118 #if ENABLE(ENCRYPTED_MEDIA_V2)
1119 bool MediaPlayer::keyNeeded(Uint8Array* initData)
1120 {
1121     return m_client.mediaPlayerKeyNeeded(this, initData);
1122 }
1123
1124 String MediaPlayer::mediaKeysStorageDirectory() const
1125 {
1126     return m_client.mediaPlayerMediaKeysStorageDirectory();
1127 }
1128 #endif
1129
1130 String MediaPlayer::referrer() const
1131 {
1132     return m_client.mediaPlayerReferrer();
1133 }
1134
1135 String MediaPlayer::userAgent() const
1136 {
1137     return m_client.mediaPlayerUserAgent();
1138 }
1139
1140 String MediaPlayer::engineDescription() const
1141 {
1142     if (!m_private)
1143         return String();
1144
1145     return m_private->engineDescription();
1146 }
1147
1148 long MediaPlayer::platformErrorCode() const
1149 {
1150     if (!m_private)
1151         return 0;
1152
1153     return m_private->platformErrorCode();
1154 }
1155
1156 #if PLATFORM(WIN) && USE(AVFOUNDATION)
1157 GraphicsDeviceAdapter* MediaPlayer::graphicsDeviceAdapter() const
1158 {
1159     return m_client.mediaPlayerGraphicsDeviceAdapter(this);
1160 }
1161 #endif
1162
1163 CachedResourceLoader* MediaPlayer::cachedResourceLoader()
1164 {
1165     return m_client.mediaPlayerCachedResourceLoader();
1166 }
1167
1168 PassRefPtr<PlatformMediaResourceLoader> MediaPlayer::createResourceLoader(std::unique_ptr<PlatformMediaResourceLoaderClient> client)
1169 {
1170     return m_client.mediaPlayerCreateResourceLoader(WTF::move(client));
1171 }
1172
1173 #if ENABLE(VIDEO_TRACK)
1174 void MediaPlayer::addAudioTrack(PassRefPtr<AudioTrackPrivate> track)
1175 {
1176     m_client.mediaPlayerDidAddAudioTrack(track);
1177 }
1178
1179 void MediaPlayer::removeAudioTrack(PassRefPtr<AudioTrackPrivate> track)
1180 {
1181     m_client.mediaPlayerDidRemoveAudioTrack(track);
1182 }
1183
1184 void MediaPlayer::addTextTrack(PassRefPtr<InbandTextTrackPrivate> track)
1185 {
1186     m_client.mediaPlayerDidAddTextTrack(track);
1187 }
1188
1189 void MediaPlayer::removeTextTrack(PassRefPtr<InbandTextTrackPrivate> track)
1190 {
1191     m_client.mediaPlayerDidRemoveTextTrack(track);
1192 }
1193
1194 void MediaPlayer::addVideoTrack(PassRefPtr<VideoTrackPrivate> track)
1195 {
1196     m_client.mediaPlayerDidAddVideoTrack(track);
1197 }
1198
1199 void MediaPlayer::removeVideoTrack(PassRefPtr<VideoTrackPrivate> track)
1200 {
1201     m_client.mediaPlayerDidRemoveVideoTrack(track);
1202 }
1203
1204 bool MediaPlayer::requiresTextTrackRepresentation() const
1205 {
1206     return m_private->requiresTextTrackRepresentation();
1207 }
1208
1209 void MediaPlayer::setTextTrackRepresentation(TextTrackRepresentation* representation)
1210 {
1211     m_private->setTextTrackRepresentation(representation);
1212 }
1213
1214 void MediaPlayer::syncTextTrackBounds()
1215 {
1216     m_private->syncTextTrackBounds();
1217 }
1218
1219 #if ENABLE(AVF_CAPTIONS)
1220 void MediaPlayer::notifyTrackModeChanged()
1221 {
1222     if (m_private)
1223         m_private->notifyTrackModeChanged();
1224 }
1225
1226 Vector<RefPtr<PlatformTextTrack>> MediaPlayer::outOfBandTrackSources()
1227 {
1228     return m_client.outOfBandTrackSources();
1229 }
1230 #endif
1231
1232 #endif // ENABLE(VIDEO_TRACK)
1233
1234 #if USE(PLATFORM_TEXT_TRACK_MENU)
1235 bool MediaPlayer::implementsTextTrackControls() const
1236 {
1237     return m_private->implementsTextTrackControls();
1238 }
1239
1240 PassRefPtr<PlatformTextTrackMenuInterface> MediaPlayer::textTrackMenu()
1241 {
1242     return m_private->textTrackMenu();
1243 }
1244 #endif // USE(PLATFORM_TEXT_TRACK_MENU)
1245
1246 void MediaPlayer::resetMediaEngines()
1247 {
1248     installedMediaEngines(ResetEngines);
1249 }
1250
1251 #if USE(GSTREAMER)
1252 void MediaPlayer::simulateAudioInterruption()
1253 {
1254     if (!m_private)
1255         return;
1256
1257     m_private->simulateAudioInterruption();
1258 }
1259 #endif
1260
1261 String MediaPlayer::languageOfPrimaryAudioTrack() const
1262 {
1263     if (!m_private)
1264         return emptyString();
1265     
1266     return m_private->languageOfPrimaryAudioTrack();
1267 }
1268
1269 size_t MediaPlayer::extraMemoryCost() const
1270 {
1271     if (!m_private)
1272         return 0;
1273
1274     return m_private->extraMemoryCost();
1275 }
1276
1277 unsigned long long MediaPlayer::fileSize() const
1278 {
1279     if (!m_private)
1280         return 0;
1281     
1282     return m_private->fileSize();
1283 }
1284
1285 #if ENABLE(MEDIA_SOURCE)
1286 unsigned long MediaPlayer::totalVideoFrames()
1287 {
1288     if (!m_private)
1289         return 0;
1290
1291     return m_private->totalVideoFrames();
1292 }
1293
1294 unsigned long MediaPlayer::droppedVideoFrames()
1295 {
1296     if (!m_private)
1297         return 0;
1298
1299     return m_private->droppedVideoFrames();
1300 }
1301
1302 unsigned long MediaPlayer::corruptedVideoFrames()
1303 {
1304     if (!m_private)
1305         return 0;
1306
1307     return m_private->corruptedVideoFrames();
1308 }
1309
1310 MediaTime MediaPlayer::totalFrameDelay()
1311 {
1312     if (!m_private)
1313         return MediaTime::zeroTime();
1314
1315     return m_private->totalFrameDelay();
1316 }
1317 #endif
1318
1319 bool MediaPlayer::shouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge& challenge)
1320 {
1321     return m_client.mediaPlayerShouldWaitForResponseToAuthenticationChallenge(challenge);
1322 }
1323
1324 void MediaPlayer::handlePlaybackCommand(MediaSession::RemoteControlCommandType command)
1325 {
1326     m_client.mediaPlayerHandlePlaybackCommand(command);
1327 }
1328
1329 String MediaPlayer::sourceApplicationIdentifier() const
1330 {
1331     return m_client.mediaPlayerSourceApplicationIdentifier();
1332 }
1333
1334 void MediaPlayerFactorySupport::callRegisterMediaEngine(MediaEngineRegister registerMediaEngine)
1335 {
1336     registerMediaEngine(addMediaEngine);
1337 }
1338
1339 bool MediaPlayer::doesHaveAttribute(const AtomicString& attribute, AtomicString* value) const
1340 {
1341     return m_client.doesHaveAttribute(attribute, value);
1342 }
1343
1344 #if PLATFORM(IOS)
1345 String MediaPlayer::mediaPlayerNetworkInterfaceName() const
1346 {
1347     return m_client.mediaPlayerNetworkInterfaceName();
1348 }
1349
1350 bool MediaPlayer::getRawCookies(const URL& url, Vector<Cookie>& cookies) const
1351 {
1352     return m_client.mediaPlayerGetRawCookies(url, cookies);
1353 }
1354 #endif
1355
1356 }
1357
1358 #endif