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