Fullscreen video layers are off by one sometimes
[WebKit-https.git] / Source / WebCore / platform / graphics / MediaPlayer.h
1 /*
2  * Copyright (C) 2007-2014 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef MediaPlayer_h
27 #define MediaPlayer_h
28
29 #if ENABLE(VIDEO)
30 #include "GraphicsTypes3D.h"
31
32 #include "AudioTrackPrivate.h"
33 #include "CDMSession.h"
34 #include "InbandTextTrackPrivate.h"
35 #include "IntRect.h"
36 #include "URL.h"
37 #include "LayoutRect.h"
38 #include "MediaSession.h"
39 #include "NativeImagePtr.h"
40 #include "PlatformLayer.h"
41 #include "PlatformMediaResourceLoader.h"
42 #include "Timer.h"
43 #include "VideoTrackPrivate.h"
44 #include <runtime/Uint8Array.h>
45 #include <wtf/Forward.h>
46 #include <wtf/HashSet.h>
47 #include <wtf/MediaTime.h>
48 #include <wtf/Noncopyable.h>
49 #include <wtf/OwnPtr.h>
50 #include <wtf/PassOwnPtr.h>
51 #include <wtf/text/StringHash.h>
52
53 #if ENABLE(AVF_CAPTIONS)
54 #include "PlatformTextTrack.h"
55 #endif
56
57 #if USE(PLATFORM_TEXT_TRACK_MENU)
58 #include "PlatformTextTrackMenu.h"
59 #endif
60
61 OBJC_CLASS AVAsset;
62 OBJC_CLASS AVPlayer;
63 OBJC_CLASS NSArray;
64 OBJC_CLASS QTMovie;
65
66 class AVCFPlayer;
67 class QTMovieGWorld;
68 class QTMovieVisualContext;
69
70 namespace WebCore {
71
72 class AudioSourceProvider;
73 class AuthenticationChallenge;
74 #if ENABLE(MEDIA_SOURCE)
75 class MediaSourcePrivateClient;
76 #endif
77 class MediaPlayerPrivateInterface;
78 class TextTrackRepresentation;
79 struct Cookie;
80
81 // Structure that will hold every native
82 // types supported by the current media player.
83 // We have to do that has multiple media players
84 // backend can live at runtime.
85 struct PlatformMedia {
86     enum {
87         None,
88         QTMovieType,
89         QTMovieGWorldType,
90         QTMovieVisualContextType,
91         AVFoundationMediaPlayerType,
92         AVFoundationCFMediaPlayerType,
93         AVFoundationAssetType,
94     } type;
95
96     union {
97         QTMovie* qtMovie;
98         QTMovieGWorld* qtMovieGWorld;
99         QTMovieVisualContext* qtMovieVisualContext;
100         AVPlayer* avfMediaPlayer;
101         AVCFPlayer* avcfMediaPlayer;
102         AVAsset* avfAsset;
103     } media;
104 };
105
106 struct MediaEngineSupportParameters {
107     String type;
108     String codecs;
109     URL url;
110 #if ENABLE(ENCRYPTED_MEDIA)
111     String keySystem;
112 #endif
113 #if ENABLE(MEDIA_SOURCE)
114     bool isMediaSource;
115 #endif
116
117     MediaEngineSupportParameters()
118 #if ENABLE(MEDIA_SOURCE)
119         : isMediaSource(false)
120 #endif
121     {
122     }
123 };
124
125 extern const PlatformMedia NoPlatformMedia;
126
127 class CachedResourceLoader;
128 class ContentType;
129 class GraphicsContext;
130 class GraphicsContext3D;
131 class IntRect;
132 class IntSize;
133 class MediaPlayer;
134 class PlatformTimeRanges;
135
136 struct MediaPlayerFactory;
137
138 #if PLATFORM(WIN) && USE(AVFOUNDATION)
139 struct GraphicsDeviceAdapter;
140 #endif
141
142 class MediaPlayerClient {
143 public:
144     virtual ~MediaPlayerClient() { }
145
146     // the network state has changed
147     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*) { }
148
149     // the ready state has changed
150     virtual void mediaPlayerReadyStateChanged(MediaPlayer*) { }
151
152     // the volume state has changed
153     virtual void mediaPlayerVolumeChanged(MediaPlayer*) { }
154
155     // the mute state has changed
156     virtual void mediaPlayerMuteChanged(MediaPlayer*) { }
157
158     // time has jumped, eg. not as a result of normal playback
159     virtual void mediaPlayerTimeChanged(MediaPlayer*) { }
160
161     // the media file duration has changed, or is now known
162     virtual void mediaPlayerDurationChanged(MediaPlayer*) { }
163
164     // the playback rate has changed
165     virtual void mediaPlayerRateChanged(MediaPlayer*) { }
166
167     // the play/pause status changed
168     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*) { }
169
170     // The MediaPlayer has found potentially problematic media content.
171     // This is used internally to trigger swapping from a <video>
172     // element to an <embed> in standalone documents
173     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*) { }
174
175     // The MediaPlayer could not discover an engine which supports the requested resource.
176     virtual void mediaPlayerResourceNotSupported(MediaPlayer*) { }
177
178 // Presentation-related methods
179     // a new frame of video is available
180     virtual void mediaPlayerRepaint(MediaPlayer*) { }
181
182     // the movie size has changed
183     virtual void mediaPlayerSizeChanged(MediaPlayer*) { }
184
185     virtual void mediaPlayerEngineUpdated(MediaPlayer*) { }
186
187     // The first frame of video is available to render. A media engine need only make this callback if the
188     // first frame is not available immediately when prepareForRendering is called.
189     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) { }
190
191     // A characteristic of the media file, eg. video, audio, closed captions, etc, has changed.
192     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) { }
193     
194     // whether the rendering system can accelerate the display of this MediaPlayer.
195     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) { return false; }
196
197     // called when the media player's rendering mode changed, which indicates a change in the
198     // availability of the platformLayer().
199     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) { }
200
201 #if PLATFORM(WIN) && USE(AVFOUNDATION)
202     virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const { return 0; }
203 #endif
204
205 #if ENABLE(ENCRYPTED_MEDIA)
206     enum MediaKeyErrorCode { UnknownError = 1, ClientError, ServiceError, OutputError, HardwareChangeError, DomainError };
207     virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */) { }
208     virtual void mediaPlayerKeyError(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, MediaKeyErrorCode, unsigned short /* systemCode */) { }
209     virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, const unsigned char* /* message */, unsigned /* messageLength */, const URL& /* defaultURL */) { }
210     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, const unsigned char* /* initData */, unsigned /* initDataLength */) { return false; }
211 #endif
212
213 #if ENABLE(ENCRYPTED_MEDIA_V2)
214     virtual RefPtr<ArrayBuffer> mediaPlayerCachedKeyForKeyId(const String&) const { return nullptr; }
215     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) { return false; }
216     virtual String mediaPlayerMediaKeysStorageDirectory() const { return emptyString(); }
217 #endif
218     
219 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
220     virtual void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) { };
221 #endif
222
223     virtual String mediaPlayerReferrer() const { return String(); }
224     virtual String mediaPlayerUserAgent() const { return String(); }
225     virtual void mediaPlayerEnterFullscreen() { }
226     virtual void mediaPlayerExitFullscreen() { }
227     virtual bool mediaPlayerIsFullscreen() const { return false; }
228     virtual bool mediaPlayerIsFullscreenPermitted() const { return false; }
229     virtual bool mediaPlayerIsVideo() const { return false; }
230     virtual LayoutRect mediaPlayerContentBoxRect() const { return LayoutRect(); }
231     virtual float mediaPlayerContentsScale() const { return 1; }
232     virtual void mediaPlayerSetSize(const IntSize&) { }
233     virtual void mediaPlayerPause() { }
234     virtual void mediaPlayerPlay() { }
235     virtual bool mediaPlayerPlatformVolumeConfigurationRequired() const { return false; }
236     virtual bool mediaPlayerIsPaused() const { return true; }
237     virtual bool mediaPlayerIsLooping() const { return false; }
238     virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() { return 0; }
239     virtual PassRefPtr<PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader(std::unique_ptr<PlatformMediaResourceLoaderClient>) { return nullptr; }
240     virtual bool doesHaveAttribute(const AtomicString&, AtomicString* = 0) const { return false; }
241
242 #if ENABLE(VIDEO_TRACK)
243     virtual void mediaPlayerDidAddAudioTrack(PassRefPtr<AudioTrackPrivate>) { }
244     virtual void mediaPlayerDidAddTextTrack(PassRefPtr<InbandTextTrackPrivate>) { }
245     virtual void mediaPlayerDidAddVideoTrack(PassRefPtr<VideoTrackPrivate>) { }
246     virtual void mediaPlayerDidRemoveAudioTrack(PassRefPtr<AudioTrackPrivate>) { }
247     virtual void mediaPlayerDidRemoveTextTrack(PassRefPtr<InbandTextTrackPrivate>) { }
248     virtual void mediaPlayerDidRemoveVideoTrack(PassRefPtr<VideoTrackPrivate>) { }
249
250     virtual void textTrackRepresentationBoundsChanged(const IntRect&) { }
251 #if ENABLE(AVF_CAPTIONS)
252     virtual Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources() { return Vector<RefPtr<PlatformTextTrack>>(); }
253 #endif
254 #endif
255
256 #if PLATFORM(IOS)
257     virtual String mediaPlayerNetworkInterfaceName() const { return String(); }
258     virtual bool mediaPlayerGetRawCookies(const URL&, Vector<Cookie>&) const { return false; }
259 #endif
260     
261     virtual bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) { return false; }
262     virtual void mediaPlayerHandlePlaybackCommand(MediaSession::RemoteControlCommandType) { }
263
264     virtual String mediaPlayerSourceApplicationIdentifier() const { return emptyString(); }
265
266     virtual bool mediaPlayerIsInMediaDocument() const { return false; }
267     virtual void mediaPlayerEngineFailedToLoad() const { }
268
269     virtual double mediaPlayerRequestedPlaybackRate() const { return 0; }
270 };
271
272 class MediaPlayerSupportsTypeClient {
273 public:
274     virtual ~MediaPlayerSupportsTypeClient() { }
275
276     virtual bool mediaPlayerNeedsSiteSpecificHacks() const { return false; }
277     virtual String mediaPlayerDocumentHost() const { return String(); }
278 };
279
280 class MediaPlayer {
281     WTF_MAKE_NONCOPYABLE(MediaPlayer); WTF_MAKE_FAST_ALLOCATED;
282 public:
283     explicit MediaPlayer(MediaPlayerClient&);
284     virtual ~MediaPlayer();
285
286     // Media engine support.
287     enum SupportsType { IsNotSupported, IsSupported, MayBeSupported };
288     static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&, const MediaPlayerSupportsTypeClient*);
289     static void getSupportedTypes(HashSet<String>&);
290     static bool isAvailable();
291     static void getSitesInMediaCache(Vector<String>&);
292     static void clearMediaCache();
293     static void clearMediaCacheForSite(const String&);
294     static bool supportsKeySystem(const String& keySystem, const String& mimeType);
295
296     bool supportsFullscreen() const;
297     bool supportsScanning() const;
298     bool canSaveMediaData() const;
299     bool requiresImmediateCompositing() const;
300     bool doesHaveAttribute(const AtomicString&, AtomicString* value = nullptr) const;
301     PlatformMedia platformMedia() const;
302     PlatformLayer* platformLayer() const;
303 #if PLATFORM(IOS)
304     void setVideoFullscreenLayer(PlatformLayer*);
305     void setVideoFullscreenFrame(FloatRect);
306     enum VideoGravity { VideoGravityResize, VideoGravityResizeAspect, VideoGravityResizeAspectFill };
307     void setVideoFullscreenGravity(VideoGravity);
308
309     NSArray *timedMetadata() const;
310     String accessLog() const;
311     String errorLog() const;
312 #endif
313
314     FloatSize naturalSize();
315     bool hasVideo() const;
316     bool hasAudio() const;
317
318     bool inMediaDocument() const;
319
320     IntSize size() const { return m_size; }
321     void setSize(const IntSize& size);
322
323     bool load(const URL&, const ContentType&, const String& keySystem);
324 #if ENABLE(MEDIA_SOURCE)
325     bool load(const URL&, const ContentType&, MediaSourcePrivateClient*);
326 #endif
327     void cancelLoad();
328
329     bool visible() const;
330     void setVisible(bool);
331
332     void prepareToPlay();
333     void play();
334     void pause();
335     void setShouldBufferData(bool);
336
337 #if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
338     // Represents synchronous exceptions that can be thrown from the Encrypted Media methods.
339     // This is different from the asynchronous MediaKeyError.
340     enum MediaKeyException { NoError, InvalidPlayerState, KeySystemNotSupported };
341 #endif
342
343 #if ENABLE(ENCRYPTED_MEDIA)
344     MediaKeyException generateKeyRequest(const String& keySystem, const unsigned char* initData, unsigned initDataLength);
345     MediaKeyException addKey(const String& keySystem, const unsigned char* key, unsigned keyLength, const unsigned char* initData, unsigned initDataLength, const String& sessionId);
346     MediaKeyException cancelKeyRequest(const String& keySystem, const String& sessionId);
347 #endif
348
349 #if ENABLE(ENCRYPTED_MEDIA_V2)
350     std::unique_ptr<CDMSession> createSession(const String& keySystem);
351     void setCDMSession(CDMSession*);
352     void keyAdded();
353 #endif
354
355     bool paused() const;
356     bool seeking() const;
357
358     static double invalidTime() { return -1.0;}
359     MediaTime duration() const;
360     MediaTime currentTime() const;
361     void seek(const MediaTime&);
362     void seekWithTolerance(const MediaTime&, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance);
363
364     MediaTime startTime() const;
365     MediaTime initialTime() const;
366
367     double rate() const;
368     void setRate(double);
369     double requestedRate() const;
370
371     bool preservesPitch() const;
372     void setPreservesPitch(bool);
373
374     std::unique_ptr<PlatformTimeRanges> buffered();
375     std::unique_ptr<PlatformTimeRanges> seekable();
376     MediaTime minTimeSeekable();
377     MediaTime maxTimeSeekable();
378
379     bool didLoadingProgress();
380
381     double volume() const;
382     void setVolume(double);
383     bool platformVolumeConfigurationRequired() const { return m_client.mediaPlayerPlatformVolumeConfigurationRequired(); }
384
385     bool muted() const;
386     void setMuted(bool);
387
388     bool hasClosedCaptions() const;
389     void setClosedCaptionsVisible(bool closedCaptionsVisible);
390
391     bool autoplay() const;
392     void setAutoplay(bool);
393
394     void paint(GraphicsContext*, const FloatRect&);
395     void paintCurrentFrameInContext(GraphicsContext*, const FloatRect&);
396
397     // copyVideoTextureToPlatformTexture() is used to do the GPU-GPU textures copy without a readback to system memory.
398     // The first five parameters denote the corresponding GraphicsContext, destination texture, requested level, requested type and the required internalFormat for destination texture.
399     // The last two parameters premultiplyAlpha and flipY denote whether addtional premultiplyAlpha and flip operation are required during the copy.
400     // It returns true on success and false on failure.
401
402     // In the GPU-GPU textures copy, the source texture(Video texture) should have valid target, internalFormat and size, etc.
403     // The destination texture may need to be resized to to the dimensions of the source texture or re-defined to the required internalFormat.
404     // The current restrictions require that format shoud be RGB or RGBA, type should be UNSIGNED_BYTE and level should be 0. It may be lifted in the future.
405
406     // Each platform port can have its own implementation on this function. The default implementation for it is a single "return false" in MediaPlayerPrivate.h.
407     // In chromium, the implementation is based on GL_CHROMIUM_copy_texture extension which is documented at
408     // http://src.chromium.org/viewvc/chrome/trunk/src/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_copy_texture.txt and implemented at
409     // http://src.chromium.org/viewvc/chrome/trunk/src/gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.cc via shaders.
410     bool copyVideoTextureToPlatformTexture(GraphicsContext3D*, Platform3DObject texture, GC3Dint level, GC3Denum type, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY);
411
412     PassNativeImagePtr nativeImageForCurrentTime();
413
414     enum NetworkState { Empty, Idle, Loading, Loaded, FormatError, NetworkError, DecodeError };
415     NetworkState networkState();
416
417     enum ReadyState  { HaveNothing, HaveMetadata, HaveCurrentData, HaveFutureData, HaveEnoughData };
418     ReadyState readyState();
419
420     enum MovieLoadType { Unknown, Download, StoredStream, LiveStream };
421     MovieLoadType movieLoadType() const;
422
423     enum Preload { None, MetaData, Auto };
424     Preload preload() const;
425     void setPreload(Preload);
426
427     void networkStateChanged();
428     void readyStateChanged();
429     void volumeChanged(double);
430     void muteChanged(bool);
431     void timeChanged();
432     void sizeChanged();
433     void rateChanged();
434     void playbackStateChanged();
435     void durationChanged();
436     void firstVideoFrameAvailable();
437     void characteristicChanged();
438
439     void repaint();
440
441     MediaPlayerClient& client() const { return m_client; }
442
443     bool hasAvailableVideoFrame() const;
444     void prepareForRendering();
445
446     bool canLoadPoster() const;
447     void setPoster(const String&);
448
449 #if USE(NATIVE_FULLSCREEN_VIDEO)
450     void enterFullscreen();
451     void exitFullscreen();
452 #endif
453
454 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
455     bool isCurrentPlaybackTargetWireless() const;
456
457     enum WirelessPlaybackTargetType { TargetTypeNone, TargetTypeAirPlay, TargetTypeTVOut };
458     WirelessPlaybackTargetType wirelessPlaybackTargetType() const;
459
460     String wirelessPlaybackTargetName() const;
461
462     bool wirelessVideoPlaybackDisabled() const;
463     void setWirelessVideoPlaybackDisabled(bool);
464
465     void currentPlaybackTargetIsWirelessChanged();
466     void playbackTargetAvailabilityChanged();
467 #endif
468
469     double minFastReverseRate() const;
470     double maxFastForwardRate() const;
471
472 #if USE(NATIVE_FULLSCREEN_VIDEO)
473     bool canEnterFullscreen() const;
474 #endif
475
476     // whether accelerated rendering is supported by the media engine for the current media.
477     bool supportsAcceleratedRendering() const;
478     // called when the rendering system flips the into or out of accelerated rendering mode.
479     void acceleratedRenderingStateChanged();
480
481     bool shouldMaintainAspectRatio() const;
482     void setShouldMaintainAspectRatio(bool);
483
484 #if PLATFORM(WIN) && USE(AVFOUNDATION)
485     GraphicsDeviceAdapter* graphicsDeviceAdapter() const;
486 #endif
487
488     bool hasSingleSecurityOrigin() const;
489
490     bool didPassCORSAccessCheck() const;
491
492     MediaTime mediaTimeForTimeValue(const MediaTime&) const;
493
494     double maximumDurationToCacheMediaTime() const;
495
496     unsigned decodedFrameCount() const;
497     unsigned droppedFrameCount() const;
498     unsigned audioDecodedByteCount() const;
499     unsigned videoDecodedByteCount() const;
500
501     void setPrivateBrowsingMode(bool);
502
503 #if ENABLE(WEB_AUDIO)
504     AudioSourceProvider* audioSourceProvider();
505 #endif
506
507 #if ENABLE(ENCRYPTED_MEDIA)
508     void keyAdded(const String& keySystem, const String& sessionId);
509     void keyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode);
510     void keyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL);
511     bool keyNeeded(const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength);
512 #endif
513
514 #if ENABLE(ENCRYPTED_MEDIA_V2)
515     RefPtr<ArrayBuffer> cachedKeyForKeyId(const String& keyId) const;
516     bool keyNeeded(Uint8Array* initData);
517     String mediaKeysStorageDirectory() const;
518 #endif
519
520     String referrer() const;
521     String userAgent() const;
522
523     String engineDescription() const;
524     long platformErrorCode() const;
525
526     CachedResourceLoader* cachedResourceLoader();
527     PassRefPtr<PlatformMediaResourceLoader> createResourceLoader(std::unique_ptr<PlatformMediaResourceLoaderClient>);
528
529 #if ENABLE(VIDEO_TRACK)
530     void addAudioTrack(PassRefPtr<AudioTrackPrivate>);
531     void addTextTrack(PassRefPtr<InbandTextTrackPrivate>);
532     void addVideoTrack(PassRefPtr<VideoTrackPrivate>);
533     void removeAudioTrack(PassRefPtr<AudioTrackPrivate>);
534     void removeTextTrack(PassRefPtr<InbandTextTrackPrivate>);
535     void removeVideoTrack(PassRefPtr<VideoTrackPrivate>);
536
537     bool requiresTextTrackRepresentation() const;
538     void setTextTrackRepresentation(TextTrackRepresentation*);
539     void syncTextTrackBounds();
540 #if ENABLE(AVF_CAPTIONS)
541     void notifyTrackModeChanged();
542     Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources();
543 #endif
544 #endif
545
546 #if PLATFORM(IOS)
547     String mediaPlayerNetworkInterfaceName() const;
548     bool getRawCookies(const URL&, Vector<Cookie>&) const;
549 #endif
550
551     static void resetMediaEngines();
552
553 #if USE(PLATFORM_TEXT_TRACK_MENU)
554     bool implementsTextTrackControls() const;
555     PassRefPtr<PlatformTextTrackMenuInterface> textTrackMenu();
556 #endif
557
558 #if USE(GSTREAMER)
559     void simulateAudioInterruption();
560 #endif
561
562     String languageOfPrimaryAudioTrack() const;
563
564     size_t extraMemoryCost() const;
565
566     unsigned long long fileSize() const;
567
568 #if ENABLE(MEDIA_SOURCE)
569     unsigned long totalVideoFrames();
570     unsigned long droppedVideoFrames();
571     unsigned long corruptedVideoFrames();
572     MediaTime totalFrameDelay();
573 #endif
574
575     bool shouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&);
576     void handlePlaybackCommand(MediaSession::RemoteControlCommandType);
577     String sourceApplicationIdentifier() const;
578
579 private:
580     const MediaPlayerFactory* nextBestMediaEngine(const MediaPlayerFactory*) const;
581     void loadWithNextMediaEngine(const MediaPlayerFactory*);
582     void reloadTimerFired();
583
584     static void initializeMediaEngines();
585
586     MediaPlayerClient& m_client;
587     Timer m_reloadTimer;
588     std::unique_ptr<MediaPlayerPrivateInterface> m_private;
589     const MediaPlayerFactory* m_currentMediaEngine;
590     URL m_url;
591     String m_contentMIMEType;
592     String m_contentTypeCodecs;
593     String m_keySystem;
594     IntSize m_size;
595     Preload m_preload;
596     bool m_visible;
597     double m_volume;
598     bool m_muted;
599     bool m_preservesPitch;
600     bool m_privateBrowsing;
601     bool m_shouldPrepareToRender;
602     bool m_contentMIMETypeWasInferredFromExtension;
603
604 #if ENABLE(MEDIA_SOURCE)
605     RefPtr<MediaSourcePrivateClient> m_mediaSource;
606 #endif
607 };
608
609 typedef std::function<std::unique_ptr<MediaPlayerPrivateInterface> (MediaPlayer*)> CreateMediaEnginePlayer;
610 typedef void (*MediaEngineSupportedTypes)(HashSet<String>& types);
611 typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const MediaEngineSupportParameters& parameters);
612 typedef void (*MediaEngineGetSitesInMediaCache)(Vector<String>&);
613 typedef void (*MediaEngineClearMediaCache)();
614 typedef void (*MediaEngineClearMediaCacheForSite)(const String&);
615 typedef bool (*MediaEngineSupportsKeySystem)(const String& keySystem, const String& mimeType);
616
617 typedef void (*MediaEngineRegistrar)(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType,
618     MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite, MediaEngineSupportsKeySystem);
619 typedef void (*MediaEngineRegister)(MediaEngineRegistrar);
620
621 class MediaPlayerFactorySupport {
622 public:
623     WEBCORE_EXPORT static void callRegisterMediaEngine(MediaEngineRegister);
624 };
625
626 }
627
628 #endif // ENABLE(VIDEO)
629
630 #endif