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