Source/WebCore/html/HTMLMediaElement.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 HTMLMediaElement_h
  27 #define HTMLMediaElement_h
  28
  29 #if ENABLE(VIDEO)
  30 #include "HTMLElement.h"
  31 #include "ActiveDOMObject.h"
  32 #include "GenericEventQueue.h"
  33 #include "HTMLMediaSession.h"
  34 #include "MediaCanStartListener.h"
  35 #include "MediaControllerInterface.h"
  36 #include "MediaPlayer.h"
  37
  38 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
  39 #include "HTMLFrameOwnerElement.h"
  40 #include "HTMLPlugInImageElement.h"
  41 #include "MediaPlayerProxy.h"
  42 #endif
  43
  44 #if ENABLE(VIDEO_TRACK)
  45 #include "AudioTrack.h"
  46 #include "CaptionUserPreferences.h"
  47 #include "PODIntervalTree.h"
  48 #include "TextTrack.h"
  49 #include "TextTrackCue.h"
  50 #include "VideoTrack.h"
  51 #endif
  52
  53 #if ENABLE(MEDIA_STREAM)
  54 #include "MediaStream.h"
  55 #endif
  56
  57
  58 namespace WebCore {
  59
  60 #if ENABLE(WEB_AUDIO)
  61 class AudioSourceProvider;
  62 class MediaElementAudioSourceNode;
  63 #endif
  64 class Event;
  65 class HTMLSourceElement;
  66 class HTMLTrackElement;
  67 class URL;
  68 class MediaController;
  69 class MediaControls;
  70 class MediaControlsHost;
  71 class MediaError;
  72 class PageActivityAssertionToken;
  73 class TimeRanges;
  74 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
  75 class Widget;
  76 #endif
  77 #if PLATFORM(MAC)
  78 class DisplaySleepDisabler;
  79 #endif
  80 #if ENABLE(ENCRYPTED_MEDIA_V2)
  81 class MediaKeys;
  82 #endif
  83 #if ENABLE(MEDIA_SOURCE)
  84 class VideoPlaybackQuality;
  85 #endif
  86
  87 #if ENABLE(VIDEO_TRACK)
  88 class AudioTrackList;
  89 class AudioTrackPrivate;
  90 class InbandTextTrackPrivate;
  91 class TextTrackList;
  92 class VideoTrackList;
  93 class VideoTrackPrivate;
  94
  95 typedef PODIntervalTree<double, TextTrackCue*> CueIntervalTree;
  96 typedef CueIntervalTree::IntervalType CueInterval;
  97 typedef Vector<CueInterval> CueList;
  98 #endif
  99
 100 class HTMLMediaElement
 101 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
 102     : public HTMLFrameOwnerElement
 103 #else
 104     : public HTMLElement
 105 #endif
 106     , private MediaPlayerClient, public MediaPlayerSupportsTypeClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface , public MediaSessionClient
 107 #if ENABLE(VIDEO_TRACK)
 108     , private AudioTrackClient
 109     , private TextTrackClient
 110     , private VideoTrackClient
 111 #endif
 112 #if USE(PLATFORM_TEXT_TRACK_MENU)
 113     , public PlatformTextTrackMenuClient
 114 #endif
 115 {
 116 public:
 117     MediaPlayer* player() const { return m_player.get(); }
 118
 119     virtual bool isVideo() const { return false; }
 120     virtual bool hasVideo() const override { return false; }
 121     virtual bool hasAudio() const override;
 122
 123     void rewind(double timeDelta);
 124     virtual void returnToRealtime() override;
 125
 126     // Eventually overloaded in HTMLVideoElement
 127     virtual bool supportsFullscreen() const override { return false; };
 128
 129     virtual bool supportsSave() const;
 130     virtual bool supportsScanning() const override;
 131
 132     PlatformMedia platformMedia() const;
 133 #if USE(ACCELERATED_COMPOSITING)
 134     PlatformLayer* platformLayer() const;
 135 #if PLATFORM(IOS)
 136     PlatformLayer* borrowPlatformLayer();
 137     void returnPlatformLayer(PlatformLayer*);
 138 #endif
 139 #endif
 140
 141     enum DelayedActionType {
 142         LoadMediaResource = 1 << 0,
 143         ConfigureTextTracks = 1 << 1,
 144         TextTrackChangesNotification = 1 << 2,
 145         ConfigureTextTrackDisplay = 1 << 3,
 146     };
 147     void scheduleDelayedAction(DelayedActionType);
 148
 149     MediaPlayer::MovieLoadType movieLoadType() const;
 150
 151     bool inActiveDocument() const { return m_inActiveDocument; }
 152
 153 // DOM API
 154 // error state
 155     PassRefPtr<MediaError> error() const;
 156
 157     void setSrc(const String&);
 158     const URL& currentSrc() const { return m_currentSrc; }
 159
 160 #if ENABLE(MEDIA_STREAM)
 161     MediaStream* srcObject() const { return m_mediaStreamSrcObject.get(); }
 162     void setSrcObject(MediaStream*);
 163 #endif
 164
 165 // network state
 166     enum NetworkState { NETWORK_EMPTY, NETWORK_IDLE, NETWORK_LOADING, NETWORK_NO_SOURCE };
 167     NetworkState networkState() const;
 168
 169     String preload() const;
 170     void setPreload(const String&);
 171
 172     virtual PassRefPtr<TimeRanges> buffered() const override;
 173     void load();
 174     String canPlayType(const String& mimeType, const String& keySystem = String(), const URL& = URL()) const;
 175
 176 // ready state
 177     virtual ReadyState readyState() const override;
 178     bool seeking() const;
 179
 180 // playback state
 181     virtual double currentTime() const override;
 182     virtual void setCurrentTime(double) override;
 183     virtual double duration() const override;
 184     virtual bool paused() const override;
 185     virtual double defaultPlaybackRate() const override;
 186     virtual void setDefaultPlaybackRate(double) override;
 187     virtual double playbackRate() const override;
 188     virtual void setPlaybackRate(double) override;
 189     void updatePlaybackRate();
 190     bool webkitPreservesPitch() const;
 191     void setWebkitPreservesPitch(bool);
 192     virtual PassRefPtr<TimeRanges> played() override;
 193     virtual PassRefPtr<TimeRanges> seekable() const override;
 194     bool ended() const;
 195     bool autoplay() const;
 196     bool loop() const;
 197     void setLoop(bool b);
 198     virtual void play() override;
 199     virtual void pause() override;
 200     void fastSeek(double);
 201
 202 // captions
 203     bool webkitHasClosedCaptions() const;
 204     bool webkitClosedCaptionsVisible() const;
 205     void setWebkitClosedCaptionsVisible(bool);
 206
 207 #if ENABLE(MEDIA_STATISTICS)
 208 // Statistics
 209     unsigned webkitAudioDecodedByteCount() const;
 210     unsigned webkitVideoDecodedByteCount() const;
 211 #endif
 212
 213 #if ENABLE(MEDIA_SOURCE)
 214 //  Media Source.
 215     void closeMediaSource();
 216     void incrementDroppedFrameCount() { ++m_droppedVideoFrames; }
 217 #endif
 218
 219 #if ENABLE(ENCRYPTED_MEDIA)
 220     void webkitGenerateKeyRequest(const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionCode&);
 221     void webkitGenerateKeyRequest(const String& keySystem, ExceptionCode&);
 222     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initData, const String& sessionId, ExceptionCode&);
 223     void webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, ExceptionCode&);
 224     void webkitCancelKeyRequest(const String& keySystem, const String& sessionId, ExceptionCode&);
 225
 226     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyadded);
 227     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyerror);
 228     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeymessage);
 229 #endif
 230 #if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
 231     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitneedkey);
 232 #endif
 233
 234 #if ENABLE(ENCRYPTED_MEDIA_V2)
 235     MediaKeys* keys() const { return m_mediaKeys.get(); }
 236     void setMediaKeys(MediaKeys*);
 237 #endif
 238
 239 // controls
 240     bool controls() const;
 241     void setControls(bool);
 242     virtual double volume() const override;
 243     virtual void setVolume(double, ExceptionCode&) override;
 244     virtual bool muted() const override;
 245     virtual void setMuted(bool) override;
 246
 247     void togglePlayState();
 248     virtual void beginScrubbing() override;
 249     virtual void endScrubbing() override;
 250
 251     virtual bool canPlay() const override;
 252
 253     double percentLoaded() const;
 254
 255 #if ENABLE(VIDEO_TRACK)
 256     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
 257     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, ExceptionCode& ec) { return addTextTrack(kind, label, emptyString(), ec); }
 258     PassRefPtr<TextTrack> addTextTrack(const String& kind, ExceptionCode& ec) { return addTextTrack(kind, emptyString(), emptyString(), ec); }
 259
 260     AudioTrackList* audioTracks();
 261     TextTrackList* textTracks();
 262     VideoTrackList* videoTracks();
 263
 264     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
 265
 266     void addAudioTrack(PassRefPtr<AudioTrack>);
 267     void addTextTrack(PassRefPtr<TextTrack>);
 268     void addVideoTrack(PassRefPtr<VideoTrack>);
 269     void removeAudioTrack(AudioTrack*);
 270     void removeTextTrack(TextTrack*);
 271     void removeVideoTrack(VideoTrack*);
 272     void removeAllInbandTracks();
 273     void closeCaptionTracksChanged();
 274     void notifyMediaPlayerOfTextTrackChanges();
 275
 276     virtual void didAddTextTrack(HTMLTrackElement*);
 277     virtual void didRemoveTextTrack(HTMLTrackElement*);
 278
 279     virtual void mediaPlayerDidAddAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
 280     virtual void mediaPlayerDidAddTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
 281     virtual void mediaPlayerDidAddVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
 282     virtual void mediaPlayerDidRemoveAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
 283     virtual void mediaPlayerDidRemoveTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
 284     virtual void mediaPlayerDidRemoveVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
 285
 286 #if USE(PLATFORM_TEXT_TRACK_MENU)
 287     virtual void setSelectedTextTrack(PassRefPtr<PlatformTextTrack>) override;
 288     virtual Vector<RefPtr<PlatformTextTrack>> platformTextTracks() override;
 289     PlatformTextTrackMenuInterface* platformTextTrackMenu();
 290 #endif
 291
 292     struct TrackGroup {
 293         enum GroupKind { CaptionsAndSubtitles, Description, Chapter, Metadata, Other };
 294
 295         TrackGroup(GroupKind kind)
 296             : visibleTrack(0)
 297             , defaultTrack(0)
 298             , kind(kind)
 299             , hasSrcLang(false)
 300         {
 301         }
 302
 303         Vector<RefPtr<TextTrack>> tracks;
 304         RefPtr<TextTrack> visibleTrack;
 305         RefPtr<TextTrack> defaultTrack;
 306         GroupKind kind;
 307         bool hasSrcLang;
 308     };
 309
 310     void configureTextTrackGroupForLanguage(const TrackGroup&) const;
 311     void configureTextTracks();
 312     void configureTextTrackGroup(const TrackGroup&);
 313
 314     void setSelectedTextTrack(TextTrack*);
 315
 316     bool textTracksAreReady() const;
 317     enum TextTrackVisibilityCheckType { CheckTextTrackVisibility, AssumeTextTrackVisibilityChanged };
 318     void configureTextTrackDisplay(TextTrackVisibilityCheckType checkType = CheckTextTrackVisibility);
 319     void updateTextTrackDisplay();
 320
 321     // AudioTrackClient
 322     virtual void audioTrackEnabledChanged(AudioTrack*) override;
 323
 324     // TextTrackClient
 325     virtual void textTrackReadyStateChanged(TextTrack*);
 326     virtual void textTrackKindChanged(TextTrack*) override;
 327     virtual void textTrackModeChanged(TextTrack*) override;
 328     virtual void textTrackAddCues(TextTrack*, const TextTrackCueList*) override;
 329     virtual void textTrackRemoveCues(TextTrack*, const TextTrackCueList*) override;
 330     virtual void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
 331     virtual void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
 332
 333     // VideoTrackClient
 334     virtual void videoTrackSelectedChanged(VideoTrack*) override;
 335
 336     bool requiresTextTrackRepresentation() const;
 337     void setTextTrackRepresentation(TextTrackRepresentation*);
 338 #endif
 339
 340 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
 341     void ensureMediaPlayer();
 342     void setNeedWidgetUpdate(bool needWidgetUpdate) { m_needWidgetUpdate = needWidgetUpdate; }
 343     void deliverNotification(MediaPlayerProxyNotificationType notification);
 344     void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
 345     void getPluginProxyParams(URL& url, Vector<String>& names, Vector<String>& values);
 346     void createMediaPlayerProxy();
 347     void updateWidget(PluginCreationOption);
 348 #endif
 349
 350 #if ENABLE(IOS_AIRPLAY)
 351     void webkitShowPlaybackTargetPicker();
 352     bool webkitCurrentPlaybackTargetIsWireless() const;
 353
 354     virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture) override;
 355     virtual bool removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture) override;
 356
 357     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitcurrentplaybacktargetiswirelesschanged);
 358     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitplaybacktargetavailabilitychanged);
 359 #endif
 360
 361     // EventTarget function.
 362     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
 363     // causes an ambiguity error at compile time. This class's constructor
 364     // ensures that both implementations return document, so return the result
 365     // of one of them here.
 366     using HTMLElement::scriptExecutionContext;
 367
 368     bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
 369
 370     virtual bool isFullscreen() const override;
 371     void toggleFullscreenState();
 372     virtual void enterFullscreen() override;
 373     void exitFullscreen();
 374
 375     virtual bool hasClosedCaptions() const override;
 376     virtual bool closedCaptionsVisible() const override;
 377     virtual void setClosedCaptionsVisible(bool) override;
 378
 379     MediaControls* mediaControls() const;
 380
 381     void sourceWasRemoved(HTMLSourceElement*);
 382     void sourceWasAdded(HTMLSourceElement*);
 383
 384     virtual void privateBrowsingStateDidChange() override;
 385
 386     // Media cache management.
 387     static void getSitesInMediaCache(Vector<String>&);
 388     static void clearMediaCache();
 389     static void clearMediaCacheForSite(const String&);
 390     static void resetMediaEngines();
 391
 392     bool isPlaying() const { return m_playing; }
 393
 394     virtual bool hasPendingActivity() const override;
 395
 396 #if ENABLE(WEB_AUDIO)
 397     MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
 398     void setAudioSourceNode(MediaElementAudioSourceNode*);
 399
 400     AudioSourceProvider* audioSourceProvider();
 401 #endif
 402
 403     enum InvalidURLAction { DoNothing, Complain };
 404     bool isSafeToLoadURL(const URL&, InvalidURLAction);
 405
 406     const String& mediaGroup() const;
 407     void setMediaGroup(const String&);
 408
 409     MediaController* controller() const;
 410     void setController(PassRefPtr<MediaController>);
 411
 412 #if !PLATFORM(IOS)
 413     virtual bool willRespondToMouseClickEvents() override;
 414 #endif
 415
 416     void enteredOrExitedFullscreen() { configureMediaControls(); }
 417
 418 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
 419     bool shouldUseVideoPluginProxy() const;
 420 #endif
 421
 422     unsigned long long fileSize() const;
 423
 424     void mediaLoadingFailed(MediaPlayer::NetworkState);
 425     void mediaLoadingFailedFatally(MediaPlayer::NetworkState);
 426
 427 #if ENABLE(MEDIA_SOURCE)
 428     RefPtr<VideoPlaybackQuality> getVideoPlaybackQuality();
 429 #endif
 430
 431     MediaPlayer::Preload preloadValue() const { return m_preload; }
 432
 433 protected:
 434     HTMLMediaElement(const QualifiedName&, Document&, bool);
 435     virtual ~HTMLMediaElement();
 436
 437     virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;
 438     virtual void finishParsingChildren() override;
 439     virtual bool isURLAttribute(const Attribute&) const override;
 440     virtual void willAttachRenderers() override;
 441     virtual void didAttachRenderers() override;
 442
 443     virtual void didMoveToNewDocument(Document* oldDocument) override;
 444
 445     enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
 446     DisplayMode displayMode() const { return m_displayMode; }
 447     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
 448
 449     virtual bool isMediaElement() const override { return true; }
 450
 451 #if ENABLE(VIDEO_TRACK)
 452     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0 || !m_textTracks || !m_cueTree.size(); }
 453     void beginIgnoringTrackDisplayUpdateRequests();
 454     void endIgnoringTrackDisplayUpdateRequests();
 455 #endif
 456
 457     virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) override;
 458
 459     HTMLMediaSession& mediaSession() const { return *m_mediaSession; }
 460
 461 private:
 462     void createMediaPlayer();
 463
 464     virtual bool alwaysCreateUserAgentShadowRoot() const override { return true; }
 465     virtual bool areAuthorShadowsAllowed() const override { return false; }
 466
 467     virtual bool hasCustomFocusLogic() const override;
 468     virtual bool supportsFocus() const override;
 469     virtual bool isMouseFocusable() const override;
 470     virtual bool rendererIsNeeded(const RenderStyle&) override;
 471     virtual bool childShouldCreateRenderer(const Node&) const override;
 472     virtual InsertionNotificationRequest insertedInto(ContainerNode&) override;
 473     virtual void removedFrom(ContainerNode&) override;
 474     virtual void didRecalcStyle(Style::Change) override;
 475
 476     virtual void defaultEventHandler(Event*) override;
 477
 478     virtual void didBecomeFullscreenElement() override;
 479     virtual void willStopBeingFullscreenElement() override;
 480
 481     // ActiveDOMObject functions.
 482     virtual bool canSuspend() const override;
 483     virtual void suspend(ReasonForSuspension) override;
 484     virtual void resume() override;
 485     virtual void stop() override;
 486
 487     virtual void mediaVolumeDidChange() override;
 488
 489 #if ENABLE(PAGE_VISIBILITY_API)
 490     virtual void visibilityStateChanged() override;
 491 #endif
 492
 493     virtual void updateDisplayState() { }
 494
 495     void setReadyState(MediaPlayer::ReadyState);
 496     void setNetworkState(MediaPlayer::NetworkState);
 497
 498     virtual Document* mediaPlayerOwningDocument() override;
 499     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*) override;
 500     virtual void mediaPlayerReadyStateChanged(MediaPlayer*) override;
 501     virtual void mediaPlayerTimeChanged(MediaPlayer*) override;
 502     virtual void mediaPlayerVolumeChanged(MediaPlayer*) override;
 503     virtual void mediaPlayerMuteChanged(MediaPlayer*) override;
 504     virtual void mediaPlayerDurationChanged(MediaPlayer*) override;
 505     virtual void mediaPlayerRateChanged(MediaPlayer*) override;
 506     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*) override;
 507     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*) override;
 508     virtual void mediaPlayerResourceNotSupported(MediaPlayer*) override;
 509     virtual void mediaPlayerRepaint(MediaPlayer*) override;
 510     virtual void mediaPlayerSizeChanged(MediaPlayer*) override;
 511 #if USE(ACCELERATED_COMPOSITING)
 512     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) override;
 513     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) override;
 514 #endif
 515     virtual void mediaPlayerEngineUpdated(MediaPlayer*) override;
 516
 517     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) override;
 518     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) override;
 519
 520 #if ENABLE(ENCRYPTED_MEDIA)
 521     virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& keySystem, const String& sessionId) override;
 522     virtual void mediaPlayerKeyError(MediaPlayer*, const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode) override;
 523     virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL) override;
 524     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength) override;
 525 #endif
 526
 527 #if ENABLE(ENCRYPTED_MEDIA_V2)
 528     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) override;
 529 #endif
 530
 531 #if ENABLE(IOS_AIRPLAY)
 532     virtual void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) override;
 533     virtual void mediaPlayerPlaybackTargetAvailabilityChanged(MediaPlayer*) override;
 534     void enqueuePlaybackTargetAvailabilityChangedEvent();
 535 #endif
 536
 537     virtual String mediaPlayerReferrer() const override;
 538     virtual String mediaPlayerUserAgent() const override;
 539     virtual CORSMode mediaPlayerCORSMode() const override;
 540
 541     virtual bool mediaPlayerNeedsSiteSpecificHacks() const override;
 542     virtual String mediaPlayerDocumentHost() const override;
 543
 544     virtual void mediaPlayerEnterFullscreen() override;
 545     virtual void mediaPlayerExitFullscreen() override;
 546     virtual bool mediaPlayerIsFullscreen() const override;
 547     virtual bool mediaPlayerIsFullscreenPermitted() const override;
 548     virtual bool mediaPlayerIsVideo() const override;
 549     virtual LayoutRect mediaPlayerContentBoxRect() const override;
 550     virtual void mediaPlayerSetSize(const IntSize&) override;
 551     virtual void mediaPlayerPause() override;
 552     virtual void mediaPlayerPlay() override;
 553     virtual bool mediaPlayerPlatformVolumeConfigurationRequired() const override;
 554     virtual bool mediaPlayerIsPaused() const override;
 555     virtual bool mediaPlayerIsLooping() const override;
 556     virtual HostWindow* mediaPlayerHostWindow() override;
 557     virtual IntRect mediaPlayerWindowClipRect() override;
 558     virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() override;
 559
 560 #if PLATFORM(WIN) && USE(AVFOUNDATION)
 561     virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const override;
 562 #endif
 563
 564     virtual bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) override;
 565
 566     void loadTimerFired(Timer<HTMLMediaElement>&);
 567     void progressEventTimerFired(Timer<HTMLMediaElement>&);
 568     void playbackProgressTimerFired(Timer<HTMLMediaElement>&);
 569     void startPlaybackProgressTimer();
 570     void startProgressEventTimer();
 571     void stopPeriodicTimers();
 572
 573     void seek(double time);
 574     void seekWithTolerance(double time, double negativeTolerance, double positiveTolerance);
 575     void finishSeek();
 576     void checkIfSeekNeeded();
 577     void addPlayedRange(double start, double end);
 578
 579     void scheduleTimeupdateEvent(bool periodicEvent);
 580     void scheduleEvent(const AtomicString& eventName);
 581
 582     // loading
 583     void selectMediaResource();
 584     void loadResource(const URL&, ContentType&, const String& keySystem);
 585     void scheduleNextSourceChild();
 586     void loadNextSourceChild();
 587     void userCancelledLoad();
 588     void clearMediaPlayer(int flags);
 589     bool havePotentialSourceChild();
 590     void noneSupported();
 591     void cancelPendingEventsAndCallbacks();
 592     void waitForSourceChange();
 593     void prepareToPlay();
 594
 595     URL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
 596
 597 #if ENABLE(VIDEO_TRACK)
 598     void updateActiveTextTrackCues(double);
 599     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
 600
 601     enum ReconfigureMode {
 602         Immediately,
 603         AfterDelay,
 604     };
 605     void markCaptionAndSubtitleTracksAsUnconfigured(ReconfigureMode);
 606     virtual void captionPreferencesChanged() override;
 607 #endif
 608
 609     // These "internal" functions do not check user gesture restrictions.
 610     void loadInternal();
 611     void playInternal();
 612     void pauseInternal();
 613
 614     void prepareForLoad();
 615     void allowVideoRendering();
 616
 617     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
 618     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
 619     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
 620
 621     void updateVolume();
 622     void updatePlayState();
 623     bool potentiallyPlaying() const;
 624     bool endedPlayback() const;
 625     bool stoppedDueToErrors() const;
 626     bool pausedForUserInteraction() const;
 627     bool couldPlayIfEnoughData() const;
 628
 629     double minTimeSeekable() const;
 630     double maxTimeSeekable() const;
 631
 632 #if PLATFORM(IOS)
 633     bool parseMediaPlayerAttribute(const QualifiedName&, const AtomicString&);
 634 #endif
 635
 636     // Pauses playback without changing any states or generating events
 637     void setPausedInternal(bool);
 638
 639     void setPlaybackRateInternal(double);
 640
 641     virtual void mediaCanStart() override;
 642
 643     void setShouldDelayLoadEvent(bool);
 644     void invalidateCachedTime();
 645     void refreshCachedTime() const;
 646
 647     bool hasMediaControls() const;
 648     bool createMediaControls();
 649     void configureMediaControls();
 650
 651     void prepareMediaFragmentURI();
 652     void applyMediaFragmentURI();
 653
 654     void changeNetworkStateFromLoadingToIdle();
 655
 656     void removeBehaviorsRestrictionsAfterFirstUserGesture();
 657
 658     void updateMediaController();
 659     bool isBlocked() const;
 660     bool isBlockedOnMediaController() const;
 661     virtual bool hasCurrentSrc() const override { return !m_currentSrc.isEmpty(); }
 662     virtual bool isLiveStream() const override { return movieLoadType() == MediaPlayer::LiveStream; }
 663     bool isAutoplaying() const { return m_autoplaying; }
 664
 665     void updateSleepDisabling();
 666 #if PLATFORM(MAC)
 667     bool shouldDisableSleep() const;
 668 #endif
 669
 670 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
 671     virtual void didAddUserAgentShadowRoot(ShadowRoot*) override;
 672     DOMWrapperWorld& ensureIsolatedWorld();
 673     bool ensureMediaControlsInjectedScript();
 674 #endif
 675
 676     virtual MediaSession::MediaType mediaType() const override;
 677
 678     virtual void beginInterruption() override;
 679     virtual void endInterruption(MediaSession::EndInterruptionFlags) override;
 680     virtual void pausePlayback() override;
 681
 682     Timer<HTMLMediaElement> m_loadTimer;
 683     Timer<HTMLMediaElement> m_progressEventTimer;
 684     Timer<HTMLMediaElement> m_playbackProgressTimer;
 685     RefPtr<TimeRanges> m_playedTimeRanges;
 686     GenericEventQueue m_asyncEventQueue;
 687
 688     double m_playbackRate;
 689     double m_defaultPlaybackRate;
 690     bool m_webkitPreservesPitch;
 691     NetworkState m_networkState;
 692     ReadyState m_readyState;
 693     ReadyState m_readyStateMaximum;
 694     URL m_currentSrc;
 695
 696     RefPtr<MediaError> m_error;
 697
 698     double m_volume;
 699     bool m_volumeInitialized;
 700     double m_lastSeekTime;
 701
 702     unsigned m_previousProgress;
 703     double m_previousProgressTime;
 704
 705     // The last time a timeupdate event was sent (based on monotonic clock).
 706     double m_clockTimeAtLastUpdateEvent;
 707
 708     // The last time a timeupdate event was sent in movie time.
 709     double m_lastTimeUpdateEventMovieTime;
 710
 711     // Loading state.
 712     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
 713     LoadState m_loadState;
 714     RefPtr<HTMLSourceElement> m_currentSourceNode;
 715     RefPtr<Node> m_nextChildNodeToConsider;
 716
 717     OwnPtr<MediaPlayer> m_player;
 718 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
 719     RefPtr<Widget> m_proxyWidget;
 720 #endif
 721
 722     MediaPlayer::Preload m_preload;
 723
 724     DisplayMode m_displayMode;
 725
 726     // Counter incremented while processing a callback from the media player, so we can avoid
 727     // calling the media engine recursively.
 728     int m_processingMediaPlayerCallback;
 729
 730 #if ENABLE(MEDIA_SOURCE)
 731     RefPtr<HTMLMediaSource> m_mediaSource;
 732     unsigned long m_droppedVideoFrames;
 733 #endif
 734
 735     mutable double m_cachedTime;
 736     mutable double m_clockTimeAtLastCachedTimeUpdate;
 737     mutable double m_minimumClockTimeToUpdateCachedTime;
 738
 739     double m_fragmentStartTime;
 740     double m_fragmentEndTime;
 741
 742     typedef unsigned PendingActionFlags;
 743     PendingActionFlags m_pendingActionFlags;
 744
 745     bool m_playing : 1;
 746     bool m_isWaitingUntilMediaCanStart : 1;
 747     bool m_shouldDelayLoadEvent : 1;
 748     bool m_haveFiredLoadedData : 1;
 749     bool m_inActiveDocument : 1;
 750     bool m_autoplaying : 1;
 751     bool m_muted : 1;
 752     bool m_explicitlyMuted : 1;
 753     bool m_paused : 1;
 754     bool m_seeking : 1;
 755
 756     // data has not been loaded since sending a "stalled" event
 757     bool m_sentStalledEvent : 1;
 758
 759     // time has not changed since sending an "ended" event
 760     bool m_sentEndEvent : 1;
 761
 762     bool m_pausedInternal : 1;
 763
 764     // Not all media engines provide enough information about a file to be able to
 765     // support progress events so setting m_sendProgressEvents disables them
 766     bool m_sendProgressEvents : 1;
 767
 768     bool m_isFullscreen : 1;
 769     bool m_closedCaptionsVisible : 1;
 770     bool m_webkitLegacyClosedCaptionOverride : 1;
 771
 772 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
 773     bool m_needWidgetUpdate : 1;
 774 #endif
 775
 776     bool m_completelyLoaded : 1;
 777     bool m_havePreparedToPlay : 1;
 778     bool m_parsingInProgress : 1;
 779 #if ENABLE(PAGE_VISIBILITY_API)
 780     bool m_isDisplaySleepDisablingSuspended : 1;
 781 #endif
 782
 783 #if PLATFORM(IOS)
 784     bool m_requestingPlay : 1;
 785     bool m_platformLayerBorrowed : 1;
 786 #endif
 787
 788     bool m_resumePlaybackAfterInterruption : 1;
 789
 790 #if ENABLE(VIDEO_TRACK)
 791     bool m_tracksAreReady : 1;
 792     bool m_haveVisibleTextTrack : 1;
 793     bool m_processingPreferenceChange : 1;
 794
 795     String m_subtitleTrackLanguage;
 796     float m_lastTextTrackUpdateTime;
 797
 798     CaptionUserPreferences::CaptionDisplayMode m_captionDisplayMode;
 799
 800     RefPtr<AudioTrackList> m_audioTracks;
 801     RefPtr<TextTrackList> m_textTracks;
 802     RefPtr<VideoTrackList> m_videoTracks;
 803     Vector<RefPtr<TextTrack>> m_textTracksWhenResourceSelectionBegan;
 804
 805     CueIntervalTree m_cueTree;
 806
 807     CueList m_currentlyActiveCues;
 808     int m_ignoreTrackDisplayUpdate;
 809 #endif
 810
 811 #if ENABLE(WEB_AUDIO)
 812     // This is a weak reference, since m_audioSourceNode holds a reference to us.
 813     // The value is set just after the MediaElementAudioSourceNode is created.
 814     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
 815     MediaElementAudioSourceNode* m_audioSourceNode;
 816 #endif
 817
 818     String m_mediaGroup;
 819     friend class MediaController;
 820     RefPtr<MediaController> m_mediaController;
 821
 822 #if PLATFORM(MAC)
 823     OwnPtr<DisplaySleepDisabler> m_sleepDisabler;
 824 #endif
 825
 826     friend class TrackDisplayUpdateScope;
 827
 828 #if ENABLE(ENCRYPTED_MEDIA_V2)
 829     RefPtr<MediaKeys> m_mediaKeys;
 830 #endif
 831
 832 #if USE(PLATFORM_TEXT_TRACK_MENU)
 833     RefPtr<PlatformTextTrackMenuInterface> m_platformMenu;
 834 #endif
 835
 836     std::unique_ptr<HTMLMediaSession> m_mediaSession;
 837     std::unique_ptr<PageActivityAssertionToken> m_activityToken;
 838     size_t m_reportedExtraMemoryCost;
 839
 840 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
 841     RefPtr<MediaControlsHost> m_mediaControlsHost;
 842     RefPtr<DOMWrapperWorld> m_isolatedWorld;
 843 #endif
 844
 845 #if ENABLE(MEDIA_STREAM)
 846     RefPtr<MediaStream> m_mediaStreamSrcObject;
 847 #endif
 848 };
 849
 850 #if ENABLE(VIDEO_TRACK)
 851 #ifndef NDEBUG
 852 // Template specialization required by PodIntervalTree in debug mode.
 853 template <>
 854 struct ValueToString<TextTrackCue*> {
 855     static String string(TextTrackCue* const& cue)
 856     {
 857         return String::format("%p id=%s interval=%f-->%f cue=%s)", cue, cue->id().utf8().data(), cue->startTime(), cue->endTime(), cue->text().utf8().data());
 858     }
 859 };
 860 #endif
 861 #endif
 862
 863 void isHTMLMediaElement(const HTMLMediaElement&); // Catch unnecessary runtime check of type known at compile time.
 864 inline bool isHTMLMediaElement(const Element& element) { return element.isMediaElement(); }
 865 inline bool isHTMLMediaElement(const Node& node) { return node.isElementNode() && toElement(node).isMediaElement(); }
 866 template <> inline bool isElementOfType<const HTMLMediaElement>(const Element& element) { return element.isMediaElement(); }
 867
 868 NODE_TYPE_CASTS(HTMLMediaElement)
 869
 870 } //namespace
 871
 872 #endif
 873 #endif