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