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