Source/WebCore/html/HTMLMediaElement.h

   1 /*
   2  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012 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 HTMLMediaElement_h
  27 #define HTMLMediaElement_h
  28
  29 #if ENABLE(VIDEO)
  30
  31 #include "HTMLElement.h"
  32 #include "ActiveDOMObject.h"
  33 #include "GenericEventQueue.h"
  34 #include "MediaCanStartListener.h"
  35 #include "MediaControllerInterface.h"
  36 #include "MediaPlayer.h"
  37
  38 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
  39 #include "MediaPlayerProxy.h"
  40 #endif
  41
  42 #if ENABLE(VIDEO_TRACK)
  43 #include "PODIntervalTree.h"
  44 #include "TextTrack.h"
  45 #include "TextTrackCue.h"
  46 #endif
  47
  48 namespace WebCore {
  49
  50 #if ENABLE(WEB_AUDIO)
  51 class AudioSourceProvider;
  52 class MediaElementAudioSourceNode;
  53 #endif
  54 class Event;
  55 class HTMLSourceElement;
  56 class HTMLTrackElement;
  57 class MediaController;
  58 class MediaControls;
  59 class MediaError;
  60 class KURL;
  61 class TextTrackList;
  62 class TimeRanges;
  63 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
  64 class Widget;
  65 #endif
  66 #if PLATFORM(MAC)
  67 class DisplaySleepDisabler;
  68 #endif
  69
  70 #if ENABLE(VIDEO_TRACK)
  71 typedef PODIntervalTree<double, TextTrackCue*> CueIntervalTree;
  72 typedef Vector<CueIntervalTree::IntervalType> CueList;
  73 #endif
  74
  75 // FIXME: The inheritance from MediaPlayerClient here should be private inheritance.
  76 // But it can't be until the Chromium WebMediaPlayerClientImpl class is fixed so it
  77 // no longer depends on typecasting a MediaPlayerClient to an HTMLMediaElement.
  78
  79 class HTMLMediaElement : public HTMLElement, public MediaPlayerClient, public MediaPlayerSupportsTypeClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface
  80 #if ENABLE(VIDEO_TRACK)
  81     , private TextTrackClient
  82 #endif
  83 {
  84 public:
  85     MediaPlayer* player() const { return m_player.get(); }
  86
  87     virtual bool isVideo() const = 0;
  88     virtual bool hasVideo() const { return false; }
  89     virtual bool hasAudio() const;
  90
  91     void rewind(float timeDelta);
  92     void returnToRealtime();
  93
  94     // Eventually overloaded in HTMLVideoElement
  95     virtual bool supportsFullscreen() const { return false; };
  96
  97     virtual bool supportsSave() const;
  98     virtual bool supportsScanning() const;
  99
 100     PlatformMedia platformMedia() const;
 101 #if USE(ACCELERATED_COMPOSITING)
 102     PlatformLayer* platformLayer() const;
 103 #endif
 104
 105     void scheduleLoad();
 106
 107     enum LoadType {
 108         MediaResource = 1 << 0,
 109         TextTrackResource = 1 << 1
 110     };
 111     void scheduleLoad(LoadType);
 112
 113     MediaPlayer::MovieLoadType movieLoadType() const;
 114
 115     bool inActiveDocument() const { return m_inActiveDocument; }
 116
 117 // DOM API
 118 // error state
 119     PassRefPtr<MediaError> error() const;
 120
 121 // network state
 122     void setSrc(const String&);
 123     const KURL& currentSrc() const { return m_currentSrc; }
 124
 125     enum NetworkState { NETWORK_EMPTY, NETWORK_IDLE, NETWORK_LOADING, NETWORK_NO_SOURCE };
 126     NetworkState networkState() const;
 127
 128     String preload() const;
 129     void setPreload(const String&);
 130
 131     PassRefPtr<TimeRanges> buffered() const;
 132     void load(ExceptionCode&);
 133     String canPlayType(const String& mimeType, const String& keySystem = String()) const;
 134
 135 // ready state
 136     ReadyState readyState() const;
 137     bool seeking() const;
 138
 139 // playback state
 140     float currentTime() const;
 141     void setCurrentTime(float, ExceptionCode&);
 142     double initialTime() const;
 143     float startTime() const;
 144     float duration() const;
 145     bool paused() const;
 146     float defaultPlaybackRate() const;
 147     void setDefaultPlaybackRate(float);
 148     float playbackRate() const;
 149     void setPlaybackRate(float);
 150     void updatePlaybackRate();
 151     bool webkitPreservesPitch() const;
 152     void setWebkitPreservesPitch(bool);
 153     PassRefPtr<TimeRanges> played();
 154     PassRefPtr<TimeRanges> seekable() const;
 155     bool ended() const;
 156     bool autoplay() const;
 157     void setAutoplay(bool b);
 158     bool loop() const;
 159     void setLoop(bool b);
 160     void play();
 161     void pause();
 162
 163 // captions
 164     bool webkitHasClosedCaptions() const;
 165     bool webkitClosedCaptionsVisible() const;
 166     void setWebkitClosedCaptionsVisible(bool);
 167
 168 #if ENABLE(MEDIA_STATISTICS)
 169 // Statistics
 170     unsigned webkitAudioDecodedByteCount() const;
 171     unsigned webkitVideoDecodedByteCount() const;
 172 #endif
 173
 174 #if ENABLE(MEDIA_SOURCE)
 175 //  Media Source.
 176     const KURL& webkitMediaSourceURL() const { return m_mediaSourceURL; }
 177     void webkitSourceAddId(const String&, const String&, ExceptionCode&);
 178     void webkitSourceRemoveId(const String&, ExceptionCode&);
 179     PassRefPtr<TimeRanges> webkitSourceBuffered(const String&, ExceptionCode&);
 180     void webkitSourceAppend(const String&, PassRefPtr<Uint8Array> data, ExceptionCode&);
 181     void webkitSourceAbort(const String&, ExceptionCode&);
 182     enum EndOfStreamStatus { EOS_NO_ERROR, EOS_NETWORK_ERR, EOS_DECODE_ERR };
 183     void webkitSourceEndOfStream(unsigned short, ExceptionCode&);
 184     enum SourceState { SOURCE_CLOSED, SOURCE_OPEN, SOURCE_ENDED };
 185     SourceState webkitSourceState() const;
 186     void setSourceState(SourceState);
 187
 188     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitsourceopen);
 189     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitsourceended);
 190     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitsourceclose);
 191 #endif
 192
 193 #if ENABLE(ENCRYPTED_MEDIA)
 194     void webkitGenerateKeyRequest(const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionCode&);
 195     void webkitGenerateKeyRequest(const String& keySystem, ExceptionCode&);
 196     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initData, const String& sessionId, ExceptionCode&);
 197     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, ExceptionCode&);
 198     void webkitCancelKeyRequest(const String& keySystem, const String& sessionId, ExceptionCode&);
 199
 200     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyadded);
 201     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyerror);
 202     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeymessage);
 203     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitneedkey);
 204 #endif
 205
 206 // controls
 207     bool controls() const;
 208     void setControls(bool);
 209     float volume() const;
 210     void setVolume(float, ExceptionCode&);
 211     bool muted() const;
 212     void setMuted(bool);
 213
 214     void togglePlayState();
 215     void beginScrubbing();
 216     void endScrubbing();
 217
 218     bool canPlay() const;
 219
 220     float percentLoaded() const;
 221
 222 #if ENABLE(VIDEO_TRACK)
 223     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
 224     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, ExceptionCode& ec) { return addTextTrack(kind, label, emptyString(), ec); }
 225     PassRefPtr<TextTrack> addTextTrack(const String& kind, ExceptionCode& ec) { return addTextTrack(kind, emptyString(), emptyString(), ec); }
 226
 227     TextTrackList* textTracks();
 228     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
 229
 230     virtual void didAddTrack(HTMLTrackElement*);
 231     virtual void willRemoveTrack(HTMLTrackElement*);
 232
 233     struct TrackGroup {
 234         enum GroupKind { CaptionsAndSubtitles, Description, Chapter, Metadata, Other };
 235
 236         TrackGroup(GroupKind kind)
 237             : visibleTrack(0)
 238             , defaultTrack(0)
 239             , kind(kind)
 240             , hasSrcLang(false)
 241         {
 242         }
 243
 244         Vector<HTMLTrackElement*> tracks;
 245         HTMLTrackElement* visibleTrack;
 246         HTMLTrackElement* defaultTrack;
 247         GroupKind kind;
 248         bool hasSrcLang;
 249     };
 250
 251     void configureTextTrackGroupForLanguage(const TrackGroup&) const;
 252     void configureNewTextTracks();
 253     void configureTextTrackGroup(const TrackGroup&) const;
 254
 255     bool userIsInterestedInThisTrackKind(String) const;
 256     bool textTracksAreReady() const;
 257     void configureTextTrackDisplay();
 258
 259     // TextTrackClient
 260     virtual void textTrackReadyStateChanged(TextTrack*);
 261     virtual void textTrackKindChanged(TextTrack*);
 262     virtual void textTrackModeChanged(TextTrack*);
 263     virtual void textTrackAddCues(TextTrack*, const TextTrackCueList*);
 264     virtual void textTrackRemoveCues(TextTrack*, const TextTrackCueList*);
 265     virtual void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>);
 266     virtual void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>);
 267 #endif
 268
 269 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
 270     void allocateMediaPlayerIfNecessary();
 271     void setNeedWidgetUpdate(bool needWidgetUpdate) { m_needWidgetUpdate = needWidgetUpdate; }
 272     void deliverNotification(MediaPlayerProxyNotificationType notification);
 273     void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
 274     void getPluginProxyParams(KURL& url, Vector<String>& names, Vector<String>& values);
 275     void createMediaPlayerProxy();
 276     void updateWidget(PluginCreationOption);
 277 #endif
 278
 279     // EventTarget function.
 280     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
 281     // causes an ambiguity error at compile time. This class's constructor
 282     // ensures that both implementations return document, so return the result
 283     // of one of them here.
 284     virtual ScriptExecutionContext* scriptExecutionContext() const OVERRIDE { return HTMLElement::scriptExecutionContext(); }
 285
 286     bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
 287
 288     bool isFullscreen() const;
 289     void enterFullscreen();
 290     void exitFullscreen();
 291
 292     bool hasClosedCaptions() const;
 293     bool closedCaptionsVisible() const;
 294     void setClosedCaptionsVisible(bool);
 295
 296     MediaControls* mediaControls();
 297
 298     void sourceWasRemoved(HTMLSourceElement*);
 299     void sourceWasAdded(HTMLSourceElement*);
 300
 301     void privateBrowsingStateDidChange();
 302
 303     // Media cache management.
 304     static void getSitesInMediaCache(Vector<String>&);
 305     static void clearMediaCache();
 306     static void clearMediaCacheForSite(const String&);
 307
 308     bool isPlaying() const { return m_playing; }
 309
 310     virtual bool hasPendingActivity() const;
 311
 312 #if ENABLE(WEB_AUDIO)
 313     MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
 314     void setAudioSourceNode(MediaElementAudioSourceNode*);
 315
 316     AudioSourceProvider* audioSourceProvider();
 317 #endif
 318
 319     enum InvalidURLAction { DoNothing, Complain };
 320     bool isSafeToLoadURL(const KURL&, InvalidURLAction);
 321
 322     const String& mediaGroup() const;
 323     void setMediaGroup(const String&);
 324
 325     MediaController* controller() const;
 326     void setController(PassRefPtr<MediaController>);
 327
 328     virtual bool dispatchEvent(PassRefPtr<Event>);
 329
 330 protected:
 331     HTMLMediaElement(const QualifiedName&, Document*, bool);
 332     virtual ~HTMLMediaElement();
 333
 334     virtual void parseAttribute(const Attribute&) OVERRIDE;
 335     virtual void finishParsingChildren();
 336     virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
 337     virtual void attach();
 338
 339     virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;
 340
 341     enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
 342     DisplayMode displayMode() const { return m_displayMode; }
 343     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
 344
 345     virtual bool isMediaElement() const { return true; }
 346
 347     // Restrictions to change default behaviors.
 348     enum BehaviorRestrictionFlags {
 349         NoRestrictions = 0,
 350         RequireUserGestureForLoadRestriction = 1 << 0,
 351         RequireUserGestureForRateChangeRestriction = 1 << 1,
 352         RequireUserGestureForFullscreenRestriction = 1 << 2,
 353         RequirePageConsentToLoadMediaRestriction = 1 << 3,
 354     };
 355     typedef unsigned BehaviorRestrictions;
 356
 357     bool userGestureRequiredForLoad() const { return m_restrictions & RequireUserGestureForLoadRestriction; }
 358     bool userGestureRequiredForRateChange() const { return m_restrictions & RequireUserGestureForRateChangeRestriction; }
 359     bool userGestureRequiredForFullscreen() const { return m_restrictions & RequireUserGestureForFullscreenRestriction; }
 360     bool pageConsentRequiredForLoad() const { return m_restrictions & RequirePageConsentToLoadMediaRestriction; }
 361
 362     void addBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions |= restriction; }
 363     void removeBehaviorRestriction(BehaviorRestrictions restriction) { m_restrictions &= ~restriction; }
 364
 365 private:
 366     void createMediaPlayer();
 367
 368     virtual bool supportsFocus() const;
 369     virtual bool isMouseFocusable() const;
 370     virtual bool rendererIsNeeded(const NodeRenderingContext&);
 371     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
 372     virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const OVERRIDE;
 373     virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
 374     virtual void removedFrom(ContainerNode*) OVERRIDE;
 375     virtual void didRecalcStyle(StyleChange);
 376
 377     virtual void defaultEventHandler(Event*);
 378
 379     virtual void didBecomeFullscreenElement();
 380     virtual void willStopBeingFullscreenElement();
 381
 382     // ActiveDOMObject functions.
 383     virtual bool canSuspend() const;
 384     virtual void suspend(ReasonForSuspension);
 385     virtual void resume();
 386     virtual void stop();
 387
 388     virtual void mediaVolumeDidChange();
 389
 390     virtual void updateDisplayState() { }
 391
 392     void setReadyState(MediaPlayer::ReadyState);
 393     void setNetworkState(MediaPlayer::NetworkState);
 394
 395     virtual Document* mediaPlayerOwningDocument();
 396     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*);
 397     virtual void mediaPlayerReadyStateChanged(MediaPlayer*);
 398     virtual void mediaPlayerTimeChanged(MediaPlayer*);
 399     virtual void mediaPlayerVolumeChanged(MediaPlayer*);
 400     virtual void mediaPlayerMuteChanged(MediaPlayer*);
 401     virtual void mediaPlayerDurationChanged(MediaPlayer*);
 402     virtual void mediaPlayerRateChanged(MediaPlayer*);
 403     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*);
 404     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*);
 405     virtual void mediaPlayerResourceNotSupported(MediaPlayer*);
 406     virtual void mediaPlayerRepaint(MediaPlayer*);
 407     virtual void mediaPlayerSizeChanged(MediaPlayer*);
 408 #if USE(ACCELERATED_COMPOSITING)
 409     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*);
 410     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*);
 411 #endif
 412     virtual void mediaPlayerEngineUpdated(MediaPlayer*);
 413
 414     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*);
 415     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*);
 416
 417 #if ENABLE(MEDIA_SOURCE)
 418     virtual void mediaPlayerSourceOpened();
 419     virtual String mediaPlayerSourceURL() const;
 420     bool isValidSourceId(const String&, ExceptionCode&) const;
 421 #endif
 422
 423 #if ENABLE(ENCRYPTED_MEDIA)
 424     virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& keySystem, const String& sessionId) OVERRIDE;
 425     virtual void mediaPlayerKeyError(MediaPlayer*, const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode) OVERRIDE;
 426     virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength) OVERRIDE;
 427     virtual void mediaPlayerKeyNeeded(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength) OVERRIDE;
 428 #endif
 429
 430     virtual String mediaPlayerReferrer() const OVERRIDE;
 431     virtual String mediaPlayerUserAgent() const OVERRIDE;
 432
 433     virtual bool mediaPlayerNeedsSiteSpecificHacks() const OVERRIDE;
 434     virtual String mediaPlayerDocumentHost() const OVERRIDE;
 435
 436     void loadTimerFired(Timer<HTMLMediaElement>*);
 437     void progressEventTimerFired(Timer<HTMLMediaElement>*);
 438     void playbackProgressTimerFired(Timer<HTMLMediaElement>*);
 439     void startPlaybackProgressTimer();
 440     void startProgressEventTimer();
 441     void stopPeriodicTimers();
 442
 443     void seek(float time, ExceptionCode&);
 444     void finishSeek();
 445     void checkIfSeekNeeded();
 446     void addPlayedRange(float start, float end);
 447
 448     void scheduleTimeupdateEvent(bool periodicEvent);
 449     void scheduleEvent(const AtomicString& eventName);
 450
 451     // loading
 452     void selectMediaResource();
 453     void loadResource(const KURL&, ContentType&, const String& keySystem);
 454     void scheduleNextSourceChild();
 455     void loadNextSourceChild();
 456     void userCancelledLoad();
 457     bool havePotentialSourceChild();
 458     void noneSupported();
 459     void mediaEngineError(PassRefPtr<MediaError> err);
 460     void cancelPendingEventsAndCallbacks();
 461     void waitForSourceChange();
 462     void prepareToPlay();
 463
 464     KURL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
 465
 466     void mediaLoadingFailed(MediaPlayer::NetworkState);
 467
 468 #if ENABLE(VIDEO_TRACK)
 469     void updateActiveTextTrackCues(float);
 470     bool userIsInterestedInThisLanguage(const String&) const;
 471     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
 472
 473     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0; }
 474     void beginIgnoringTrackDisplayUpdateRequests() { ++m_ignoreTrackDisplayUpdate; }
 475     void endIgnoringTrackDisplayUpdateRequests() { ASSERT(m_ignoreTrackDisplayUpdate); --m_ignoreTrackDisplayUpdate; }
 476 #endif
 477
 478     // These "internal" functions do not check user gesture restrictions.
 479     void loadInternal();
 480     void playInternal();
 481     void pauseInternal();
 482
 483     void prepareForLoad();
 484     void allowVideoRendering();
 485
 486     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
 487     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
 488     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
 489
 490     void updateVolume();
 491     void updatePlayState();
 492     bool potentiallyPlaying() const;
 493     bool endedPlayback() const;
 494     bool stoppedDueToErrors() const;
 495     bool pausedForUserInteraction() const;
 496     bool couldPlayIfEnoughData() const;
 497
 498     float minTimeSeekable() const;
 499     float maxTimeSeekable() const;
 500
 501     // Pauses playback without changing any states or generating events
 502     void setPausedInternal(bool);
 503
 504     void setPlaybackRateInternal(float);
 505
 506     virtual void mediaCanStart();
 507
 508     void setShouldDelayLoadEvent(bool);
 509     void invalidateCachedTime();
 510     void refreshCachedTime() const;
 511
 512     bool hasMediaControls();
 513     bool createMediaControls();
 514     void configureMediaControls();
 515
 516     void prepareMediaFragmentURI();
 517     void applyMediaFragmentURI();
 518
 519     virtual void* preDispatchEventHandler(Event*);
 520
 521     void changeNetworkStateFromLoadingToIdle();
 522
 523     void removeBehaviorsRestrictionsAfterFirstUserGesture();
 524
 525 #if ENABLE(MICRODATA)
 526     virtual String itemValueText() const;
 527     virtual void setItemValueText(const String&, ExceptionCode&);
 528 #endif
 529
 530     void updateMediaController();
 531     bool isBlocked() const;
 532     bool isBlockedOnMediaController() const;
 533     bool hasCurrentSrc() const { return !m_currentSrc.isEmpty(); }
 534     bool isLiveStream() const { return movieLoadType() == MediaPlayer::LiveStream; }
 535     bool isAutoplaying() const { return m_autoplaying; }
 536
 537 #if PLATFORM(MAC)
 538     void updateDisableSleep();
 539     bool shouldDisableSleep() const;
 540 #endif
 541
 542     Timer<HTMLMediaElement> m_loadTimer;
 543     Timer<HTMLMediaElement> m_progressEventTimer;
 544     Timer<HTMLMediaElement> m_playbackProgressTimer;
 545     RefPtr<TimeRanges> m_playedTimeRanges;
 546     OwnPtr<GenericEventQueue> m_asyncEventQueue;
 547
 548     float m_playbackRate;
 549     float m_defaultPlaybackRate;
 550     bool m_webkitPreservesPitch;
 551     NetworkState m_networkState;
 552     ReadyState m_readyState;
 553     ReadyState m_readyStateMaximum;
 554     KURL m_currentSrc;
 555
 556     RefPtr<MediaError> m_error;
 557
 558     float m_volume;
 559     float m_lastSeekTime;
 560
 561     unsigned m_previousProgress;
 562     double m_previousProgressTime;
 563
 564     // The last time a timeupdate event was sent (wall clock).
 565     double m_lastTimeUpdateEventWallTime;
 566
 567     // The last time a timeupdate event was sent in movie time.
 568     float m_lastTimeUpdateEventMovieTime;
 569
 570     // Loading state.
 571     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
 572     LoadState m_loadState;
 573     RefPtr<HTMLSourceElement> m_currentSourceNode;
 574     RefPtr<Node> m_nextChildNodeToConsider;
 575
 576     OwnPtr<MediaPlayer> m_player;
 577 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
 578     RefPtr<Widget> m_proxyWidget;
 579 #endif
 580
 581     BehaviorRestrictions m_restrictions;
 582
 583     MediaPlayer::Preload m_preload;
 584
 585     DisplayMode m_displayMode;
 586
 587     // Counter incremented while processing a callback from the media player, so we can avoid
 588     // calling the media engine recursively.
 589     int m_processingMediaPlayerCallback;
 590
 591 #if ENABLE(MEDIA_SOURCE)
 592     KURL m_mediaSourceURL;
 593     SourceState m_sourceState;
 594     HashSet<String> m_sourceIDs;
 595 #endif
 596
 597     mutable float m_cachedTime;
 598     mutable double m_cachedTimeWallClockUpdateTime;
 599     mutable double m_minimumWallClockTimeToCacheMediaTime;
 600
 601     double m_fragmentStartTime;
 602     double m_fragmentEndTime;
 603
 604     typedef unsigned PendingLoadFlags;
 605     PendingLoadFlags m_pendingLoadFlags;
 606
 607     bool m_playing : 1;
 608     bool m_isWaitingUntilMediaCanStart : 1;
 609     bool m_shouldDelayLoadEvent : 1;
 610     bool m_haveFiredLoadedData : 1;
 611     bool m_inActiveDocument : 1;
 612     bool m_autoplaying : 1;
 613     bool m_muted : 1;
 614     bool m_paused : 1;
 615     bool m_seeking : 1;
 616
 617     // data has not been loaded since sending a "stalled" event
 618     bool m_sentStalledEvent : 1;
 619
 620     // time has not changed since sending an "ended" event
 621     bool m_sentEndEvent : 1;
 622
 623     bool m_pausedInternal : 1;
 624
 625     // Not all media engines provide enough information about a file to be able to
 626     // support progress events so setting m_sendProgressEvents disables them
 627     bool m_sendProgressEvents : 1;
 628
 629     bool m_isFullscreen : 1;
 630     bool m_closedCaptionsVisible : 1;
 631
 632 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
 633     bool m_needWidgetUpdate : 1;
 634 #endif
 635
 636     bool m_dispatchingCanPlayEvent : 1;
 637     bool m_loadInitiatedByUserGesture : 1;
 638     bool m_completelyLoaded : 1;
 639     bool m_havePreparedToPlay : 1;
 640     bool m_parsingInProgress : 1;
 641
 642 #if ENABLE(VIDEO_TRACK)
 643     bool m_tracksAreReady : 1;
 644     bool m_haveVisibleTextTrack : 1;
 645     float m_lastTextTrackUpdateTime;
 646
 647     RefPtr<TextTrackList> m_textTracks;
 648     Vector<RefPtr<TextTrack> > m_textTracksWhenResourceSelectionBegan;
 649
 650     CueIntervalTree m_cueTree;
 651
 652     CueList m_currentlyActiveCues;
 653     int m_ignoreTrackDisplayUpdate;
 654 #endif
 655
 656 #if ENABLE(WEB_AUDIO)
 657     // This is a weak reference, since m_audioSourceNode holds a reference to us.
 658     // The value is set just after the MediaElementAudioSourceNode is created.
 659     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
 660     MediaElementAudioSourceNode* m_audioSourceNode;
 661 #endif
 662
 663     String m_mediaGroup;
 664     friend class MediaController;
 665     RefPtr<MediaController> m_mediaController;
 666
 667 #if PLATFORM(MAC)
 668     OwnPtr<DisplaySleepDisabler> m_sleepDisabler;
 669 #endif
 670 };
 671
 672 #if ENABLE(VIDEO_TRACK)
 673 #ifndef NDEBUG
 674 // Template specializations required by PodIntervalTree in debug mode.
 675 template <>
 676 struct ValueToString<double> {
 677     static String string(const double value)
 678     {
 679         return String::number(value);
 680     }
 681 };
 682
 683 template <>
 684 struct ValueToString<TextTrackCue*> {
 685     static String string(TextTrackCue* const& cue)
 686     {
 687         return String::format("%p id=%s interval=%f-->%f cue=%s)", cue, cue->id().utf8().data(), cue->startTime(), cue->endTime(), cue->text().utf8().data());
 688     }
 689 };
 690 #endif
 691 #endif
 692
 693 inline bool isMediaElement(Node* node)
 694 {
 695     return node && node->isElementNode() && toElement(node)->isMediaElement();
 696 }
 697
 698 inline HTMLMediaElement* toMediaElement(Node* node)
 699 {
 700     ASSERT(!node || isMediaElement(node));
 701     return static_cast<HTMLMediaElement*>(node);
 702 }
 703
 704 } //namespace
 705
 706 #endif
 707 #endif