Remove std::chrono completely
[WebKit.git] / Source / WebCore / platform / graphics / MediaPlayer.cpp
1 /*
2  * Copyright (C) 2007-2015 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 "DeprecatedGlobalSettings.h"
33 #include "Document.h"
34 #include "IntRect.h"
35 #include "Logging.h"
36 #include "MIMETypeRegistry.h"
37 #include "MediaPlayerPrivate.h"
38 #include "PlatformTimeRanges.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 #if ENABLE(VIDEO) && ENABLE(MEDIA_SOURCE) && ENABLE(VIDEO_TRACK)
58 #include "MediaPlayerPrivateGStreamerMSE.h"
59 #endif
60 #endif // USE(GSTREAMER)
61
62 #if USE(MEDIA_FOUNDATION)
63 #include "MediaPlayerPrivateMediaFoundation.h"
64 #define PlatformMediaEngineClassName MediaPlayerPrivateMediaFoundation
65 #endif
66
67 #if PLATFORM(COCOA)
68 #if USE(QTKIT)
69 #include "MediaPlayerPrivateQTKit.h"
70 #endif
71
72 #if USE(AVFOUNDATION)
73 #include "MediaPlayerPrivateAVFoundationObjC.h"
74 #endif
75
76 #if ENABLE(MEDIA_SOURCE) && USE(AVFOUNDATION)
77 #include "MediaPlayerPrivateMediaSourceAVFObjC.h"
78 #endif
79
80 #if ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
81 #include "MediaPlayerPrivateMediaStreamAVFObjC.h"
82 #endif
83
84 #endif // PLATFORM(COCOA)
85
86 #if PLATFORM(WIN) && USE(AVFOUNDATION) && !USE(GSTREAMER)
87 #include "MediaPlayerPrivateAVFoundationCF.h"
88 #endif
89
90 namespace WebCore {
91
92 const PlatformMedia NoPlatformMedia = { PlatformMedia::None, {0} };
93
94 #if !RELEASE_LOG_DISABLED
95 static RefPtr<Logger>& nullLogger()
96 {
97     static NeverDestroyed<RefPtr<Logger>> logger;
98     return logger;
99 }
100 #endif
101
102 // a null player to make MediaPlayer logic simpler
103
104 class NullMediaPlayerPrivate : public MediaPlayerPrivateInterface {
105 public:
106     explicit NullMediaPlayerPrivate(MediaPlayer*) { }
107
108     void load(const String&) override { }
109 #if ENABLE(MEDIA_SOURCE)
110     void load(const String&, MediaSourcePrivateClient*) override { }
111 #endif
112 #if ENABLE(MEDIA_STREAM)
113     void load(MediaStreamPrivate&) override { }
114 #endif
115     void cancelLoad() override { }
116
117     void prepareToPlay() override { }
118     void play() override { }
119     void pause() override { }
120
121     PlatformMedia platformMedia() const override { return NoPlatformMedia; }
122     PlatformLayer* platformLayer() const override { return 0; }
123
124     FloatSize naturalSize() const override { return FloatSize(); }
125
126     bool hasVideo() const override { return false; }
127     bool hasAudio() const override { return false; }
128
129     void setVisible(bool) override { }
130
131     double durationDouble() const override { return 0; }
132
133     double currentTimeDouble() const override { return 0; }
134     void seekDouble(double) override { }
135     bool seeking() const override { return false; }
136
137     void setRateDouble(double) override { }
138     void setPreservesPitch(bool) override { }
139     bool paused() const override { return false; }
140
141     void setVolumeDouble(double) override { }
142
143     bool supportsMuting() const override { return false; }
144     void setMuted(bool) override { }
145
146     bool hasClosedCaptions() const override { return false; }
147     void setClosedCaptionsVisible(bool) override { };
148
149     MediaPlayer::NetworkState networkState() const override { return MediaPlayer::Empty; }
150     MediaPlayer::ReadyState readyState() const override { return MediaPlayer::HaveNothing; }
151
152     float maxTimeSeekable() const override { return 0; }
153     double minTimeSeekable() const override { return 0; }
154     std::unique_ptr<PlatformTimeRanges> buffered() const override { return std::make_unique<PlatformTimeRanges>(); }
155
156     double seekableTimeRangesLastModifiedTime() const override { return 0; }
157     double liveUpdateInterval() const override { return 0; }
158
159     unsigned long long totalBytes() const override { return 0; }
160     bool didLoadingProgress() const override { return false; }
161
162     void setSize(const IntSize&) override { }
163
164     void paint(GraphicsContext&, const FloatRect&) override { }
165
166     bool canLoadPoster() const override { return false; }
167     void setPoster(const String&) override { }
168
169     bool hasSingleSecurityOrigin() const override { return true; }
170 };
171
172 class NullMediaPlayerClient : public MediaPlayerClient {
173 public:
174 #if !RELEASE_LOG_DISABLED
175     const Logger& mediaPlayerLogger() final
176     {
177         if (!nullLogger().get()) {
178             nullLogger() = Logger::create(this);
179             nullLogger()->setEnabled(this, false);
180         }
181
182         return *nullLogger().get();
183     }
184 #endif
185 };
186
187 const Vector<ContentType>& MediaPlayerClient::mediaContentTypesRequiringHardwareSupport() const
188 {
189     static NeverDestroyed<Vector<ContentType>> contentTypes;
190     return contentTypes;
191 }
192
193 static MediaPlayerClient& nullMediaPlayerClient()
194 {
195     static NeverDestroyed<NullMediaPlayerClient> client;
196     return client.get();
197 }
198
199 // engine support
200
201 struct MediaPlayerFactory {
202     CreateMediaEnginePlayer constructor;
203     MediaEngineSupportedTypes getSupportedTypes;
204     MediaEngineSupportsType supportsTypeAndCodecs;
205     MediaEngineOriginsInMediaCache originsInMediaCache;
206     MediaEngineClearMediaCache clearMediaCache;
207     MediaEngineClearMediaCacheForOrigins clearMediaCacheForOrigins;
208     MediaEngineSupportsKeySystem supportsKeySystem;
209 };
210
211 static void addMediaEngine(CreateMediaEnginePlayer&&, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineOriginsInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForOrigins, MediaEngineSupportsKeySystem);
212
213 static StaticLock mediaEngineVectorLock;
214
215 static bool& haveMediaEnginesVector()
216 {
217     static bool haveVector;
218     return haveVector;
219 }
220
221 static Vector<MediaPlayerFactory>& mutableInstalledMediaEnginesVector()
222 {
223     static NeverDestroyed<Vector<MediaPlayerFactory>> installedEngines;
224     return installedEngines;
225 }
226
227 static void buildMediaEnginesVector()
228 {
229     ASSERT(mediaEngineVectorLock.isLocked());
230
231 #if USE(AVFOUNDATION)
232     if (DeprecatedGlobalSettings::isAVFoundationEnabled()) {
233
234 #if PLATFORM(COCOA)
235         MediaPlayerPrivateAVFoundationObjC::registerMediaEngine(addMediaEngine);
236 #endif
237
238 #if ENABLE(MEDIA_SOURCE)
239         MediaPlayerPrivateMediaSourceAVFObjC::registerMediaEngine(addMediaEngine);
240 #endif
241
242 #if ENABLE(MEDIA_STREAM)
243         MediaPlayerPrivateMediaStreamAVFObjC::registerMediaEngine(addMediaEngine);
244 #endif
245
246 #if PLATFORM(WIN)
247         MediaPlayerPrivateAVFoundationCF::registerMediaEngine(addMediaEngine);
248 #endif
249     }
250 #endif // USE(AVFOUNDATION)
251
252 #if PLATFORM(MAC) && USE(QTKIT)
253     if (DeprecatedGlobalSettings::isQTKitEnabled())
254         MediaPlayerPrivateQTKit::registerMediaEngine(addMediaEngine);
255 #endif
256
257 #if defined(PlatformMediaEngineClassName)
258 #if USE(GSTREAMER)
259     if (DeprecatedGlobalSettings::isGStreamerEnabled())
260 #endif
261         PlatformMediaEngineClassName::registerMediaEngine(addMediaEngine);
262 #endif
263
264 #if ENABLE(VIDEO) && USE(GSTREAMER) && ENABLE(MEDIA_SOURCE) && ENABLE(VIDEO_TRACK)
265     if (DeprecatedGlobalSettings::isGStreamerEnabled())
266         MediaPlayerPrivateGStreamerMSE::registerMediaEngine(addMediaEngine);
267 #endif
268
269     haveMediaEnginesVector() = true;
270 }
271
272 static const Vector<MediaPlayerFactory>& installedMediaEngines()
273 {
274     {
275         auto locker = holdLock(mediaEngineVectorLock);
276         if (!haveMediaEnginesVector())
277             buildMediaEnginesVector();
278     }
279
280     return mutableInstalledMediaEnginesVector();
281 }
282
283 static void addMediaEngine(CreateMediaEnginePlayer&& constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,
284     MediaEngineOriginsInMediaCache originsInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForOrigins clearMediaCacheForOrigins, MediaEngineSupportsKeySystem supportsKeySystem)
285 {
286     ASSERT(constructor);
287     ASSERT(getSupportedTypes);
288     ASSERT(supportsType);
289
290     mutableInstalledMediaEnginesVector().append(MediaPlayerFactory { WTFMove(constructor), getSupportedTypes, supportsType, originsInMediaCache, clearMediaCache, clearMediaCacheForOrigins, supportsKeySystem });
291 }
292
293 static const AtomicString& applicationOctetStream()
294 {
295     static NeverDestroyed<const AtomicString> applicationOctetStream("application/octet-stream", AtomicString::ConstructFromLiteral);
296     return applicationOctetStream;
297 }
298
299 static const AtomicString& textPlain()
300 {
301     static NeverDestroyed<const AtomicString> textPlain("text/plain", AtomicString::ConstructFromLiteral);
302     return textPlain;
303 }
304
305 static const MediaPlayerFactory* bestMediaEngineForSupportParameters(const MediaEngineSupportParameters& parameters, const MediaPlayerFactory* current = nullptr)
306 {
307     if (parameters.type.isEmpty() && !parameters.isMediaSource && !parameters.isMediaStream)
308         return nullptr;
309
310     // 4.8.10.3 MIME types - In the absence of a specification to the contrary, the MIME type "application/octet-stream"
311     // when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows 
312     // it cannot render.
313     if (parameters.type.containerType() == applicationOctetStream()) {
314         if (!parameters.type.codecs().isEmpty())
315             return nullptr;
316     }
317
318     const MediaPlayerFactory* foundEngine = nullptr;
319     MediaPlayer::SupportsType supported = MediaPlayer::IsNotSupported;
320     for (auto& engine : installedMediaEngines()) {
321         if (current) {
322             if (current == &engine)
323                 current = nullptr;
324             continue;
325         }
326         MediaPlayer::SupportsType engineSupport = engine.supportsTypeAndCodecs(parameters);
327         if (engineSupport > supported) {
328             supported = engineSupport;
329             foundEngine = &engine;
330         }
331     }
332
333     return foundEngine;
334 }
335
336 static const MediaPlayerFactory* nextMediaEngine(const MediaPlayerFactory* current)
337 {
338     auto& engines = installedMediaEngines();
339     if (engines.isEmpty())
340         return nullptr;
341
342     if (!current) 
343         return &engines.first();
344
345     size_t currentIndex = current - &engines.first();
346     if (currentIndex + 1 >= engines.size())
347         return nullptr;
348
349     return &engines[currentIndex + 1];
350 }
351
352 // media player
353
354 Ref<MediaPlayer> MediaPlayer::create(MediaPlayerClient& client)
355 {
356     return adoptRef(*new MediaPlayer(client));
357 }
358
359 MediaPlayer::MediaPlayer(MediaPlayerClient& client)
360     : m_client(&client)
361     , m_reloadTimer(*this, &MediaPlayer::reloadTimerFired)
362     , m_private(std::make_unique<NullMediaPlayerPrivate>(this))
363     , m_currentMediaEngine(0)
364     , m_preload(Auto)
365     , m_visible(false)
366     , m_volume(1.0f)
367     , m_muted(false)
368     , m_preservesPitch(true)
369     , m_privateBrowsing(false)
370     , m_shouldPrepareToRender(false)
371     , m_contentMIMETypeWasInferredFromExtension(false)
372 {
373 }
374
375 MediaPlayer::~MediaPlayer()
376 {
377     ASSERT(!m_initializingMediaEngine);
378 }
379
380 void MediaPlayer::invalidate()
381 {
382     m_client = &nullMediaPlayerClient();
383 }
384
385 bool MediaPlayer::load(const URL& url, const ContentType& contentType, const String& keySystem)
386 {
387     ASSERT(!m_reloadTimer.isActive());
388
389     // Protect against MediaPlayer being destroyed during a MediaPlayerClient callback.
390     Ref<MediaPlayer> protectedThis(*this);
391
392     m_contentType = contentType;
393     m_url = url;
394     m_keySystem = keySystem.convertToASCIILowercase();
395     m_contentMIMETypeWasInferredFromExtension = false;
396
397 #if ENABLE(MEDIA_SOURCE)
398     m_mediaSource = nullptr;
399 #endif
400 #if ENABLE(MEDIA_STREAM)
401     m_mediaStream = nullptr;
402 #endif
403
404     // If the MIME type is missing or is not meaningful, try to figure it out from the URL.
405     AtomicString containerType = m_contentType.containerType();
406     if (containerType.isEmpty() || containerType == applicationOctetStream() || containerType == textPlain()) {
407         if (m_url.protocolIsData())
408             m_contentType = ContentType(mimeTypeFromDataURL(m_url.string()));
409         else {
410             String lastPathComponent = url.lastPathComponent();
411             size_t pos = lastPathComponent.reverseFind('.');
412             if (pos != notFound) {
413                 String extension = lastPathComponent.substring(pos + 1);
414                 String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
415                 if (!mediaType.isEmpty()) {
416                     m_contentType = ContentType { WTFMove(mediaType) };
417                     m_contentMIMETypeWasInferredFromExtension = true;
418                 }
419             }
420         }
421     }
422
423     loadWithNextMediaEngine(0);
424     return m_currentMediaEngine;
425 }
426
427 #if ENABLE(MEDIA_SOURCE)
428 bool MediaPlayer::load(const URL& url, const ContentType& contentType, MediaSourcePrivateClient* mediaSource)
429 {
430     ASSERT(!m_reloadTimer.isActive());
431     ASSERT(mediaSource);
432
433     m_mediaSource = mediaSource;
434     m_contentType = contentType;
435     m_url = url;
436     m_keySystem = emptyString();
437     m_contentMIMETypeWasInferredFromExtension = false;
438     loadWithNextMediaEngine(0);
439     return m_currentMediaEngine;
440 }
441 #endif
442
443 #if ENABLE(MEDIA_STREAM)
444 bool MediaPlayer::load(MediaStreamPrivate& mediaStream)
445 {
446     ASSERT(!m_reloadTimer.isActive());
447
448     m_mediaStream = &mediaStream;
449     m_keySystem = emptyString();
450     m_contentType = { };
451     m_contentMIMETypeWasInferredFromExtension = false;
452     loadWithNextMediaEngine(0);
453     return m_currentMediaEngine;
454 }
455 #endif
456
457 const MediaPlayerFactory* MediaPlayer::nextBestMediaEngine(const MediaPlayerFactory* current) const
458 {
459     MediaEngineSupportParameters parameters;
460     parameters.type = m_contentType;
461     parameters.url = m_url;
462 #if ENABLE(MEDIA_SOURCE)
463     parameters.isMediaSource = !!m_mediaSource;
464 #endif
465 #if ENABLE(MEDIA_STREAM)
466     parameters.isMediaStream = !!m_mediaStream;
467 #endif
468
469     return bestMediaEngineForSupportParameters(parameters, current);
470 }
471
472 void MediaPlayer::loadWithNextMediaEngine(const MediaPlayerFactory* current)
473 {
474 #if ENABLE(MEDIA_SOURCE) 
475 #define MEDIASOURCE m_mediaSource
476 #else
477 #define MEDIASOURCE 0
478 #endif
479
480 #if ENABLE(MEDIA_STREAM)
481 #define MEDIASTREAM m_mediaStream
482 #else
483 #define MEDIASTREAM 0
484 #endif
485
486     ASSERT(!m_initializingMediaEngine);
487     m_initializingMediaEngine = true;
488
489     const MediaPlayerFactory* engine = nullptr;
490
491     if (!m_contentType.isEmpty() || MEDIASTREAM || MEDIASOURCE)
492         engine = nextBestMediaEngine(current);
493
494     // If no MIME type is specified or the type was inferred from the file extension, just use the next engine.
495     if (!engine && (m_contentType.isEmpty() || m_contentMIMETypeWasInferredFromExtension))
496         engine = nextMediaEngine(current);
497
498     // Don't delete and recreate the player unless it comes from a different engine.
499     if (!engine) {
500         LOG(Media, "MediaPlayer::loadWithNextMediaEngine - no media engine found for type \"%s\"", m_contentType.raw().utf8().data());
501         m_currentMediaEngine = engine;
502         m_private = nullptr;
503     } else if (m_currentMediaEngine != engine) {
504         m_currentMediaEngine = engine;
505         m_private = engine->constructor(this);
506         client().mediaPlayerEngineUpdated(this);
507         m_private->setPrivateBrowsingMode(m_privateBrowsing);
508         m_private->setPreload(m_preload);
509         m_private->setPreservesPitch(preservesPitch());
510         if (m_shouldPrepareToRender)
511             m_private->prepareForRendering();
512     }
513
514     if (m_private) {
515 #if ENABLE(MEDIA_SOURCE)
516         if (m_mediaSource)
517             m_private->load(m_url.string(), m_mediaSource.get());
518         else
519 #endif
520 #if ENABLE(MEDIA_STREAM)
521         if (m_mediaStream)
522             m_private->load(*m_mediaStream);
523         else
524 #endif
525         m_private->load(m_url.string());
526     } else {
527         m_private = std::make_unique<NullMediaPlayerPrivate>(this);
528         client().mediaPlayerEngineUpdated(this);
529         client().mediaPlayerResourceNotSupported(this);
530     }
531
532     m_initializingMediaEngine = false;
533 }
534
535 bool MediaPlayer::hasAvailableVideoFrame() const
536 {
537     return m_private->hasAvailableVideoFrame();
538 }
539
540 void MediaPlayer::prepareForRendering()
541 {
542     m_shouldPrepareToRender = true;
543     m_private->prepareForRendering();
544 }
545
546 bool MediaPlayer::canLoadPoster() const
547 {
548     return m_private->canLoadPoster();
549 }
550
551 void MediaPlayer::setPoster(const String& url)
552 {
553     m_private->setPoster(url);
554 }    
555
556 void MediaPlayer::cancelLoad()
557 {
558     m_private->cancelLoad();
559 }    
560
561 void MediaPlayer::prepareToPlay()
562 {
563     m_private->prepareToPlay();
564 }
565
566 void MediaPlayer::play()
567 {
568     m_private->play();
569 }
570
571 void MediaPlayer::pause()
572 {
573     m_private->pause();
574 }
575
576 void MediaPlayer::setShouldBufferData(bool shouldBuffer)
577 {
578     m_private->setShouldBufferData(shouldBuffer);
579 }
580
581 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
582 std::unique_ptr<LegacyCDMSession> MediaPlayer::createSession(const String& keySystem, LegacyCDMSessionClient* client)
583 {
584     return m_private->createSession(keySystem, client);
585 }
586
587 void MediaPlayer::setCDMSession(LegacyCDMSession* session)
588 {
589     m_private->setCDMSession(session);
590 }
591
592 void MediaPlayer::keyAdded()
593 {
594     m_private->keyAdded();
595 }
596 #endif
597     
598 #if ENABLE(ENCRYPTED_MEDIA)
599 void MediaPlayer::cdmInstanceAttached(CDMInstance& instance)
600 {
601     m_private->cdmInstanceAttached(instance);
602 }
603
604 void MediaPlayer::cdmInstanceDetached(CDMInstance& instance)
605 {
606     m_private->cdmInstanceDetached(instance);
607 }
608
609 void MediaPlayer::attemptToDecryptWithInstance(CDMInstance& instance)
610 {
611     m_private->attemptToDecryptWithInstance(instance);
612 }
613 #endif
614
615 MediaTime MediaPlayer::duration() const
616 {
617     return m_private->durationMediaTime();
618 }
619
620 MediaTime MediaPlayer::startTime() const
621 {
622     return m_private->startTime();
623 }
624
625 MediaTime MediaPlayer::initialTime() const
626 {
627     return m_private->initialTime();
628 }
629
630 MediaTime MediaPlayer::currentTime() const
631 {
632     return m_private->currentMediaTime();
633 }
634
635 MediaTime MediaPlayer::getStartDate() const
636 {
637     return m_private->getStartDate();
638 }
639
640 void MediaPlayer::seekWithTolerance(const MediaTime& time, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance)
641 {
642     m_private->seekWithTolerance(time, negativeTolerance, positiveTolerance);
643 }
644
645 void MediaPlayer::seek(const MediaTime& time)
646 {
647     m_private->seek(time);
648 }
649
650 bool MediaPlayer::paused() const
651 {
652     return m_private->paused();
653 }
654
655 bool MediaPlayer::seeking() const
656 {
657     return m_private->seeking();
658 }
659
660 bool MediaPlayer::supportsFullscreen() const
661 {
662     return m_private->supportsFullscreen();
663 }
664
665 bool MediaPlayer::canSaveMediaData() const
666 {
667     return m_private->canSaveMediaData();
668 }
669
670 bool MediaPlayer::supportsScanning() const
671 {
672     return m_private->supportsScanning();
673 }
674
675 bool MediaPlayer::requiresImmediateCompositing() const
676 {
677     return m_private->requiresImmediateCompositing();
678 }
679
680 FloatSize MediaPlayer::naturalSize()
681 {
682     return m_private->naturalSize();
683 }
684
685 bool MediaPlayer::hasVideo() const
686 {
687     return m_private->hasVideo();
688 }
689
690 bool MediaPlayer::hasAudio() const
691 {
692     return m_private->hasAudio();
693 }
694
695 bool MediaPlayer::inMediaDocument() const
696 {
697     return m_visible && client().mediaPlayerIsInMediaDocument();
698 }
699
700 PlatformMedia MediaPlayer::platformMedia() const
701 {
702     return m_private->platformMedia();
703 }
704
705 PlatformLayer* MediaPlayer::platformLayer() const
706 {
707     return m_private->platformLayer();
708 }
709     
710 #if PLATFORM(IOS) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
711 void MediaPlayer::setVideoFullscreenLayer(PlatformLayer* layer, WTF::Function<void()>&& completionHandler)
712 {
713     m_private->setVideoFullscreenLayer(layer, WTFMove(completionHandler));
714 }
715
716 void MediaPlayer::setVideoFullscreenFrame(FloatRect frame)
717 {
718     m_private->setVideoFullscreenFrame(frame);
719 }
720
721 void MediaPlayer::setVideoFullscreenGravity(MediaPlayer::VideoGravity gravity)
722 {
723     m_private->setVideoFullscreenGravity(gravity);
724 }
725
726 void MediaPlayer::setVideoFullscreenMode(MediaPlayer::VideoFullscreenMode mode)
727 {
728     m_private->setVideoFullscreenMode(mode);
729 }
730
731 MediaPlayer::VideoFullscreenMode MediaPlayer::fullscreenMode() const
732 {
733     return client().mediaPlayerFullscreenMode();
734 }
735 #endif
736
737 #if PLATFORM(IOS)
738 NSArray* MediaPlayer::timedMetadata() const
739 {
740     return m_private->timedMetadata();
741 }
742
743 String MediaPlayer::accessLog() const
744 {
745     return m_private->accessLog();
746 }
747
748 String MediaPlayer::errorLog() const
749 {
750     return m_private->errorLog();
751 }
752 #endif
753
754 MediaPlayer::NetworkState MediaPlayer::networkState()
755 {
756     return m_private->networkState();
757 }
758
759 MediaPlayer::ReadyState MediaPlayer::readyState()
760 {
761     return m_private->readyState();
762 }
763
764 double MediaPlayer::volume() const
765 {
766     return m_volume;
767 }
768
769 void MediaPlayer::setVolume(double volume)
770 {
771     m_volume = volume;
772
773     if (m_private->supportsMuting() || !m_muted)
774         m_private->setVolumeDouble(volume);
775 }
776
777 bool MediaPlayer::muted() const
778 {
779     return m_muted;
780 }
781
782 void MediaPlayer::setMuted(bool muted)
783 {
784     m_muted = muted;
785
786     if (m_private->supportsMuting())
787         m_private->setMuted(muted);
788     else
789         m_private->setVolume(muted ? 0 : m_volume);
790 }
791
792 bool MediaPlayer::hasClosedCaptions() const
793 {
794     return m_private->hasClosedCaptions();
795 }
796
797 void MediaPlayer::setClosedCaptionsVisible(bool closedCaptionsVisible)
798 {
799     m_private->setClosedCaptionsVisible(closedCaptionsVisible);
800 }
801
802 double MediaPlayer::rate() const
803 {
804     return m_private->rate();
805 }
806
807 void MediaPlayer::setRate(double rate)
808 {
809     m_private->setRateDouble(rate);
810 }
811
812 double MediaPlayer::requestedRate() const
813 {
814     return client().mediaPlayerRequestedPlaybackRate();
815 }
816
817 bool MediaPlayer::preservesPitch() const
818 {
819     return m_preservesPitch;
820 }
821
822 void MediaPlayer::setPreservesPitch(bool preservesPitch)
823 {
824     m_preservesPitch = preservesPitch;
825     m_private->setPreservesPitch(preservesPitch);
826 }
827
828 std::unique_ptr<PlatformTimeRanges> MediaPlayer::buffered()
829 {
830     return m_private->buffered();
831 }
832
833 std::unique_ptr<PlatformTimeRanges> MediaPlayer::seekable()
834 {
835     return m_private->seekable();
836 }
837
838 MediaTime MediaPlayer::maxTimeSeekable()
839 {
840     return m_private->maxMediaTimeSeekable();
841 }
842
843 MediaTime MediaPlayer::minTimeSeekable()
844 {
845     return m_private->minMediaTimeSeekable();
846 }
847
848 double MediaPlayer::seekableTimeRangesLastModifiedTime()
849 {
850     return m_private->seekableTimeRangesLastModifiedTime();
851 }
852
853 double MediaPlayer::liveUpdateInterval()
854 {
855     return m_private->liveUpdateInterval();
856 }
857
858 bool MediaPlayer::didLoadingProgress()
859 {
860     return m_private->didLoadingProgress();
861 }
862
863 void MediaPlayer::setSize(const IntSize& size)
864
865     m_size = size;
866     m_private->setSize(size);
867 }
868
869 bool MediaPlayer::visible() const
870 {
871     return m_visible;
872 }
873
874 void MediaPlayer::setVisible(bool b)
875 {
876     m_visible = b;
877     m_private->setVisible(b);
878 }
879
880 MediaPlayer::Preload MediaPlayer::preload() const
881 {
882     return m_preload;
883 }
884
885 void MediaPlayer::setPreload(MediaPlayer::Preload preload)
886 {
887     m_preload = preload;
888     m_private->setPreload(preload);
889 }
890
891 void MediaPlayer::paint(GraphicsContext& p, const FloatRect& r)
892 {
893     m_private->paint(p, r);
894 }
895
896 void MediaPlayer::paintCurrentFrameInContext(GraphicsContext& p, const FloatRect& r)
897 {
898     m_private->paintCurrentFrameInContext(p, r);
899 }
900
901 bool MediaPlayer::copyVideoTextureToPlatformTexture(GraphicsContext3D* context, Platform3DObject texture, GC3Denum target, GC3Dint level, GC3Denum internalFormat, GC3Denum format, GC3Denum type, bool premultiplyAlpha, bool flipY)
902 {
903     return m_private->copyVideoTextureToPlatformTexture(context, texture, target, level, internalFormat, format, type, premultiplyAlpha, flipY);
904 }
905
906 NativeImagePtr MediaPlayer::nativeImageForCurrentTime()
907 {
908     return m_private->nativeImageForCurrentTime();
909 }
910
911 MediaPlayer::SupportsType MediaPlayer::supportsType(const MediaEngineSupportParameters& parameters, const MediaPlayerSupportsTypeClient* client)
912 {
913     // 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the 
914     // user agent knows it cannot render or is the type "application/octet-stream"
915     AtomicString containerType = parameters.type.containerType();
916     if (containerType == applicationOctetStream())
917         return IsNotSupported;
918
919     const MediaPlayerFactory* engine = bestMediaEngineForSupportParameters(parameters);
920     if (!engine)
921         return IsNotSupported;
922
923 #if PLATFORM(COCOA)
924     // YouTube will ask if the HTMLMediaElement canPlayType video/webm, then
925     // video/x-flv, then finally video/mp4, and will then load a URL of the first type
926     // in that list which returns "probably". When Perian is installed,
927     // MediaPlayerPrivateQTKit claims to support both video/webm and video/x-flv, but
928     // due to a bug in Perian, loading media in these formats will sometimes fail on
929     // slow connections. <https://bugs.webkit.org/show_bug.cgi?id=86409>
930     if (client && client->mediaPlayerNeedsSiteSpecificHacks()) {
931         String host = client->mediaPlayerDocumentHost();
932         if ((host.endsWithIgnoringASCIICase(".youtube.com") || equalLettersIgnoringASCIICase(host, "youtube.com"))
933             && (startsWithLettersIgnoringASCIICase(containerType, "video/webm") || startsWithLettersIgnoringASCIICase(containerType, "video/x-flv")))
934             return IsNotSupported;
935     }
936 #else
937     UNUSED_PARAM(client);
938 #endif
939
940     return engine->supportsTypeAndCodecs(parameters);
941 }
942
943 void MediaPlayer::getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>& types)
944 {
945     for (auto& engine : installedMediaEngines()) {
946         HashSet<String, ASCIICaseInsensitiveHash> engineTypes;
947         engine.getSupportedTypes(engineTypes);
948         types.add(engineTypes.begin(), engineTypes.end());
949     }
950
951
952 bool MediaPlayer::isAvailable()
953 {
954 #if PLATFORM(IOS)
955     if (DeprecatedGlobalSettings::isAVFoundationEnabled())
956         return true;
957 #endif
958     return !installedMediaEngines().isEmpty();
959 }
960
961 bool MediaPlayer::supportsPictureInPicture() const
962 {
963     return m_private->supportsPictureInPicture();
964 }
965
966 #if USE(NATIVE_FULLSCREEN_VIDEO)
967 void MediaPlayer::enterFullscreen()
968 {
969     m_private->enterFullscreen();
970 }
971
972 void MediaPlayer::exitFullscreen()
973 {
974     m_private->exitFullscreen();
975 }
976 #endif
977
978 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
979 bool MediaPlayer::isCurrentPlaybackTargetWireless() const
980 {
981     return m_private->isCurrentPlaybackTargetWireless();
982 }
983
984 String MediaPlayer::wirelessPlaybackTargetName() const
985 {
986     return m_private->wirelessPlaybackTargetName();
987 }
988
989 MediaPlayer::WirelessPlaybackTargetType MediaPlayer::wirelessPlaybackTargetType() const
990 {
991     return m_private->wirelessPlaybackTargetType();
992 }
993
994 bool MediaPlayer::wirelessVideoPlaybackDisabled() const
995 {
996     return m_private->wirelessVideoPlaybackDisabled();
997 }
998
999 void MediaPlayer::setWirelessVideoPlaybackDisabled(bool disabled)
1000 {
1001     m_private->setWirelessVideoPlaybackDisabled(disabled);
1002 }
1003
1004 void MediaPlayer::currentPlaybackTargetIsWirelessChanged()
1005 {
1006     client().mediaPlayerCurrentPlaybackTargetIsWirelessChanged(this);
1007 }
1008
1009 bool MediaPlayer::canPlayToWirelessPlaybackTarget() const
1010 {
1011     return m_private->canPlayToWirelessPlaybackTarget();
1012 }
1013
1014 void MediaPlayer::setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&& device)
1015 {
1016     m_private->setWirelessPlaybackTarget(WTFMove(device));
1017 }
1018
1019 void MediaPlayer::setShouldPlayToPlaybackTarget(bool shouldPlay)
1020 {
1021     m_private->setShouldPlayToPlaybackTarget(shouldPlay);
1022 }
1023 #endif
1024
1025 double MediaPlayer::maxFastForwardRate() const
1026 {
1027     return m_private->maxFastForwardRate();
1028 }
1029
1030 double MediaPlayer::minFastReverseRate() const
1031 {
1032     return m_private->minFastReverseRate();
1033 }
1034
1035 #if USE(NATIVE_FULLSCREEN_VIDEO)
1036 bool MediaPlayer::canEnterFullscreen() const
1037 {
1038     return m_private->canEnterFullscreen();
1039 }
1040 #endif
1041
1042 void MediaPlayer::acceleratedRenderingStateChanged()
1043 {
1044     m_private->acceleratedRenderingStateChanged();
1045 }
1046
1047 bool MediaPlayer::supportsAcceleratedRendering() const
1048 {
1049     return m_private->supportsAcceleratedRendering();
1050 }
1051
1052 bool MediaPlayer::shouldMaintainAspectRatio() const
1053 {
1054     return m_private->shouldMaintainAspectRatio();
1055 }
1056
1057 void MediaPlayer::setShouldMaintainAspectRatio(bool maintainAspectRatio)
1058 {
1059     m_private->setShouldMaintainAspectRatio(maintainAspectRatio);
1060 }
1061
1062 bool MediaPlayer::hasSingleSecurityOrigin() const
1063 {
1064     return m_private->hasSingleSecurityOrigin();
1065 }
1066
1067 bool MediaPlayer::didPassCORSAccessCheck() const
1068 {
1069     return m_private->didPassCORSAccessCheck();
1070 }
1071
1072 MediaPlayer::MovieLoadType MediaPlayer::movieLoadType() const
1073 {
1074     return m_private->movieLoadType();
1075 }
1076
1077 MediaTime MediaPlayer::mediaTimeForTimeValue(const MediaTime& timeValue) const
1078 {
1079     return m_private->mediaTimeForTimeValue(timeValue);
1080 }
1081
1082 double MediaPlayer::maximumDurationToCacheMediaTime() const
1083 {
1084     return m_private->maximumDurationToCacheMediaTime();
1085 }
1086
1087 unsigned MediaPlayer::decodedFrameCount() const
1088 {
1089     return m_private->decodedFrameCount();
1090 }
1091
1092 unsigned MediaPlayer::droppedFrameCount() const
1093 {
1094     return m_private->droppedFrameCount();
1095 }
1096
1097 unsigned MediaPlayer::audioDecodedByteCount() const
1098 {
1099     return m_private->audioDecodedByteCount();
1100 }
1101
1102 unsigned MediaPlayer::videoDecodedByteCount() const
1103 {
1104     return m_private->videoDecodedByteCount();
1105 }
1106
1107 void MediaPlayer::reloadTimerFired()
1108 {
1109     m_private->cancelLoad();
1110     loadWithNextMediaEngine(m_currentMediaEngine);
1111 }
1112
1113 template<typename T>
1114 static void addToHash(HashSet<T>& toHash, HashSet<T>&& fromHash)
1115 {
1116     if (toHash.isEmpty())
1117         toHash = WTFMove(fromHash);
1118     else
1119         toHash.add(fromHash.begin(), fromHash.end());
1120 }
1121     
1122 HashSet<RefPtr<SecurityOrigin>> MediaPlayer::originsInMediaCache(const String& path)
1123 {
1124     HashSet<RefPtr<SecurityOrigin>> origins;
1125     for (auto& engine : installedMediaEngines()) {
1126         if (!engine.originsInMediaCache)
1127             continue;
1128         addToHash(origins, engine.originsInMediaCache(path));
1129     }
1130     return origins;
1131 }
1132
1133 void MediaPlayer::clearMediaCache(const String& path, WallTime modifiedSince)
1134 {
1135     for (auto& engine : installedMediaEngines()) {
1136         if (engine.clearMediaCache)
1137             engine.clearMediaCache(path, modifiedSince);
1138     }
1139 }
1140
1141 void MediaPlayer::clearMediaCacheForOrigins(const String& path, const HashSet<RefPtr<SecurityOrigin>>& origins)
1142 {
1143     for (auto& engine : installedMediaEngines()) {
1144         if (engine.clearMediaCacheForOrigins)
1145             engine.clearMediaCacheForOrigins(path, origins);
1146     }
1147 }
1148
1149 bool MediaPlayer::supportsKeySystem(const String& keySystem, const String& mimeType)
1150 {
1151     for (auto& engine : installedMediaEngines()) {
1152         if (engine.supportsKeySystem && engine.supportsKeySystem(keySystem, mimeType))
1153             return true;
1154     }
1155     return false;
1156 }
1157
1158 void MediaPlayer::setPrivateBrowsingMode(bool privateBrowsingMode)
1159 {
1160     m_privateBrowsing = privateBrowsingMode;
1161     if (m_private)
1162         m_private->setPrivateBrowsingMode(m_privateBrowsing);
1163 }
1164
1165 // Client callbacks.
1166 void MediaPlayer::networkStateChanged()
1167 {
1168     // If more than one media engine is installed and this one failed before finding metadata,
1169     // let the next engine try.
1170     if (m_private->networkState() >= FormatError && m_private->readyState() < HaveMetadata) {
1171         client().mediaPlayerEngineFailedToLoad();
1172         if (installedMediaEngines().size() > 1 && (m_contentType.isEmpty() || nextBestMediaEngine(m_currentMediaEngine))) {
1173             m_reloadTimer.startOneShot(0_s);
1174             return;
1175         }
1176     }
1177     client().mediaPlayerNetworkStateChanged(this);
1178 }
1179
1180 void MediaPlayer::readyStateChanged()
1181 {
1182     client().mediaPlayerReadyStateChanged(this);
1183 }
1184
1185 void MediaPlayer::volumeChanged(double newVolume)
1186 {
1187 #if PLATFORM(IOS)
1188     UNUSED_PARAM(newVolume);
1189     m_volume = m_private->volume();
1190 #else
1191     m_volume = newVolume;
1192 #endif
1193     client().mediaPlayerVolumeChanged(this);
1194 }
1195
1196 void MediaPlayer::muteChanged(bool newMuted)
1197 {
1198     m_muted = newMuted;
1199     client().mediaPlayerMuteChanged(this);
1200 }
1201
1202 void MediaPlayer::timeChanged()
1203 {
1204     client().mediaPlayerTimeChanged(this);
1205 }
1206
1207 void MediaPlayer::sizeChanged()
1208 {
1209     client().mediaPlayerSizeChanged(this);
1210 }
1211
1212 void MediaPlayer::repaint()
1213 {
1214     client().mediaPlayerRepaint(this);
1215 }
1216
1217 void MediaPlayer::durationChanged()
1218 {
1219     client().mediaPlayerDurationChanged(this);
1220 }
1221
1222 void MediaPlayer::rateChanged()
1223 {
1224     client().mediaPlayerRateChanged(this);
1225 }
1226
1227 void MediaPlayer::playbackStateChanged()
1228 {
1229     client().mediaPlayerPlaybackStateChanged(this);
1230 }
1231
1232 void MediaPlayer::firstVideoFrameAvailable()
1233 {
1234     client().mediaPlayerFirstVideoFrameAvailable(this);
1235 }
1236
1237 void MediaPlayer::characteristicChanged()
1238 {
1239     client().mediaPlayerCharacteristicChanged(this);
1240 }
1241
1242 #if ENABLE(WEB_AUDIO)
1243 AudioSourceProvider* MediaPlayer::audioSourceProvider()
1244 {
1245     return m_private->audioSourceProvider();
1246 }
1247 #endif // WEB_AUDIO
1248
1249 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
1250 RefPtr<ArrayBuffer> MediaPlayer::cachedKeyForKeyId(const String& keyId) const
1251 {
1252     return client().mediaPlayerCachedKeyForKeyId(keyId);
1253 }
1254
1255 bool MediaPlayer::keyNeeded(Uint8Array* initData)
1256 {
1257     return client().mediaPlayerKeyNeeded(this, initData);
1258 }
1259
1260 String MediaPlayer::mediaKeysStorageDirectory() const
1261 {
1262     return client().mediaPlayerMediaKeysStorageDirectory();
1263 }
1264 #endif
1265
1266 #if ENABLE(ENCRYPTED_MEDIA)
1267 void MediaPlayer::initializationDataEncountered(const String& initDataType, RefPtr<ArrayBuffer>&& initData)
1268 {
1269     client().mediaPlayerInitializationDataEncountered(initDataType, WTFMove(initData));
1270 }
1271 #endif
1272
1273 String MediaPlayer::referrer() const
1274 {
1275     return client().mediaPlayerReferrer();
1276 }
1277
1278 String MediaPlayer::userAgent() const
1279 {
1280     return client().mediaPlayerUserAgent();
1281 }
1282
1283 String MediaPlayer::engineDescription() const
1284 {
1285     if (!m_private)
1286         return String();
1287
1288     return m_private->engineDescription();
1289 }
1290
1291 long MediaPlayer::platformErrorCode() const
1292 {
1293     if (!m_private)
1294         return 0;
1295
1296     return m_private->platformErrorCode();
1297 }
1298
1299 #if PLATFORM(WIN) && USE(AVFOUNDATION)
1300 GraphicsDeviceAdapter* MediaPlayer::graphicsDeviceAdapter() const
1301 {
1302     return client().mediaPlayerGraphicsDeviceAdapter(this);
1303 }
1304 #endif
1305
1306 CachedResourceLoader* MediaPlayer::cachedResourceLoader()
1307 {
1308     return client().mediaPlayerCachedResourceLoader();
1309 }
1310
1311 RefPtr<PlatformMediaResourceLoader> MediaPlayer::createResourceLoader()
1312 {
1313     return client().mediaPlayerCreateResourceLoader();
1314 }
1315
1316 #if ENABLE(VIDEO_TRACK)
1317
1318 void MediaPlayer::addAudioTrack(AudioTrackPrivate& track)
1319 {
1320     client().mediaPlayerDidAddAudioTrack(track);
1321 }
1322
1323 void MediaPlayer::removeAudioTrack(AudioTrackPrivate& track)
1324 {
1325     client().mediaPlayerDidRemoveAudioTrack(track);
1326 }
1327
1328 void MediaPlayer::addTextTrack(InbandTextTrackPrivate& track)
1329 {
1330     client().mediaPlayerDidAddTextTrack(track);
1331 }
1332
1333 void MediaPlayer::removeTextTrack(InbandTextTrackPrivate& track)
1334 {
1335     client().mediaPlayerDidRemoveTextTrack(track);
1336 }
1337
1338 void MediaPlayer::addVideoTrack(VideoTrackPrivate& track)
1339 {
1340     client().mediaPlayerDidAddVideoTrack(track);
1341 }
1342
1343 void MediaPlayer::removeVideoTrack(VideoTrackPrivate& track)
1344 {
1345     client().mediaPlayerDidRemoveVideoTrack(track);
1346 }
1347
1348 bool MediaPlayer::requiresTextTrackRepresentation() const
1349 {
1350     return m_private->requiresTextTrackRepresentation();
1351 }
1352
1353 void MediaPlayer::setTextTrackRepresentation(TextTrackRepresentation* representation)
1354 {
1355     m_private->setTextTrackRepresentation(representation);
1356 }
1357
1358 void MediaPlayer::syncTextTrackBounds()
1359 {
1360     m_private->syncTextTrackBounds();
1361 }
1362
1363 void MediaPlayer::tracksChanged()
1364 {
1365     m_private->tracksChanged();
1366 }
1367
1368 #if ENABLE(AVF_CAPTIONS)
1369
1370 void MediaPlayer::notifyTrackModeChanged()
1371 {
1372     if (m_private)
1373         m_private->notifyTrackModeChanged();
1374 }
1375
1376 Vector<RefPtr<PlatformTextTrack>> MediaPlayer::outOfBandTrackSources()
1377 {
1378     return client().outOfBandTrackSources();
1379 }
1380
1381 #endif
1382
1383 #endif // ENABLE(VIDEO_TRACK)
1384
1385 void MediaPlayer::resetMediaEngines()
1386 {
1387     auto locker = holdLock(mediaEngineVectorLock);
1388
1389     mutableInstalledMediaEnginesVector().clear();
1390     haveMediaEnginesVector() = false;
1391 }
1392
1393 #if USE(GSTREAMER)
1394 void MediaPlayer::simulateAudioInterruption()
1395 {
1396     if (!m_private)
1397         return;
1398
1399     m_private->simulateAudioInterruption();
1400 }
1401 #endif
1402
1403 String MediaPlayer::languageOfPrimaryAudioTrack() const
1404 {
1405     if (!m_private)
1406         return emptyString();
1407     
1408     return m_private->languageOfPrimaryAudioTrack();
1409 }
1410
1411 size_t MediaPlayer::extraMemoryCost() const
1412 {
1413     if (!m_private)
1414         return 0;
1415
1416     return m_private->extraMemoryCost();
1417 }
1418
1419 unsigned long long MediaPlayer::fileSize() const
1420 {
1421     if (!m_private)
1422         return 0;
1423     
1424     return m_private->fileSize();
1425 }
1426
1427 bool MediaPlayer::ended() const
1428 {
1429     return m_private->ended();
1430 }
1431
1432 #if ENABLE(MEDIA_SOURCE)
1433 std::optional<PlatformVideoPlaybackQualityMetrics> MediaPlayer::videoPlaybackQualityMetrics()
1434 {
1435     if (!m_private)
1436         return std::nullopt;
1437
1438     return m_private->videoPlaybackQualityMetrics();
1439 }
1440 #endif
1441
1442 bool MediaPlayer::shouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge& challenge)
1443 {
1444     return client().mediaPlayerShouldWaitForResponseToAuthenticationChallenge(challenge);
1445 }
1446
1447 void MediaPlayer::handlePlaybackCommand(PlatformMediaSession::RemoteControlCommandType command)
1448 {
1449     client().mediaPlayerHandlePlaybackCommand(command);
1450 }
1451
1452 String MediaPlayer::sourceApplicationIdentifier() const
1453 {
1454     return client().mediaPlayerSourceApplicationIdentifier();
1455 }
1456
1457 Vector<String> MediaPlayer::preferredAudioCharacteristics() const
1458 {
1459     return client().mediaPlayerPreferredAudioCharacteristics();
1460 }
1461
1462 void MediaPlayerFactorySupport::callRegisterMediaEngine(MediaEngineRegister registerMediaEngine)
1463 {
1464     registerMediaEngine(addMediaEngine);
1465 }
1466
1467 bool MediaPlayer::doesHaveAttribute(const AtomicString& attribute, AtomicString* value) const
1468 {
1469     return client().doesHaveAttribute(attribute, value);
1470 }
1471
1472 #if PLATFORM(IOS)
1473 String MediaPlayer::mediaPlayerNetworkInterfaceName() const
1474 {
1475     return client().mediaPlayerNetworkInterfaceName();
1476 }
1477
1478 bool MediaPlayer::getRawCookies(const URL& url, Vector<Cookie>& cookies) const
1479 {
1480     return client().mediaPlayerGetRawCookies(url, cookies);
1481 }
1482 #endif
1483
1484 void MediaPlayer::setShouldDisableSleep(bool flag)
1485 {
1486     if (m_private)
1487         m_private->setShouldDisableSleep(flag);
1488 }
1489
1490 bool MediaPlayer::shouldDisableSleep() const
1491 {
1492     return client().mediaPlayerShouldDisableSleep();
1493 }
1494
1495 const Vector<ContentType>& MediaPlayer::mediaContentTypesRequiringHardwareSupport() const
1496 {
1497     return client().mediaContentTypesRequiringHardwareSupport();
1498 }
1499
1500 bool MediaPlayer::shouldCheckHardwareSupport() const
1501 {
1502     return client().mediaPlayerShouldCheckHardwareSupport();
1503 }
1504
1505 #if !RELEASE_LOG_DISABLED
1506 const Logger& MediaPlayer::mediaPlayerLogger()
1507 {
1508     return client().mediaPlayerLogger();
1509 }
1510 #endif
1511
1512 String convertEnumerationToString(MediaPlayerEnums::ReadyState enumerationValue)
1513 {
1514     static const NeverDestroyed<String> values[] = {
1515         MAKE_STATIC_STRING_IMPL("HaveNothing"),
1516         MAKE_STATIC_STRING_IMPL("HaveMetadata"),
1517         MAKE_STATIC_STRING_IMPL("HaveCurrentData"),
1518         MAKE_STATIC_STRING_IMPL("HaveFutureData"),
1519         MAKE_STATIC_STRING_IMPL("HaveEnoughData"),
1520     };
1521     static_assert(static_cast<size_t>(MediaPlayerEnums::HaveNothing) == 0, "MediaPlayerEnums::HaveNothing is not 0 as expected");
1522     static_assert(static_cast<size_t>(MediaPlayerEnums::HaveMetadata) == 1, "MediaPlayerEnums::HaveMetadata is not 1 as expected");
1523     static_assert(static_cast<size_t>(MediaPlayerEnums::HaveCurrentData) == 2, "MediaPlayerEnums::HaveCurrentData is not 2 as expected");
1524     static_assert(static_cast<size_t>(MediaPlayerEnums::HaveFutureData) == 3, "MediaPlayerEnums::HaveFutureData is not 3 as expected");
1525     static_assert(static_cast<size_t>(MediaPlayerEnums::HaveEnoughData) == 4, "MediaPlayerEnums::HaveEnoughData is not 4 as expected");
1526     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
1527     return values[static_cast<size_t>(enumerationValue)];
1528 }
1529
1530 String convertEnumerationToString(MediaPlayerEnums::NetworkState enumerationValue)
1531 {
1532     static const NeverDestroyed<String> values[] = {
1533         MAKE_STATIC_STRING_IMPL("Empty"),
1534         MAKE_STATIC_STRING_IMPL("Idle"),
1535         MAKE_STATIC_STRING_IMPL("Loading"),
1536         MAKE_STATIC_STRING_IMPL("Loaded"),
1537         MAKE_STATIC_STRING_IMPL("FormatError"),
1538         MAKE_STATIC_STRING_IMPL("NetworkError"),
1539         MAKE_STATIC_STRING_IMPL("DecodeError"),
1540     };
1541     static_assert(static_cast<size_t>(MediaPlayerEnums::Empty) == 0, "MediaPlayerEnums::Empty is not 0 as expected");
1542     static_assert(static_cast<size_t>(MediaPlayerEnums::Idle) == 1, "MediaPlayerEnums::Idle is not 1 as expected");
1543     static_assert(static_cast<size_t>(MediaPlayerEnums::Loading) == 2, "MediaPlayerEnums::Loading is not 2 as expected");
1544     static_assert(static_cast<size_t>(MediaPlayerEnums::Loaded) == 3, "MediaPlayerEnums::Loaded is not 3 as expected");
1545     static_assert(static_cast<size_t>(MediaPlayerEnums::FormatError) == 4, "MediaPlayerEnums::FormatError is not 4 as expected");
1546     static_assert(static_cast<size_t>(MediaPlayerEnums::NetworkError) == 5, "MediaPlayerEnums::NetworkError is not 5 as expected");
1547     static_assert(static_cast<size_t>(MediaPlayerEnums::DecodeError) == 6, "MediaPlayerEnums::DecodeError is not 6 as expected");
1548     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
1549     return values[static_cast<size_t>(enumerationValue)];
1550 }
1551
1552 }
1553
1554 #endif