Source/WebCore/html/HTMLMediaElement.h

   1 /*
   2  * Copyright (C) 2007-2015 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #pragma once
  27
  28 #if ENABLE(VIDEO)
  29
  30 #include "HTMLElement.h"
  31 #include "ActiveDOMObject.h"
  32 #include "GenericEventQueue.h"
  33 #include "GenericTaskQueue.h"
  34 #include "HTMLMediaElementEnums.h"
  35 #include "JSDOMPromise.h"
  36 #include "MediaCanStartListener.h"
  37 #include "MediaControllerInterface.h"
  38 #include "MediaElementSession.h"
  39 #include "MediaProducer.h"
  40 #include "PageThrottler.h"
  41 #include "UserInterfaceLayoutDirection.h"
  42
  43 #if ENABLE(VIDEO_TRACK)
  44 #include "AudioTrack.h"
  45 #include "CaptionUserPreferences.h"
  46 #include "PODIntervalTree.h"
  47 #include "TextTrack.h"
  48 #include "TextTrackCue.h"
  49 #include "VTTCue.h"
  50 #include "VideoTrack.h"
  51 #endif
  52
  53 #ifndef NDEBUG
  54 #include <wtf/StringPrintStream.h>
  55 #endif
  56
  57 namespace WebCore {
  58
  59 class AudioSourceProvider;
  60 class AudioTrackList;
  61 class AudioTrackPrivate;
  62 class DOMError;
  63 class DisplaySleepDisabler;
  64 class Event;
  65 class HTMLSourceElement;
  66 class HTMLTrackElement;
  67 class InbandTextTrackPrivate;
  68 class MediaController;
  69 class MediaControls;
  70 class MediaControlsHost;
  71 class MediaElementAudioSourceNode;
  72 class MediaError;
  73 class MediaKeys;
  74 class MediaPlayer;
  75 class MediaSession;
  76 class MediaSource;
  77 class MediaStream;
  78 class RenderMedia;
  79 class ScriptExecutionContext;
  80 class SourceBuffer;
  81 class TextTrackList;
  82 class TimeRanges;
  83 class URL;
  84 class VideoPlaybackQuality;
  85 class VideoTrackList;
  86 class VideoTrackPrivate;
  87
  88 #if ENABLE(VIDEO_TRACK)
  89 typedef PODIntervalTree<MediaTime, TextTrackCue*> CueIntervalTree;
  90 typedef CueIntervalTree::IntervalType CueInterval;
  91 typedef Vector<CueInterval> CueList;
  92 #endif
  93
  94 class HTMLMediaElement
  95     : public HTMLElement
  96     , public ActiveDOMObject
  97     , public MediaControllerInterface
  98     , public MediaPlayerSupportsTypeClient
  99     , public PlatformMediaSessionClient
 100     , private MediaCanStartListener
 101     , private MediaPlayerClient
 102     , private MediaProducer
 103 #if ENABLE(VIDEO_TRACK)
 104     , private AudioTrackClient
 105     , private TextTrackClient
 106     , private VideoTrackClient
 107 #endif
 108 {
 109 public:
 110     MediaPlayer* player() const { return m_player.get(); }
 111
 112     virtual bool isVideo() const { return false; }
 113     bool hasVideo() const override { return false; }
 114     bool hasAudio() const override;
 115
 116     static HashSet<HTMLMediaElement*>& allMediaElements();
 117
 118     void rewind(double timeDelta);
 119     WEBCORE_EXPORT void returnToRealtime() override;
 120
 121     // Eventually overloaded in HTMLVideoElement
 122     bool supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenMode) const override { return false; };
 123
 124     bool supportsScanning() const override;
 125
 126     bool canSaveMediaData() const;
 127
 128     bool doesHaveAttribute(const AtomicString&, AtomicString* value = nullptr) const override;
 129
 130     WEBCORE_EXPORT PlatformMedia platformMedia() const;
 131     PlatformLayer* platformLayer() const;
 132     bool isVideoLayerInline();
 133     void setPreparedToReturnVideoLayerToInline(bool);
 134     void waitForPreparedForInlineThen(std::function<void()> completionHandler = [] { });
 135 #if PLATFORM(IOS) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
 136     void setVideoFullscreenLayer(PlatformLayer*, std::function<void()> completionHandler = [] { });
 137     PlatformLayer* videoFullscreenLayer() const { return m_videoFullscreenLayer.get(); }
 138     void setVideoFullscreenFrame(FloatRect);
 139     void setVideoFullscreenGravity(MediaPlayerEnums::VideoGravity);
 140     MediaPlayerEnums::VideoGravity videoFullscreenGravity() const { return m_videoFullscreenGravity; }
 141 #endif
 142
 143     using HTMLMediaElementEnums::DelayedActionType;
 144     void scheduleDelayedAction(DelayedActionType);
 145     void scheduleResolvePendingPlayPromises();
 146     void rejectPendingPlayPromises(DOMError&);
 147     void resolvePendingPlayPromises();
 148     void scheduleNotifyAboutPlaying();
 149     void notifyAboutPlaying();
 150
 151     MediaPlayerEnums::MovieLoadType movieLoadType() const;
 152
 153     bool inActiveDocument() const { return m_inActiveDocument; }
 154
 155     const Document* hostingDocument() const override { return &document(); }
 156
 157 // DOM API
 158 // error state
 159     MediaError* error() const;
 160
 161     void setSrc(const String&);
 162     const URL& currentSrc() const { return m_currentSrc; }
 163
 164 #if ENABLE(MEDIA_STREAM)
 165     MediaStream* srcObject() const { return m_mediaStreamSrcObject.get(); }
 166     void setSrcObject(ScriptExecutionContext&, MediaStream*);
 167 #endif
 168
 169     void setCrossOrigin(const AtomicString&);
 170     String crossOrigin() const;
 171
 172 // network state
 173     using HTMLMediaElementEnums::NetworkState;
 174     NetworkState networkState() const;
 175
 176     String preload() const;
 177     void setPreload(const String&);
 178
 179     Ref<TimeRanges> buffered() const override;
 180     void load();
 181     String canPlayType(const String& mimeType, const String& keySystem = String(), const URL& = URL()) const;
 182
 183 // ready state
 184     using HTMLMediaElementEnums::ReadyState;
 185     ReadyState readyState() const override;
 186     bool seeking() const;
 187
 188 // playback state
 189     WEBCORE_EXPORT double currentTime() const override;
 190     void setCurrentTime(double) override;
 191     virtual void setCurrentTime(double, ExceptionCode&);
 192     virtual double getStartDate() const;
 193     WEBCORE_EXPORT double duration() const override;
 194     WEBCORE_EXPORT bool paused() const override;
 195     double defaultPlaybackRate() const override;
 196     void setDefaultPlaybackRate(double) override;
 197     WEBCORE_EXPORT double playbackRate() const override;
 198     void setPlaybackRate(double) override;
 199
 200 // MediaTime versions of playback state
 201     MediaTime currentMediaTime() const;
 202     void setCurrentTime(const MediaTime&);
 203     MediaTime durationMediaTime() const;
 204     void fastSeek(const MediaTime&);
 205
 206     void updatePlaybackRate();
 207     bool webkitPreservesPitch() const;
 208     void setWebkitPreservesPitch(bool);
 209     Ref<TimeRanges> played() override;
 210     Ref<TimeRanges> seekable() const override;
 211     WEBCORE_EXPORT bool ended() const;
 212     bool autoplay() const;
 213     bool isAutoplaying() const { return m_autoplaying; }
 214     bool loop() const;
 215     void setLoop(bool b);
 216
 217     typedef DOMPromise<std::nullptr_t> PlayPromise;
 218     void play(PlayPromise&&);
 219
 220     WEBCORE_EXPORT void play() override;
 221     WEBCORE_EXPORT void pause() override;
 222     void setShouldBufferData(bool) override;
 223     void fastSeek(double);
 224     double minFastReverseRate() const;
 225     double maxFastForwardRate() const;
 226
 227     void purgeBufferedDataIfPossible();
 228
 229 // captions
 230     bool webkitHasClosedCaptions() const;
 231     bool webkitClosedCaptionsVisible() const;
 232     void setWebkitClosedCaptionsVisible(bool);
 233
 234     bool elementIsHidden() const override { return m_elementIsHidden; }
 235
 236 #if ENABLE(MEDIA_STATISTICS)
 237 // Statistics
 238     unsigned webkitAudioDecodedByteCount() const;
 239     unsigned webkitVideoDecodedByteCount() const;
 240 #endif
 241
 242 #if ENABLE(MEDIA_SOURCE)
 243 //  Media Source.
 244     void closeMediaSource();
 245     void incrementDroppedFrameCount() { ++m_droppedVideoFrames; }
 246     size_t maximumSourceBufferSize(const SourceBuffer&) const;
 247 #endif
 248
 249 #if ENABLE(ENCRYPTED_MEDIA)
 250     void webkitGenerateKeyRequest(const String& keySystem, const RefPtr<Uint8Array>& initData, ExceptionCode&);
 251     void webkitAddKey(const String& keySystem, Uint8Array& key, const RefPtr<Uint8Array>& initData, const String& sessionId, ExceptionCode&);
 252     void webkitCancelKeyRequest(const String& keySystem, const String& sessionId, ExceptionCode&);
 253 #endif
 254
 255 #if ENABLE(ENCRYPTED_MEDIA_V2)
 256     MediaKeys* keys() const { return m_mediaKeys.get(); }
 257     void setMediaKeys(MediaKeys*);
 258
 259     void keyAdded();
 260 #endif
 261
 262 // controls
 263     bool controls() const;
 264     void setControls(bool);
 265     WEBCORE_EXPORT double volume() const override;
 266     void setVolume(double, ExceptionCode&) override;
 267     WEBCORE_EXPORT bool muted() const override;
 268     WEBCORE_EXPORT void setMuted(bool) override;
 269
 270     WEBCORE_EXPORT void togglePlayState();
 271     WEBCORE_EXPORT void beginScrubbing() override;
 272     WEBCORE_EXPORT void endScrubbing() override;
 273
 274     void beginScanning(ScanDirection) override;
 275     void endScanning() override;
 276     double nextScanRate();
 277
 278     WEBCORE_EXPORT bool canPlay() const override;
 279
 280     double percentLoaded() const;
 281
 282 #if ENABLE(VIDEO_TRACK)
 283     RefPtr<TextTrack> addTextTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
 284
 285     AudioTrackList& audioTracks();
 286     TextTrackList& textTracks();
 287     VideoTrackList& videoTracks();
 288
 289     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
 290
 291     void addAudioTrack(Ref<AudioTrack>&&);
 292     void addTextTrack(Ref<TextTrack>&&);
 293     void addVideoTrack(Ref<VideoTrack>&&);
 294     void removeAudioTrack(AudioTrack&);
 295     void removeTextTrack(TextTrack&, bool scheduleEvent = true);
 296     void removeVideoTrack(VideoTrack&);
 297     void forgetResourceSpecificTracks();
 298     void closeCaptionTracksChanged();
 299     void notifyMediaPlayerOfTextTrackChanges();
 300
 301     virtual void didAddTextTrack(HTMLTrackElement*);
 302     virtual void didRemoveTextTrack(HTMLTrackElement*);
 303
 304     void mediaPlayerDidAddAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
 305     void mediaPlayerDidAddTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
 306     void mediaPlayerDidAddVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
 307     void mediaPlayerDidRemoveAudioTrack(PassRefPtr<AudioTrackPrivate>) override;
 308     void mediaPlayerDidRemoveTextTrack(PassRefPtr<InbandTextTrackPrivate>) override;
 309     void mediaPlayerDidRemoveVideoTrack(PassRefPtr<VideoTrackPrivate>) override;
 310
 311 #if ENABLE(AVF_CAPTIONS)
 312     Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources() override;
 313 #endif
 314
 315     struct TrackGroup;
 316     void configureTextTrackGroupForLanguage(const TrackGroup&) const;
 317     void configureTextTracks();
 318     void configureTextTrackGroup(const TrackGroup&);
 319
 320     void setSelectedTextTrack(TextTrack*);
 321
 322     bool textTracksAreReady() const;
 323     using HTMLMediaElementEnums::TextTrackVisibilityCheckType;
 324     void configureTextTrackDisplay(TextTrackVisibilityCheckType checkType = CheckTextTrackVisibility);
 325     void updateTextTrackDisplay();
 326
 327     // AudioTrackClient
 328     void audioTrackEnabledChanged(AudioTrack*) override;
 329
 330     // TextTrackClient
 331     virtual void textTrackReadyStateChanged(TextTrack*);
 332     void textTrackKindChanged(TextTrack*) override;
 333     void textTrackModeChanged(TextTrack*) override;
 334     void textTrackAddCues(TextTrack*, const TextTrackCueList*) override;
 335     void textTrackRemoveCues(TextTrack*, const TextTrackCueList*) override;
 336     void textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
 337     void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>) override;
 338
 339     // VideoTrackClient
 340     void videoTrackSelectedChanged(VideoTrack*) override;
 341
 342     bool requiresTextTrackRepresentation() const;
 343     void setTextTrackRepresentation(TextTrackRepresentation*);
 344     void syncTextTrackBounds();
 345 #endif
 346
 347 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
 348     void webkitShowPlaybackTargetPicker();
 349     bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
 350     bool removeEventListener(const AtomicString& eventType, EventListener&, const ListenerOptions&) override;
 351
 352     void wirelessRoutesAvailableDidChange() override;
 353     bool canPlayToWirelessPlaybackTarget() const override;
 354     bool isPlayingToWirelessPlaybackTarget() const override;
 355     void setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&&) override;
 356     void setShouldPlayToPlaybackTarget(bool) override;
 357 #endif
 358     bool webkitCurrentPlaybackTargetIsWireless() const;
 359
 360     // EventTarget function.
 361     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
 362     // causes an ambiguity error at compile time. This class's constructor
 363     // ensures that both implementations return document, so return the result
 364     // of one of them here.
 365     using HTMLElement::scriptExecutionContext;
 366
 367     bool hasSingleSecurityOrigin() const { return !m_player || m_player->hasSingleSecurityOrigin(); }
 368
 369     WEBCORE_EXPORT bool isFullscreen() const override;
 370     bool isStandardFullscreen() const;
 371     void toggleStandardFullscreenState();
 372
 373     using MediaPlayerEnums::VideoFullscreenMode;
 374     VideoFullscreenMode fullscreenMode() const { return m_videoFullscreenMode; }
 375     virtual void fullscreenModeChanged(VideoFullscreenMode);
 376
 377     void enterFullscreen(VideoFullscreenMode);
 378     void enterFullscreen() override;
 379     WEBCORE_EXPORT void exitFullscreen();
 380
 381     bool hasClosedCaptions() const override;
 382     bool closedCaptionsVisible() const override;
 383     void setClosedCaptionsVisible(bool) override;
 384
 385     MediaControls* mediaControls() const;
 386
 387     void sourceWasRemoved(HTMLSourceElement*);
 388     void sourceWasAdded(HTMLSourceElement*);
 389
 390     void privateBrowsingStateDidChange() override;
 391
 392     // Media cache management.
 393     WEBCORE_EXPORT static void setMediaCacheDirectory(const String&);
 394     WEBCORE_EXPORT static const String& mediaCacheDirectory();
 395     WEBCORE_EXPORT static HashSet<RefPtr<SecurityOrigin>> originsInMediaCache(const String&);
 396     WEBCORE_EXPORT static void clearMediaCache(const String&, std::chrono::system_clock::time_point modifiedSince = { });
 397     WEBCORE_EXPORT static void clearMediaCacheForOrigins(const String&, const HashSet<RefPtr<SecurityOrigin>>&);
 398     static void resetMediaEngines();
 399
 400     bool isPlaying() const { return m_playing; }
 401
 402     bool hasPendingActivity() const override;
 403
 404 #if ENABLE(WEB_AUDIO)
 405     MediaElementAudioSourceNode* audioSourceNode() { return m_audioSourceNode; }
 406     void setAudioSourceNode(MediaElementAudioSourceNode*);
 407
 408     AudioSourceProvider* audioSourceProvider();
 409 #endif
 410
 411     using HTMLMediaElementEnums::InvalidURLAction;
 412     bool isSafeToLoadURL(const URL&, InvalidURLAction);
 413
 414     const String& mediaGroup() const;
 415     void setMediaGroup(const String&);
 416
 417     MediaController* controller() const;
 418     void setController(PassRefPtr<MediaController>);
 419
 420     void enteredOrExitedFullscreen() { configureMediaControls(); }
 421
 422     unsigned long long fileSize() const;
 423
 424     void mediaLoadingFailed(MediaPlayerEnums::NetworkState);
 425     void mediaLoadingFailedFatally(MediaPlayerEnums::NetworkState);
 426
 427 #if ENABLE(MEDIA_SESSION)
 428     WEBCORE_EXPORT double playerVolume() const;
 429
 430     const String& kind() const { return m_kind; }
 431     void setKind(const String& kind) { m_kind = kind; }
 432
 433     MediaSession* session() const;
 434     void setSession(MediaSession*);
 435
 436     void setShouldDuck(bool);
 437
 438     static HTMLMediaElement* elementWithID(uint64_t);
 439     uint64_t elementID() const { return m_elementID; }
 440 #endif
 441
 442 #if ENABLE(MEDIA_SOURCE)
 443     RefPtr<VideoPlaybackQuality> getVideoPlaybackQuality();
 444 #endif
 445
 446     MediaPlayerEnums::Preload preloadValue() const { return m_preload; }
 447     MediaElementSession& mediaSession() const { return *m_mediaSession; }
 448
 449 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
 450     void pageScaleFactorChanged();
 451     void userInterfaceLayoutDirectionChanged();
 452     WEBCORE_EXPORT String getCurrentMediaControlsStatus();
 453 #endif
 454
 455     MediaControlsHost* mediaControlsHost() { return m_mediaControlsHost.get(); }
 456
 457     bool isDisablingSleep() const { return m_sleepDisabler.get(); }
 458
 459     double maxBufferedTime() const;
 460
 461     MediaProducer::MediaStateFlags mediaState() const override;
 462
 463     void layoutSizeChanged();
 464     void visibilityDidChange();
 465
 466     void allowsMediaDocumentInlinePlaybackChanged();
 467     void updateShouldPlay();
 468
 469     RenderMedia* renderer() const;
 470
 471 protected:
 472     HTMLMediaElement(const QualifiedName&, Document&, bool createdByParser);
 473     virtual ~HTMLMediaElement();
 474
 475     void parseAttribute(const QualifiedName&, const AtomicString&) override;
 476     void finishParsingChildren() override;
 477     bool isURLAttribute(const Attribute&) const override;
 478     void willAttachRenderers() override;
 479     void didAttachRenderers() override;
 480     void willDetachRenderers() override;
 481     void didDetachRenderers() override;
 482
 483     void didMoveToNewDocument(Document* oldDocument) override;
 484
 485     enum DisplayMode { Unknown, None, Poster, PosterWaitingForVideo, Video };
 486     DisplayMode displayMode() const { return m_displayMode; }
 487     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
 488
 489     bool isMediaElement() const final { return true; }
 490
 491 #if ENABLE(VIDEO_TRACK)
 492     bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0 || !m_textTracks || !m_cueTree.size(); }
 493     void beginIgnoringTrackDisplayUpdateRequests();
 494     void endIgnoringTrackDisplayUpdateRequests();
 495 #endif
 496
 497     RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
 498
 499 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
 500     bool mediaControlsDependOnPageScaleFactor() const { return m_mediaControlsDependOnPageScaleFactor; }
 501     void setMediaControlsDependOnPageScaleFactor(bool);
 502     void updateMediaControlsAfterPresentationModeChange();
 503 #endif
 504
 505     void scheduleEvent(const AtomicString& eventName);
 506
 507 private:
 508     void createMediaPlayer();
 509
 510     bool alwaysCreateUserAgentShadowRoot() const override { return true; }
 511
 512     bool supportsFocus() const override;
 513     bool isMouseFocusable() const override;
 514     bool rendererIsNeeded(const RenderStyle&) override;
 515     bool childShouldCreateRenderer(const Node&) const override;
 516     InsertionNotificationRequest insertedInto(ContainerNode&) override;
 517     void removedFrom(ContainerNode&) override;
 518     void didRecalcStyle(Style::Change) override;
 519
 520     void willBecomeFullscreenElement() override;
 521     void didBecomeFullscreenElement() override;
 522     void willStopBeingFullscreenElement() override;
 523
 524     // ActiveDOMObject API.
 525     const char* activeDOMObjectName() const override;
 526     bool canSuspendForDocumentSuspension() const override;
 527     void suspend(ReasonForSuspension) override;
 528     void resume() override;
 529     void stop() override;
 530     void stopWithoutDestroyingMediaPlayer();
 531     void contextDestroyed() override;
 532
 533     void mediaVolumeDidChange() override;
 534
 535     void visibilityStateChanged() override;
 536
 537     virtual void updateDisplayState() { }
 538
 539     void setReadyState(MediaPlayerEnums::ReadyState);
 540     void setNetworkState(MediaPlayerEnums::NetworkState);
 541
 542     double effectivePlaybackRate() const;
 543     double requestedPlaybackRate() const;
 544
 545     void mediaPlayerNetworkStateChanged(MediaPlayer*) override;
 546     void mediaPlayerReadyStateChanged(MediaPlayer*) override;
 547     void mediaPlayerTimeChanged(MediaPlayer*) override;
 548     void mediaPlayerVolumeChanged(MediaPlayer*) override;
 549     void mediaPlayerMuteChanged(MediaPlayer*) override;
 550     void mediaPlayerDurationChanged(MediaPlayer*) override;
 551     void mediaPlayerRateChanged(MediaPlayer*) override;
 552     void mediaPlayerPlaybackStateChanged(MediaPlayer*) override;
 553     void mediaPlayerSawUnsupportedTracks(MediaPlayer*) override;
 554     void mediaPlayerResourceNotSupported(MediaPlayer*) override;
 555     void mediaPlayerRepaint(MediaPlayer*) override;
 556     void mediaPlayerSizeChanged(MediaPlayer*) override;
 557     bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) override;
 558     void mediaPlayerRenderingModeChanged(MediaPlayer*) override;
 559     void mediaPlayerEngineUpdated(MediaPlayer*) override;
 560     void mediaEngineWasUpdated();
 561
 562     void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) override;
 563     void mediaPlayerCharacteristicChanged(MediaPlayer*) override;
 564
 565 #if ENABLE(ENCRYPTED_MEDIA)
 566     void mediaPlayerKeyAdded(MediaPlayer*, const String& keySystem, const String& sessionId) override;
 567     void mediaPlayerKeyError(MediaPlayer*, const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode) override;
 568     void mediaPlayerKeyMessage(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL) override;
 569     bool mediaPlayerKeyNeeded(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength) override;
 570 #endif
 571
 572 #if ENABLE(ENCRYPTED_MEDIA_V2)
 573     RefPtr<ArrayBuffer> mediaPlayerCachedKeyForKeyId(const String& keyId) const override;
 574     bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) override;
 575     String mediaPlayerMediaKeysStorageDirectory() const override;
 576 #endif
 577
 578 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
 579     void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) override;
 580     void enqueuePlaybackTargetAvailabilityChangedEvent();
 581
 582     using EventTarget::dispatchEvent;
 583     bool dispatchEvent(Event&) override;
 584 #endif
 585
 586 #if ENABLE(MEDIA_SESSION)
 587     void setSessionInternal(MediaSession&);
 588 #endif
 589
 590     String mediaPlayerReferrer() const override;
 591     String mediaPlayerUserAgent() const override;
 592
 593     bool mediaPlayerNeedsSiteSpecificHacks() const override;
 594     String mediaPlayerDocumentHost() const override;
 595
 596     void mediaPlayerEnterFullscreen() override;
 597     void mediaPlayerExitFullscreen() override;
 598     bool mediaPlayerIsFullscreen() const override;
 599     bool mediaPlayerIsFullscreenPermitted() const override;
 600     bool mediaPlayerIsVideo() const override;
 601     LayoutRect mediaPlayerContentBoxRect() const override;
 602     float mediaPlayerContentsScale() const override;
 603     void mediaPlayerSetSize(const IntSize&) override;
 604     void mediaPlayerPause() override;
 605     void mediaPlayerPlay() override;
 606     bool mediaPlayerPlatformVolumeConfigurationRequired() const override;
 607     bool mediaPlayerIsPaused() const override;
 608     bool mediaPlayerIsLooping() const override;
 609     CachedResourceLoader* mediaPlayerCachedResourceLoader() override;
 610     RefPtr<PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader() override;
 611     bool mediaPlayerShouldUsePersistentCache() const override;
 612     const String& mediaPlayerMediaCacheDirectory() const override;
 613
 614 #if PLATFORM(WIN) && USE(AVFOUNDATION)
 615     GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const override;
 616 #endif
 617
 618     bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) override;
 619     void mediaPlayerHandlePlaybackCommand(PlatformMediaSession::RemoteControlCommandType command) override { didReceiveRemoteControlCommand(command, nullptr); }
 620     String mediaPlayerSourceApplicationIdentifier() const override;
 621     Vector<String> mediaPlayerPreferredAudioCharacteristics() const override;
 622
 623 #if PLATFORM(IOS)
 624     String mediaPlayerNetworkInterfaceName() const override;
 625     bool mediaPlayerGetRawCookies(const URL&, Vector<Cookie>&) const override;
 626 #endif
 627
 628     bool mediaPlayerIsInMediaDocument() const final;
 629     void mediaPlayerEngineFailedToLoad() const final;
 630
 631     double mediaPlayerRequestedPlaybackRate() const final;
 632     VideoFullscreenMode mediaPlayerFullscreenMode() const final { return fullscreenMode(); }
 633
 634 #if USE(GSTREAMER)
 635     void requestInstallMissingPlugins(const String& details, const String& description, MediaPlayerRequestInstallMissingPluginsCallback&) final;
 636 #endif
 637
 638     void pendingActionTimerFired();
 639     void progressEventTimerFired();
 640     void playbackProgressTimerFired();
 641     void scanTimerFired();
 642     void seekTask();
 643     void startPlaybackProgressTimer();
 644     void startProgressEventTimer();
 645     void stopPeriodicTimers();
 646
 647     void seek(const MediaTime&);
 648     void seekInternal(const MediaTime&);
 649     void seekWithTolerance(const MediaTime&, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance, bool fromDOM);
 650     void finishSeek();
 651     void clearSeeking();
 652     void addPlayedRange(const MediaTime& start, const MediaTime& end);
 653
 654     void scheduleTimeupdateEvent(bool periodicEvent);
 655     virtual void scheduleResizeEvent() { }
 656     virtual void scheduleResizeEventIfSizeChanged() { }
 657
 658     void selectMediaResource();
 659     void loadResource(const URL&, ContentType&, const String& keySystem);
 660     void scheduleNextSourceChild();
 661     void loadNextSourceChild();
 662     void userCancelledLoad();
 663     void clearMediaPlayer(DelayedActionType flags);
 664     bool havePotentialSourceChild();
 665     void noneSupported();
 666     void cancelPendingEventsAndCallbacks();
 667     void waitForSourceChange();
 668     void prepareToPlay();
 669
 670     URL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
 671
 672 #if ENABLE(VIDEO_TRACK)
 673     void updateActiveTextTrackCues(const MediaTime&);
 674     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
 675
 676     enum ReconfigureMode {
 677         Immediately,
 678         AfterDelay,
 679     };
 680     void markCaptionAndSubtitleTracksAsUnconfigured(ReconfigureMode);
 681     void captionPreferencesChanged() override;
 682 #endif
 683
 684     // These "internal" functions do not check user gesture restrictions.
 685     void loadInternal();
 686     bool playInternal();
 687     void pauseInternal();
 688
 689     void prepareForLoad();
 690     void allowVideoRendering();
 691
 692     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
 693     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
 694     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
 695
 696     enum class UpdateState { Asynchronously, Synchronously };
 697
 698     void updatePlayState(UpdateState updateState = UpdateState::Synchronously);
 699     void updateVolume();
 700     void setPlaying(bool);
 701     bool potentiallyPlaying() const;
 702     bool endedPlayback() const;
 703     bool stoppedDueToErrors() const;
 704     bool pausedForUserInteraction() const;
 705     bool couldPlayIfEnoughData() const;
 706     bool canTransitionFromAutoplayToPlay() const;
 707
 708     MediaTime minTimeSeekable() const;
 709     MediaTime maxTimeSeekable() const;
 710
 711     // Pauses playback without changing any states or generating events
 712     void setPausedInternal(bool);
 713
 714     void setPlaybackRateInternal(double);
 715
 716     void mediaCanStart() override;
 717
 718     void setShouldDelayLoadEvent(bool);
 719     void invalidateCachedTime() const;
 720     void refreshCachedTime() const;
 721
 722     bool hasMediaControls() const;
 723     bool createMediaControls();
 724     void configureMediaControls();
 725
 726     void prepareMediaFragmentURI();
 727     void applyMediaFragmentURI();
 728
 729     void changeNetworkStateFromLoadingToIdle();
 730
 731     void removeBehaviorsRestrictionsAfterFirstUserGesture(MediaElementSession::BehaviorRestrictions mask = MediaElementSession::AllRestrictions);
 732
 733     void updateMediaController();
 734     bool isBlocked() const;
 735     bool isBlockedOnMediaController() const;
 736     bool hasCurrentSrc() const override { return !m_currentSrc.isEmpty(); }
 737     bool isLiveStream() const override { return movieLoadType() == MediaPlayerEnums::LiveStream; }
 738
 739     void updateSleepDisabling();
 740     bool shouldDisableSleep() const;
 741
 742 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
 743     void didAddUserAgentShadowRoot(ShadowRoot*) override;
 744     DOMWrapperWorld& ensureIsolatedWorld();
 745     bool ensureMediaControlsInjectedScript();
 746 #endif
 747
 748     PlatformMediaSession::MediaType mediaType() const override;
 749     PlatformMediaSession::MediaType presentationType() const override;
 750     PlatformMediaSession::DisplayType displayType() const override;
 751     PlatformMediaSession::CharacteristicsFlags characteristics() const final;
 752
 753     void suspendPlayback() override;
 754     void resumeAutoplaying() override;
 755     void mayResumePlayback(bool shouldResume) override;
 756     String mediaSessionTitle() const override;
 757     double mediaSessionDuration() const override { return duration(); }
 758     double mediaSessionCurrentTime() const override { return currentTime(); }
 759     bool canReceiveRemoteControlCommands() const override { return true; }
 760     void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType, const PlatformMediaSession::RemoteCommandArgument*) override;
 761     bool supportsSeeking() const override;
 762     bool shouldOverrideBackgroundPlaybackRestriction(PlatformMediaSession::InterruptionType) const override;
 763     bool shouldOverrideBackgroundLoadingRestriction() const override;
 764
 765     void pageMutedStateDidChange() override;
 766
 767     bool effectiveMuted() const;
 768
 769     void registerWithDocument(Document&);
 770     void unregisterWithDocument(Document&);
 771
 772     void updateCaptionContainer();
 773     void ensureMediaControlsShadowRoot();
 774
 775 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
 776     void prepareForDocumentSuspension() final;
 777     void resumeFromDocumentSuspension() final;
 778
 779     void updateMediaState(UpdateState updateState = UpdateState::Synchronously);
 780     bool hasPlaybackTargetAvailabilityListeners() const { return m_hasPlaybackTargetAvailabilityListeners; }
 781 #endif
 782
 783     bool isVideoTooSmallForInlinePlayback();
 784     void isVisibleInViewportChanged() final;
 785     void updateShouldAutoplay();
 786
 787     void pauseAfterDetachedTask();
 788     void updatePlaybackControlsManager();
 789     void scheduleUpdatePlaybackControlsManager();
 790
 791     void updateRenderer();
 792
 793     void updatePageScaleFactorJSProperty();
 794     void updateUsesLTRUserInterfaceLayoutDirectionJSProperty();
 795     void setControllerJSProperty(const char*, JSC::JSValue);
 796
 797     Timer m_pendingActionTimer;
 798     Timer m_progressEventTimer;
 799     Timer m_playbackProgressTimer;
 800     Timer m_scanTimer;
 801     GenericTaskQueue<Timer> m_seekTaskQueue;
 802     GenericTaskQueue<Timer> m_resizeTaskQueue;
 803     GenericTaskQueue<Timer> m_shadowDOMTaskQueue;
 804     GenericTaskQueue<Timer> m_promiseTaskQueue;
 805     GenericTaskQueue<Timer> m_pauseAfterDetachedTaskQueue;
 806     GenericTaskQueue<Timer> m_updatePlaybackControlsManagerQueue;
 807     RefPtr<TimeRanges> m_playedTimeRanges;
 808     GenericEventQueue m_asyncEventQueue;
 809
 810     Vector<PlayPromise> m_pendingPlayPromises;
 811
 812     double m_requestedPlaybackRate;
 813     double m_reportedPlaybackRate;
 814     double m_defaultPlaybackRate;
 815     bool m_webkitPreservesPitch;
 816     NetworkState m_networkState;
 817     ReadyState m_readyState;
 818     ReadyState m_readyStateMaximum;
 819     URL m_currentSrc;
 820
 821     RefPtr<MediaError> m_error;
 822
 823     struct PendingSeek {
 824         PendingSeek(const MediaTime& now, const MediaTime& targetTime, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance)
 825             : now(now)
 826             , targetTime(targetTime)
 827             , negativeTolerance(negativeTolerance)
 828             , positiveTolerance(positiveTolerance)
 829         {
 830         }
 831         MediaTime now;
 832         MediaTime targetTime;
 833         MediaTime negativeTolerance;
 834         MediaTime positiveTolerance;
 835     };
 836     std::unique_ptr<PendingSeek> m_pendingSeek;
 837     SeekType m_pendingSeekType { NoSeek };
 838
 839     double m_volume;
 840     bool m_volumeInitialized;
 841     MediaTime m_lastSeekTime;
 842
 843     double m_previousProgressTime;
 844
 845     // The last time a timeupdate event was sent (based on monotonic clock).
 846     double m_clockTimeAtLastUpdateEvent;
 847
 848     // The last time a timeupdate event was sent in movie time.
 849     MediaTime m_lastTimeUpdateEventMovieTime;
 850
 851     // Loading state.
 852     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
 853     LoadState m_loadState;
 854     RefPtr<HTMLSourceElement> m_currentSourceNode;
 855     RefPtr<Node> m_nextChildNodeToConsider;
 856
 857     VideoFullscreenMode m_videoFullscreenMode;
 858     bool m_preparedForInline;
 859     std::function<void()> m_preparedForInlineCompletionHandler;
 860
 861 #if PLATFORM(IOS) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
 862     RetainPtr<PlatformLayer> m_videoFullscreenLayer;
 863     FloatRect m_videoFullscreenFrame;
 864     MediaPlayerEnums::VideoGravity m_videoFullscreenGravity;
 865 #endif
 866
 867     std::unique_ptr<MediaPlayer> m_player;
 868
 869     MediaPlayerEnums::Preload m_preload;
 870
 871     DisplayMode m_displayMode;
 872
 873     // Counter incremented while processing a callback from the media player, so we can avoid
 874     // calling the media engine recursively.
 875     int m_processingMediaPlayerCallback;
 876
 877 #if ENABLE(MEDIA_SESSION)
 878     String m_kind;
 879     RefPtr<MediaSession> m_session;
 880     bool m_shouldDuck { false };
 881     uint64_t m_elementID;
 882 #endif
 883
 884 #if ENABLE(MEDIA_SOURCE)
 885     RefPtr<MediaSource> m_mediaSource;
 886     unsigned long m_droppedVideoFrames;
 887 #endif
 888
 889     mutable MediaTime m_cachedTime;
 890     mutable double m_clockTimeAtLastCachedTimeUpdate;
 891     mutable double m_minimumClockTimeToUpdateCachedTime;
 892
 893     MediaTime m_fragmentStartTime;
 894     MediaTime m_fragmentEndTime;
 895
 896     typedef unsigned PendingActionFlags;
 897     PendingActionFlags m_pendingActionFlags;
 898
 899     enum ActionAfterScanType {
 900         Nothing, Play, Pause
 901     };
 902     ActionAfterScanType m_actionAfterScan;
 903
 904     enum ScanType { Seek, Scan };
 905     ScanType m_scanType;
 906     ScanDirection m_scanDirection;
 907
 908     bool m_firstTimePlaying : 1;
 909     bool m_playing : 1;
 910     bool m_isWaitingUntilMediaCanStart : 1;
 911     bool m_shouldDelayLoadEvent : 1;
 912     bool m_haveFiredLoadedData : 1;
 913     bool m_inActiveDocument : 1;
 914     bool m_autoplaying : 1;
 915     bool m_muted : 1;
 916     bool m_explicitlyMuted : 1;
 917     bool m_initiallyMuted : 1;
 918     bool m_paused : 1;
 919     bool m_seeking : 1;
 920
 921     // data has not been loaded since sending a "stalled" event
 922     bool m_sentStalledEvent : 1;
 923
 924     // time has not changed since sending an "ended" event
 925     bool m_sentEndEvent : 1;
 926
 927     bool m_pausedInternal : 1;
 928
 929     // Not all media engines provide enough information about a file to be able to
 930     // support progress events so setting m_sendProgressEvents disables them
 931     bool m_sendProgressEvents : 1;
 932
 933     bool m_closedCaptionsVisible : 1;
 934     bool m_webkitLegacyClosedCaptionOverride : 1;
 935     bool m_completelyLoaded : 1;
 936     bool m_havePreparedToPlay : 1;
 937     bool m_parsingInProgress : 1;
 938     bool m_elementIsHidden : 1;
 939     bool m_creatingControls : 1;
 940     bool m_receivedLayoutSizeChanged : 1;
 941
 942 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
 943     bool m_mediaControlsDependOnPageScaleFactor : 1;
 944     bool m_haveSetUpCaptionContainer : 1;
 945 #endif
 946
 947 #if ENABLE(VIDEO_TRACK)
 948     bool m_tracksAreReady : 1;
 949     bool m_haveVisibleTextTrack : 1;
 950     bool m_processingPreferenceChange : 1;
 951
 952     String m_subtitleTrackLanguage;
 953     MediaTime m_lastTextTrackUpdateTime;
 954
 955     CaptionUserPreferences::CaptionDisplayMode m_captionDisplayMode;
 956
 957     RefPtr<AudioTrackList> m_audioTracks;
 958     RefPtr<TextTrackList> m_textTracks;
 959     RefPtr<VideoTrackList> m_videoTracks;
 960     Vector<RefPtr<TextTrack>> m_textTracksWhenResourceSelectionBegan;
 961
 962     CueIntervalTree m_cueTree;
 963
 964     CueList m_currentlyActiveCues;
 965     int m_ignoreTrackDisplayUpdate;
 966
 967     bool m_requireCaptionPreferencesChangedCallbacks { false };
 968 #endif
 969
 970 #if ENABLE(WEB_AUDIO)
 971     // This is a weak reference, since m_audioSourceNode holds a reference to us.
 972     // The value is set just after the MediaElementAudioSourceNode is created.
 973     // The value is cleared in MediaElementAudioSourceNode::~MediaElementAudioSourceNode().
 974     MediaElementAudioSourceNode* m_audioSourceNode;
 975 #endif
 976
 977     String m_mediaGroup;
 978     friend class MediaController;
 979     RefPtr<MediaController> m_mediaController;
 980
 981     std::unique_ptr<DisplaySleepDisabler> m_sleepDisabler;
 982
 983     friend class TrackDisplayUpdateScope;
 984
 985 #if ENABLE(ENCRYPTED_MEDIA_V2)
 986     RefPtr<MediaKeys> m_mediaKeys;
 987 #endif
 988
 989     std::unique_ptr<MediaElementSession> m_mediaSession;
 990     PageActivityAssertionToken m_activityToken;
 991     size_t m_reportedExtraMemoryCost;
 992
 993 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
 994     friend class MediaControlsHost;
 995     RefPtr<MediaControlsHost> m_mediaControlsHost;
 996     RefPtr<DOMWrapperWorld> m_isolatedWorld;
 997 #endif
 998
 999 #if ENABLE(MEDIA_STREAM)
1000     RefPtr<MediaStream> m_mediaStreamSrcObject;
1001 #endif
1002
1003 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
1004     MediaProducer::MediaStateFlags m_mediaState { MediaProducer::IsNotPlaying };
1005     bool m_hasPlaybackTargetAvailabilityListeners { false };
1006     bool m_failedToPlayToWirelessTarget { false };
1007     bool m_isPlayingToWirelessTarget { false };
1008 #endif
1009 };
1010
1011 #if ENABLE(VIDEO_TRACK)
1012 #ifndef NDEBUG
1013 // Template specialization required by PodIntervalTree in debug mode.
1014 template <>
1015 struct ValueToString<TextTrackCue*> {
1016     static String string(TextTrackCue* const& cue)
1017     {
1018         String text;
1019         if (cue->isRenderable())
1020             text = toVTTCue(cue)->text();
1021         return String::format("%p id=%s interval=%s-->%s cue=%s)", cue, cue->id().utf8().data(), toString(cue->startTime()).utf8().data(), toString(cue->endTime()).utf8().data(), text.utf8().data());
1022     }
1023 };
1024 #endif
1025 #endif
1026
1027 #ifndef NDEBUG
1028 template<>
1029 struct ValueToString<MediaTime> {
1030     static String string(const MediaTime& time)
1031     {
1032         return toString(time);
1033     }
1034 };
1035 #endif
1036
1037 } // namespace WebCore
1038
1039 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::HTMLMediaElement)
1040     static bool isType(const WebCore::Element& element) { return element.isMediaElement(); }
1041     static bool isType(const WebCore::Node& node) { return is<WebCore::Element>(node) && isType(downcast<WebCore::Element>(node)); }
1042 SPECIALIZE_TYPE_TRAITS_END()
1043
1044 #endif