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