Source/WebCore/html/HTMLMediaElement.h

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