Changeset 184966 in webkit


Ignore:
Timestamp:
May 28, 2015 4:03:34 PM (9 years ago)
Author:
commit-queue@webkit.org
Message:

Rename HTMLMediaSession to MediaElementSession to reserve "media session" for the Media Session API.
https://bugs.webkit.org/show_bug.cgi?id=145440

Patch by Matt Rajca <mrajca@apple.com> on 2015-05-28
Reviewed by Eric Carlson.

  • CMakeLists.txt:
  • WebCore.vcxproj/WebCore.vcxproj:
  • WebCore.vcxproj/WebCore.vcxproj.filters:
  • WebCore.xcodeproj/project.pbxproj:
  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::HTMLMediaElement):
(WebCore::HTMLMediaElement::loadInternal):
(WebCore::HTMLMediaElement::loadResource):
(WebCore::HTMLMediaElement::suspend):
(WebCore::HTMLMediaElement::resume):
(WebCore::HTMLMediaElement::removeBehaviorsRestrictionsAfterFirstUserGesture):
(WebCore::HTMLMediaElement::mediaState):

  • html/HTMLMediaElement.h:

(WebCore::HTMLMediaElement::mediaSession):

  • html/MediaElementSession.cpp: Renamed from Source/WebCore/html/HTMLMediaSession.cpp.

(WebCore::restrictionName):
(WebCore::MediaElementSession::MediaElementSession):
(WebCore::MediaElementSession::registerWithDocument):
(WebCore::MediaElementSession::unregisterWithDocument):
(WebCore::MediaElementSession::addBehaviorRestriction):
(WebCore::MediaElementSession::removeBehaviorRestriction):
(WebCore::MediaElementSession::playbackPermitted):
(WebCore::MediaElementSession::dataLoadingPermitted):
(WebCore::MediaElementSession::fullscreenPermitted):
(WebCore::MediaElementSession::pageAllowsDataLoading):
(WebCore::MediaElementSession::pageAllowsPlaybackAfterResuming):
(WebCore::MediaElementSession::showPlaybackTargetPicker):
(WebCore::MediaElementSession::hasWirelessPlaybackTargets):
(WebCore::MediaElementSession::wirelessVideoPlaybackDisabled):
(WebCore::MediaElementSession::setWirelessVideoPlaybackDisabled):
(WebCore::MediaElementSession::setHasPlaybackTargetAvailabilityListeners):
(WebCore::MediaElementSession::setPlaybackTarget):
(WebCore::MediaElementSession::targetAvailabilityChangedTimerFired):
(WebCore::MediaElementSession::externalOutputDeviceAvailableDidChange):
(WebCore::MediaElementSession::canPlayToWirelessPlaybackTarget):
(WebCore::MediaElementSession::isPlayingToWirelessPlaybackTarget):
(WebCore::MediaElementSession::setShouldPlayToPlaybackTarget):
(WebCore::MediaElementSession::mediaStateDidChange):
(WebCore::MediaElementSession::effectivePreloadForElement):
(WebCore::MediaElementSession::requiresFullscreenForVideoPlayback):
(WebCore::MediaElementSession::mediaEngineUpdated):
(WebCore::MediaElementSession::allowsAlternateFullscreen):
(WebCore::MediaElementSession::maximumMediaSourceBufferSize):

  • html/MediaElementSession.h: Renamed from Source/WebCore/html/HTMLMediaSession.h.
  • testing/Internals.cpp:

(WebCore::Internals::setMediaElementRestrictions):
(WebCore::Internals::setAudioContextRestrictions):

Location:
trunk/Source/WebCore
Files:
8 edited
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/CMakeLists.txt

    r184954 r184966  
    16371637    html/HTMLMarqueeElement.cpp
    16381638    html/HTMLMediaElement.cpp
    1639     html/HTMLMediaSession.cpp
    16401639    html/HTMLMenuElement.cpp
    16411640    html/HTMLMetaElement.cpp
     
    16891688    html/MediaController.cpp
    16901689    html/MediaDocument.cpp
     1690    html/MediaElementSession.cpp
    16911691    html/MediaFragmentURIParser.cpp
    16921692    html/MonthInputType.cpp
  • trunk/Source/WebCore/ChangeLog

    r184965 r184966  
     12015-05-28  Matt Rajca  <mrajca@apple.com>
     2
     3        Rename HTMLMediaSession to MediaElementSession to reserve "media session" for the Media Session API.
     4        https://bugs.webkit.org/show_bug.cgi?id=145440
     5
     6        Reviewed by Eric Carlson.
     7
     8        * CMakeLists.txt:
     9        * WebCore.vcxproj/WebCore.vcxproj:
     10        * WebCore.vcxproj/WebCore.vcxproj.filters:
     11        * WebCore.xcodeproj/project.pbxproj:
     12        * html/HTMLMediaElement.cpp:
     13        (WebCore::HTMLMediaElement::HTMLMediaElement):
     14        (WebCore::HTMLMediaElement::loadInternal):
     15        (WebCore::HTMLMediaElement::loadResource):
     16        (WebCore::HTMLMediaElement::suspend):
     17        (WebCore::HTMLMediaElement::resume):
     18        (WebCore::HTMLMediaElement::removeBehaviorsRestrictionsAfterFirstUserGesture):
     19        (WebCore::HTMLMediaElement::mediaState):
     20        * html/HTMLMediaElement.h:
     21        (WebCore::HTMLMediaElement::mediaSession):
     22        * html/MediaElementSession.cpp: Renamed from Source/WebCore/html/HTMLMediaSession.cpp.
     23        (WebCore::restrictionName):
     24        (WebCore::MediaElementSession::MediaElementSession):
     25        (WebCore::MediaElementSession::registerWithDocument):
     26        (WebCore::MediaElementSession::unregisterWithDocument):
     27        (WebCore::MediaElementSession::addBehaviorRestriction):
     28        (WebCore::MediaElementSession::removeBehaviorRestriction):
     29        (WebCore::MediaElementSession::playbackPermitted):
     30        (WebCore::MediaElementSession::dataLoadingPermitted):
     31        (WebCore::MediaElementSession::fullscreenPermitted):
     32        (WebCore::MediaElementSession::pageAllowsDataLoading):
     33        (WebCore::MediaElementSession::pageAllowsPlaybackAfterResuming):
     34        (WebCore::MediaElementSession::showPlaybackTargetPicker):
     35        (WebCore::MediaElementSession::hasWirelessPlaybackTargets):
     36        (WebCore::MediaElementSession::wirelessVideoPlaybackDisabled):
     37        (WebCore::MediaElementSession::setWirelessVideoPlaybackDisabled):
     38        (WebCore::MediaElementSession::setHasPlaybackTargetAvailabilityListeners):
     39        (WebCore::MediaElementSession::setPlaybackTarget):
     40        (WebCore::MediaElementSession::targetAvailabilityChangedTimerFired):
     41        (WebCore::MediaElementSession::externalOutputDeviceAvailableDidChange):
     42        (WebCore::MediaElementSession::canPlayToWirelessPlaybackTarget):
     43        (WebCore::MediaElementSession::isPlayingToWirelessPlaybackTarget):
     44        (WebCore::MediaElementSession::setShouldPlayToPlaybackTarget):
     45        (WebCore::MediaElementSession::mediaStateDidChange):
     46        (WebCore::MediaElementSession::effectivePreloadForElement):
     47        (WebCore::MediaElementSession::requiresFullscreenForVideoPlayback):
     48        (WebCore::MediaElementSession::mediaEngineUpdated):
     49        (WebCore::MediaElementSession::allowsAlternateFullscreen):
     50        (WebCore::MediaElementSession::maximumMediaSourceBufferSize):
     51        * html/MediaElementSession.h: Renamed from Source/WebCore/html/HTMLMediaSession.h.
     52        * testing/Internals.cpp:
     53        (WebCore::Internals::setMediaElementRestrictions):
     54        (WebCore::Internals::setAudioContextRestrictions):
     55
    1562015-05-28  Myles C. Maxfield  <mmaxfield@apple.com>
    257
  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj

    r184895 r184966  
    1509915099    <ClCompile Include="..\html\DOMTokenList.cpp" />
    1510015100    <ClCompile Include="..\html\DOMURL.cpp" />
    15101     <ClCompile Include="..\html\HTMLMediaSession.cpp" />
     15101    <ClCompile Include="..\html\MediaElementSession.cpp" />
    1510215102    <ClCompile Include="..\html\EmailInputType.cpp" />
    1510315103    <ClCompile Include="..\html\PublicURLManager.cpp" />
  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters

    r184895 r184966  
    70317031      <Filter>Modules\gamepad</Filter>
    70327032    </ClCompile>
    7033     <ClCompile Include="..\html\HTMLMediaSession.cpp">
     7033    <ClCompile Include="..\html\MediaElementSession.cpp">
    70347034      <Filter>html</Filter>
    70357035    </ClCompile>
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r184895 r184966  
    352352                07F944161864D046005D31CB /* MediaSessionManager.h in Headers */ = {isa = PBXBuildFile; fileRef = CDAE8C081746B95700532D78 /* MediaSessionManager.h */; settings = {ATTRIBUTES = (Private, ); }; };
    353353                07FBDE2C18FED178001A7CFF /* JSDataCueCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07FBDE2B18FED178001A7CFF /* JSDataCueCustom.cpp */; };
    354                 07FE99DC18807A7D00256648 /* HTMLMediaSession.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07FE99DA18807A7D00256648 /* HTMLMediaSession.cpp */; };
    355                 07FE99DD18807A7D00256648 /* HTMLMediaSession.h in Headers */ = {isa = PBXBuildFile; fileRef = 07FE99DB18807A7D00256648 /* HTMLMediaSession.h */; settings = {ATTRIBUTES = (Private, ); }; };
     354                07FE99DC18807A7D00256648 /* MediaElementSession.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07FE99DA18807A7D00256648 /* MediaElementSession.cpp */; };
     355                07FE99DD18807A7D00256648 /* MediaElementSession.h in Headers */ = {isa = PBXBuildFile; fileRef = 07FE99DB18807A7D00256648 /* MediaElementSession.h */; settings = {ATTRIBUTES = (Private, ); }; };
    356356                07FFDE68181AED420072D409 /* MediaStreamTrackPrivate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07FFDE66181AED420072D409 /* MediaStreamTrackPrivate.cpp */; };
    357357                07FFDE69181AED420072D409 /* MediaStreamTrackPrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 07FFDE67181AED420072D409 /* MediaStreamTrackPrivate.h */; };
     
    74047404                07F876831AD4A94500905849 /* MediaPlaybackTargetContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaPlaybackTargetContext.h; sourceTree = "<group>"; };
    74057405                07FBDE2B18FED178001A7CFF /* JSDataCueCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDataCueCustom.cpp; sourceTree = "<group>"; };
    7406                 07FE99DA18807A7D00256648 /* HTMLMediaSession.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = HTMLMediaSession.cpp; sourceTree = "<group>"; };
    7407                 07FE99DB18807A7D00256648 /* HTMLMediaSession.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HTMLMediaSession.h; sourceTree = "<group>"; };
     7406                07FE99DA18807A7D00256648 /* MediaElementSession.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaElementSession.cpp; sourceTree = "<group>"; };
     7407                07FE99DB18807A7D00256648 /* MediaElementSession.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaElementSession.h; sourceTree = "<group>"; };
    74087408                07FFDE66181AED420072D409 /* MediaStreamTrackPrivate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaStreamTrackPrivate.cpp; sourceTree = "<group>"; };
    74097409                07FFDE67181AED420072D409 /* MediaStreamTrackPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaStreamTrackPrivate.h; sourceTree = "<group>"; };
     
    1815718157                                E44613940CD6331000FADA75 /* HTMLMediaElement.idl */,
    1815818158                                CD5209E51B0BD9E10077184E /* HTMLMediaElementEnums.h */,
    18159                                 07FE99DA18807A7D00256648 /* HTMLMediaSession.cpp */,
    18160                                 07FE99DB18807A7D00256648 /* HTMLMediaSession.h */,
    1816118159                                A8EA79EC0A1916DF00A8EF5F /* HTMLMenuElement.cpp */,
    1816218160                                A8EA79E80A1916DF00A8EF5F /* HTMLMenuElement.h */,
     
    1829718295                                97205AB31239291000B17380 /* MediaDocument.cpp */,
    1829818296                                97205AB41239291000B17380 /* MediaDocument.h */,
     18297                                07FE99DA18807A7D00256648 /* MediaElementSession.cpp */,
     18298                                07FE99DB18807A7D00256648 /* MediaElementSession.h */,
    1829918299                                E446139B0CD6331000FADA75 /* MediaError.h */,
    1830018300                                E446139C0CD6331000FADA75 /* MediaError.idl */,
     
    2489624896                                E44613A50CD6331000FADA75 /* HTMLMediaElement.h in Headers */,
    2489724897                                0779BF0E18453168000B6AE7 /* HTMLMediaElementMediaStream.h in Headers */,
    24898                                 07FE99DD18807A7D00256648 /* HTMLMediaSession.h in Headers */,
    2489924898                                A8EA79F40A1916DF00A8EF5F /* HTMLMenuElement.h in Headers */,
    2490024899                                2BE8E2C712A589EC00FAD550 /* HTMLMetaCharsetParser.h in Headers */,
     
    2577525774                                97205AB81239291000B17380 /* MediaDocument.h in Headers */,
    2577625775                                FD6F252D13F5EF0E0065165F /* MediaElementAudioSourceNode.h in Headers */,
     25776                                07FE99DD18807A7D00256648 /* MediaElementSession.h in Headers */,
    2577725777                                E44613AD0CD6331000FADA75 /* MediaError.h in Headers */,
    2577825778                                4E1959220A39DABA00220FE5 /* MediaFeatureNames.h in Headers */,
     
    2840328403                                E44613A40CD6331000FADA75 /* HTMLMediaElement.cpp in Sources */,
    2840428404                                0779BF0D18453168000B6AE7 /* HTMLMediaElementMediaStream.cpp in Sources */,
    28405                                 07FE99DC18807A7D00256648 /* HTMLMediaSession.cpp in Sources */,
    2840628405                                A8EA79F80A1916DF00A8EF5F /* HTMLMenuElement.cpp in Sources */,
    2840728406                                2BE8E2C912A58A0100FAD550 /* HTMLMetaCharsetParser.cpp in Sources */,
     
    2935629355                                97205AB71239291000B17380 /* MediaDocument.cpp in Sources */,
    2935729356                                FD6F252C13F5EF0E0065165F /* MediaElementAudioSourceNode.cpp in Sources */,
     29357                                07FE99DC18807A7D00256648 /* MediaElementSession.cpp in Sources */,
    2935829358                                4E1959210A39DABA00220FE5 /* MediaFeatureNames.cpp in Sources */,
    2935929359                                07A6D1EB1491137700051D0C /* MediaFragmentURIParser.cpp in Sources */,
  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r184814 r184966  
    352352    , m_audioSourceNode(0)
    353353#endif
    354     , m_mediaSession(std::make_unique<HTMLMediaSession>(*this))
     354    , m_mediaSession(std::make_unique<MediaElementSession>(*this))
    355355    , m_reportedExtraMemoryCost(0)
    356356#if ENABLE(MEDIA_STREAM)
     
    361361    setHasCustomStyleResolveCallbacks();
    362362
    363     m_mediaSession->addBehaviorRestriction(HTMLMediaSession::RequireUserGestureForFullscreen);
    364     m_mediaSession->addBehaviorRestriction(HTMLMediaSession::RequirePageConsentToLoadMedia);
     363    m_mediaSession->addBehaviorRestriction(MediaElementSession::RequireUserGestureForFullscreen);
     364    m_mediaSession->addBehaviorRestriction(MediaElementSession::RequirePageConsentToLoadMedia);
    365365#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    366     m_mediaSession->addBehaviorRestriction(HTMLMediaSession::RequireUserGestureToAutoplayToExternalDevice);
     366    m_mediaSession->addBehaviorRestriction(MediaElementSession::RequireUserGestureToAutoplayToExternalDevice);
    367367#endif
    368368
     
    371371#if !PLATFORM(IOS)
    372372    if (settings && settings->requiresUserGestureForMediaPlayback()) {
    373         m_mediaSession->addBehaviorRestriction(HTMLMediaSession::RequireUserGestureForRateChange);
    374         m_mediaSession->addBehaviorRestriction(HTMLMediaSession::RequireUserGestureForLoad);
     373        m_mediaSession->addBehaviorRestriction(MediaElementSession::RequireUserGestureForRateChange);
     374        m_mediaSession->addBehaviorRestriction(MediaElementSession::RequireUserGestureForLoad);
    375375    }
    376376#else
     
    379379        // Allow autoplay in a MediaDocument that is not in an iframe.
    380380        if (document.ownerElement() || !document.isMediaDocument())
    381             m_mediaSession->addBehaviorRestriction(HTMLMediaSession::RequireUserGestureForRateChange);
     381            m_mediaSession->addBehaviorRestriction(MediaElementSession::RequireUserGestureForRateChange);
    382382#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    383         m_mediaSession->addBehaviorRestriction(HTMLMediaSession::RequireUserGestureToShowPlaybackTargetPicker);
     383        m_mediaSession->addBehaviorRestriction(MediaElementSession::RequireUserGestureToShowPlaybackTargetPicker);
    384384#endif
    385385    } else {
    386386        // Relax RequireUserGestureForFullscreen when requiresUserGestureForMediaPlayback is not set:
    387         m_mediaSession->removeBehaviorRestriction(HTMLMediaSession::RequireUserGestureForFullscreen);
     387        m_mediaSession->removeBehaviorRestriction(MediaElementSession::RequireUserGestureForFullscreen);
    388388    }
    389389#endif // !PLATFORM(IOS)
    390390
    391391    if (settings && settings->audioPlaybackRequiresUserGesture())
    392         m_mediaSession->addBehaviorRestriction(HTMLMediaSession::RequireUserGestureForAudioRateChange);
     392        m_mediaSession->addBehaviorRestriction(MediaElementSession::RequireUserGestureForAudioRateChange);
    393393
    394394#if ENABLE(VIDEO_TRACK)
     
    10221022    // playlist that starts in a foreground tab to continue automatically if the tab is subsequently
    10231023    // put into the background.
    1024     m_mediaSession->removeBehaviorRestriction(HTMLMediaSession::RequirePageConsentToLoadMedia);
     1024    m_mediaSession->removeBehaviorRestriction(MediaElementSession::RequirePageConsentToLoadMedia);
    10251025
    10261026#if ENABLE(VIDEO_TRACK)
     
    12011201#if ENABLE(MEDIA_STREAM)
    12021202    if (MediaStreamRegistry::registry().lookup(url.string()))
    1203         m_mediaSession->removeBehaviorRestriction(HTMLMediaSession::RequireUserGestureForRateChange);
     1203        m_mediaSession->removeBehaviorRestriction(MediaElementSession::RequireUserGestureForRateChange);
    12041204#endif
    12051205
     
    48364836        case PageCache:
    48374837            stop();
    4838             m_mediaSession->addBehaviorRestriction(HTMLMediaSession::RequirePageConsentToResumeMedia);
     4838            m_mediaSession->addBehaviorRestriction(MediaElementSession::RequirePageConsentToResumeMedia);
    48394839            break;
    48404840        case DocumentWillBePaused:
     
    48584858        setPausedInternal(false);
    48594859
    4860     m_mediaSession->removeBehaviorRestriction(HTMLMediaSession::RequirePageConsentToResumeMedia);
     4860    m_mediaSession->removeBehaviorRestriction(MediaElementSession::RequirePageConsentToResumeMedia);
    48614861
    48624862    if (m_error && m_error->code() == MediaError::MEDIA_ERR_ABORTED) {
     
    59635963void HTMLMediaElement::removeBehaviorsRestrictionsAfterFirstUserGesture()
    59645964{
    5965     HTMLMediaSession::BehaviorRestrictions restrictionsToRemove = HTMLMediaSession::RequireUserGestureForLoad
     5965    MediaElementSession::BehaviorRestrictions restrictionsToRemove = MediaElementSession::RequireUserGestureForLoad
    59665966#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    5967         | HTMLMediaSession::RequireUserGestureToShowPlaybackTargetPicker
    5968         | HTMLMediaSession::RequireUserGestureToAutoplayToExternalDevice
    5969 #endif
    5970         | HTMLMediaSession::RequireUserGestureForLoad
    5971         | HTMLMediaSession::RequireUserGestureForRateChange
    5972         | HTMLMediaSession::RequireUserGestureForAudioRateChange
    5973         | HTMLMediaSession::RequireUserGestureForFullscreen;
     5967        | MediaElementSession::RequireUserGestureToShowPlaybackTargetPicker
     5968        | MediaElementSession::RequireUserGestureToAutoplayToExternalDevice
     5969#endif
     5970        | MediaElementSession::RequireUserGestureForLoad
     5971        | MediaElementSession::RequireUserGestureForRateChange
     5972        | MediaElementSession::RequireUserGestureForAudioRateChange
     5973        | MediaElementSession::RequireUserGestureForFullscreen;
    59745974    m_mediaSession->removeBehaviorRestriction(restrictionsToRemove);
    59755975}
     
    62966296        state |= RequiresPlaybackTargetMonitoring;
    62976297
    6298     bool requireUserGesture = m_mediaSession->hasBehaviorRestriction(HTMLMediaSession::RequireUserGestureToAutoplayToExternalDevice);
     6298    bool requireUserGesture = m_mediaSession->hasBehaviorRestriction(MediaElementSession::RequireUserGestureToAutoplayToExternalDevice);
    62996299    if (hasActiveVideo && (!requireUserGesture || (hasAudio && !loop())))
    63006300        state |= ExternalDeviceAutoPlayCandidate;
  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r184799 r184966  
    3333#include "GenericTaskQueue.h"
    3434#include "HTMLMediaElementEnums.h"
    35 #include "HTMLMediaSession.h"
    3635#include "MediaCanStartListener.h"
    3736#include "MediaControllerInterface.h"
     37#include "MediaElementSession.h"
    3838#include "MediaProducer.h"
    3939#include "PageThrottler.h"
     
    417417
    418418    MediaPlayerEnums::Preload preloadValue() const { return m_preload; }
    419     HTMLMediaSession& mediaSession() const { return *m_mediaSession; }
     419    MediaElementSession& mediaSession() const { return *m_mediaSession; }
    420420
    421421#if ENABLE(MEDIA_CONTROLS_SCRIPT)
     
    895895#endif
    896896
    897     std::unique_ptr<HTMLMediaSession> m_mediaSession;
     897    std::unique_ptr<MediaElementSession> m_mediaSession;
    898898    PageActivityAssertionToken m_activityToken;
    899899    size_t m_reportedExtraMemoryCost;
  • trunk/Source/WebCore/html/MediaElementSession.cpp

    r184965 r184966  
    2828#if ENABLE(VIDEO)
    2929
    30 #include "HTMLMediaSession.h"
     30#include "MediaElementSession.h"
    3131
    3232#include "Chrome.h"
     
    5252
    5353#if !LOG_DISABLED
    54 static String restrictionName(HTMLMediaSession::BehaviorRestrictions restriction)
     54static String restrictionName(MediaElementSession::BehaviorRestrictions restriction)
    5555{
    5656    StringBuilder restrictionBuilder;
    5757#define CASE(restrictionType) \
    58     if (restriction & HTMLMediaSession::restrictionType) { \
     58    if (restriction & MediaElementSession::restrictionType) { \
    5959        if (!restrictionBuilder.isEmpty()) \
    6060            restrictionBuilder.append(", "); \
     
    7979#endif
    8080
    81 HTMLMediaSession::HTMLMediaSession(MediaSessionClient& client)
     81MediaElementSession::MediaElementSession(MediaSessionClient& client)
    8282    : MediaSession(client)
    8383    , m_restrictions(NoRestrictions)
    8484#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    85     , m_targetAvailabilityChangedTimer(*this, &HTMLMediaSession::targetAvailabilityChangedTimerFired)
    86 #endif
    87 {
    88 }
    89 
    90 void HTMLMediaSession::registerWithDocument(const HTMLMediaElement& element)
     85    , m_targetAvailabilityChangedTimer(*this, &MediaElementSession::targetAvailabilityChangedTimerFired)
     86#endif
     87{
     88}
     89
     90void MediaElementSession::registerWithDocument(const HTMLMediaElement& element)
    9191{
    9292#if ENABLE(WIRELESS_PLAYBACK_TARGET)
     
    9797}
    9898
    99 void HTMLMediaSession::unregisterWithDocument(const HTMLMediaElement& element)
     99void MediaElementSession::unregisterWithDocument(const HTMLMediaElement& element)
    100100{
    101101#if ENABLE(WIRELESS_PLAYBACK_TARGET)
     
    106106}
    107107
    108 void HTMLMediaSession::addBehaviorRestriction(BehaviorRestrictions restriction)
    109 {
    110     LOG(Media, "HTMLMediaSession::addBehaviorRestriction - adding %s", restrictionName(restriction).utf8().data());
     108void MediaElementSession::addBehaviorRestriction(BehaviorRestrictions restriction)
     109{
     110    LOG(Media, "MediaElementSession::addBehaviorRestriction - adding %s", restrictionName(restriction).utf8().data());
    111111    m_restrictions |= restriction;
    112112}
    113113
    114 void HTMLMediaSession::removeBehaviorRestriction(BehaviorRestrictions restriction)
    115 {
    116     LOG(Media, "HTMLMediaSession::removeBehaviorRestriction - removing %s", restrictionName(restriction).utf8().data());
     114void MediaElementSession::removeBehaviorRestriction(BehaviorRestrictions restriction)
     115{
     116    LOG(Media, "MediaElementSession::removeBehaviorRestriction - removing %s", restrictionName(restriction).utf8().data());
    117117    m_restrictions &= ~restriction;
    118118}
    119119
    120 bool HTMLMediaSession::playbackPermitted(const HTMLMediaElement& element) const
     120bool MediaElementSession::playbackPermitted(const HTMLMediaElement& element) const
    121121{
    122122    if (m_restrictions & RequireUserGestureForRateChange && !ScriptController::processingUserGesture()) {
    123         LOG(Media, "HTMLMediaSession::playbackPermitted - returning FALSE");
     123        LOG(Media, "MediaElementSession::playbackPermitted - returning FALSE");
    124124        return false;
    125125    }
    126126
    127127    if (m_restrictions & RequireUserGestureForAudioRateChange && element.hasAudio() && !ScriptController::processingUserGesture()) {
    128         LOG(Media, "HTMLMediaSession::playbackPermitted - returning FALSE");
    129         return false;
    130     }
    131 
    132     return true;
    133 }
    134 
    135 bool HTMLMediaSession::dataLoadingPermitted(const HTMLMediaElement&) const
     128        LOG(Media, "MediaElementSession::playbackPermitted - returning FALSE");
     129        return false;
     130    }
     131
     132    return true;
     133}
     134
     135bool MediaElementSession::dataLoadingPermitted(const HTMLMediaElement&) const
    136136{
    137137    if (m_restrictions & RequireUserGestureForLoad && !ScriptController::processingUserGesture()) {
    138         LOG(Media, "HTMLMediaSession::dataLoadingPermitted - returning FALSE");
    139         return false;
    140     }
    141 
    142     return true;
    143 }
    144 
    145 bool HTMLMediaSession::fullscreenPermitted(const HTMLMediaElement&) const
     138        LOG(Media, "MediaElementSession::dataLoadingPermitted - returning FALSE");
     139        return false;
     140    }
     141
     142    return true;
     143}
     144
     145bool MediaElementSession::fullscreenPermitted(const HTMLMediaElement&) const
    146146{
    147147    if (m_restrictions & RequireUserGestureForFullscreen && !ScriptController::processingUserGesture()) {
    148         LOG(Media, "HTMLMediaSession::fullscreenPermitted - returning FALSE");
    149         return false;
    150     }
    151 
    152     return true;
    153 }
    154 
    155 bool HTMLMediaSession::pageAllowsDataLoading(const HTMLMediaElement& element) const
     148        LOG(Media, "MediaElementSession::fullscreenPermitted - returning FALSE");
     149        return false;
     150    }
     151
     152    return true;
     153}
     154
     155bool MediaElementSession::pageAllowsDataLoading(const HTMLMediaElement& element) const
    156156{
    157157    Page* page = element.document().page();
    158158    if (m_restrictions & RequirePageConsentToLoadMedia && page && !page->canStartMedia()) {
    159         LOG(Media, "HTMLMediaSession::pageAllowsDataLoading - returning FALSE");
    160         return false;
    161     }
    162 
    163     return true;
    164 }
    165 
    166 bool HTMLMediaSession::pageAllowsPlaybackAfterResuming(const HTMLMediaElement& element) const
     159        LOG(Media, "MediaElementSession::pageAllowsDataLoading - returning FALSE");
     160        return false;
     161    }
     162
     163    return true;
     164}
     165
     166bool MediaElementSession::pageAllowsPlaybackAfterResuming(const HTMLMediaElement& element) const
    167167{
    168168    Page* page = element.document().page();
    169169    if (m_restrictions & RequirePageConsentToResumeMedia && page && !page->canStartMedia()) {
    170         LOG(Media, "HTMLMediaSession::pageAllowsPlaybackAfterResuming - returning FALSE");
    171         return false;
    172     }
    173 
    174     return true;
    175 }
    176 
    177 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
    178 void HTMLMediaSession::showPlaybackTargetPicker(const HTMLMediaElement& element)
    179 {
    180     LOG(Media, "HTMLMediaSession::showPlaybackTargetPicker");
     170        LOG(Media, "MediaElementSession::pageAllowsPlaybackAfterResuming - returning FALSE");
     171        return false;
     172    }
     173
     174    return true;
     175}
     176
     177#if ENABLE(WIRELESS_PLAYBACK_TARGET)
     178void MediaElementSession::showPlaybackTargetPicker(const HTMLMediaElement& element)
     179{
     180    LOG(Media, "MediaElementSession::showPlaybackTargetPicker");
    181181
    182182    if (m_restrictions & RequireUserGestureToShowPlaybackTargetPicker && !ScriptController::processingUserGesture()) {
    183         LOG(Media, "HTMLMediaSession::showPlaybackTargetPicker - returning early because of permissions");
     183        LOG(Media, "MediaElementSession::showPlaybackTargetPicker - returning early because of permissions");
    184184        return;
    185185    }
    186186
    187187    if (!element.document().page()) {
    188         LOG(Media, "HTMLMediaSession::showingPlaybackTargetPickerPermitted - returning early because page is NULL");
     188        LOG(Media, "MediaElementSession::showingPlaybackTargetPickerPermitted - returning early because page is NULL");
    189189        return;
    190190    }
     
    192192#if !PLATFORM(IOS)
    193193    if (!element.hasVideo()) {
    194         LOG(Media, "HTMLMediaSession::showPlaybackTargetPicker - returning early because element has no video");
     194        LOG(Media, "MediaElementSession::showPlaybackTargetPicker - returning early because element has no video");
    195195        return;
    196196    }
     
    200200}
    201201
    202 bool HTMLMediaSession::hasWirelessPlaybackTargets(const HTMLMediaElement&) const
     202bool MediaElementSession::hasWirelessPlaybackTargets(const HTMLMediaElement&) const
    203203{
    204204#if PLATFORM(IOS)
     
    207207#endif
    208208
    209     LOG(Media, "HTMLMediaSession::hasWirelessPlaybackTargets - returning %s", m_hasPlaybackTargets ? "TRUE" : "FALSE");
     209    LOG(Media, "MediaElementSession::hasWirelessPlaybackTargets - returning %s", m_hasPlaybackTargets ? "TRUE" : "FALSE");
    210210
    211211    return m_hasPlaybackTargets;
    212212}
    213213
    214 bool HTMLMediaSession::wirelessVideoPlaybackDisabled(const HTMLMediaElement& element) const
     214bool MediaElementSession::wirelessVideoPlaybackDisabled(const HTMLMediaElement& element) const
    215215{
    216216    Settings* settings = element.document().settings();
    217217    if (!settings || !settings->allowsAirPlayForMediaPlayback()) {
    218         LOG(Media, "HTMLMediaSession::wirelessVideoPlaybackDisabled - returning TRUE because of settings");
     218        LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of settings");
    219219        return true;
    220220    }
    221221
    222222    if (element.fastHasAttribute(HTMLNames::webkitwirelessvideoplaybackdisabledAttr)) {
    223         LOG(Media, "HTMLMediaSession::wirelessVideoPlaybackDisabled - returning TRUE because of attribute");
     223        LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of attribute");
    224224        return true;
    225225    }
     
    228228    String legacyAirplayAttributeValue = element.fastGetAttribute(HTMLNames::webkitairplayAttr);
    229229    if (equalIgnoringCase(legacyAirplayAttributeValue, "deny")) {
    230         LOG(Media, "HTMLMediaSession::wirelessVideoPlaybackDisabled - returning TRUE because of legacy attribute");
     230        LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of legacy attribute");
    231231        return true;
    232232    }
    233233    if (equalIgnoringCase(legacyAirplayAttributeValue, "allow")) {
    234         LOG(Media, "HTMLMediaSession::wirelessVideoPlaybackDisabled - returning FALSE because of legacy attribute");
     234        LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning FALSE because of legacy attribute");
    235235        return false;
    236236    }
     
    242242
    243243    bool disabled = player->wirelessVideoPlaybackDisabled();
    244     LOG(Media, "HTMLMediaSession::wirelessVideoPlaybackDisabled - returning %s because media engine says so", disabled ? "TRUE" : "FALSE");
     244    LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning %s because media engine says so", disabled ? "TRUE" : "FALSE");
    245245   
    246246    return disabled;
    247247}
    248248
    249 void HTMLMediaSession::setWirelessVideoPlaybackDisabled(const HTMLMediaElement& element, bool disabled)
     249void MediaElementSession::setWirelessVideoPlaybackDisabled(const HTMLMediaElement& element, bool disabled)
    250250{
    251251    if (disabled)
     
    258258        return;
    259259
    260     LOG(Media, "HTMLMediaSession::setWirelessVideoPlaybackDisabled - disabled %s", disabled ? "TRUE" : "FALSE");
     260    LOG(Media, "MediaElementSession::setWirelessVideoPlaybackDisabled - disabled %s", disabled ? "TRUE" : "FALSE");
    261261    player->setWirelessVideoPlaybackDisabled(disabled);
    262262}
    263263
    264 void HTMLMediaSession::setHasPlaybackTargetAvailabilityListeners(const HTMLMediaElement& element, bool hasListeners)
    265 {
    266     LOG(Media, "HTMLMediaSession::setHasPlaybackTargetAvailabilityListeners - hasListeners %s", hasListeners ? "TRUE" : "FALSE");
     264void MediaElementSession::setHasPlaybackTargetAvailabilityListeners(const HTMLMediaElement& element, bool hasListeners)
     265{
     266    LOG(Media, "MediaElementSession::setHasPlaybackTargetAvailabilityListeners - hasListeners %s", hasListeners ? "TRUE" : "FALSE");
    267267
    268268#if PLATFORM(IOS)
     
    276276}
    277277
    278 void HTMLMediaSession::setPlaybackTarget(Ref<MediaPlaybackTarget>&& device)
     278void MediaElementSession::setPlaybackTarget(Ref<MediaPlaybackTarget>&& device)
    279279{
    280280    m_playbackTarget = WTF::move(device);
     
    282282}
    283283
    284 void HTMLMediaSession::targetAvailabilityChangedTimerFired()
     284void MediaElementSession::targetAvailabilityChangedTimerFired()
    285285{
    286286    client().wirelessRoutesAvailableDidChange();
    287287}
    288288
    289 void HTMLMediaSession::externalOutputDeviceAvailableDidChange(bool hasTargets)
     289void MediaElementSession::externalOutputDeviceAvailableDidChange(bool hasTargets)
    290290{
    291291    if (m_hasPlaybackTargets == hasTargets)
    292292        return;
    293293
    294     LOG(Media, "HTMLMediaSession::externalOutputDeviceAvailableDidChange(%p) - hasTargets %s", this, hasTargets ? "TRUE" : "FALSE");
     294    LOG(Media, "MediaElementSession::externalOutputDeviceAvailableDidChange(%p) - hasTargets %s", this, hasTargets ? "TRUE" : "FALSE");
    295295
    296296    m_hasPlaybackTargets = hasTargets;
     
    298298}
    299299
    300 bool HTMLMediaSession::canPlayToWirelessPlaybackTarget() const
     300bool MediaElementSession::canPlayToWirelessPlaybackTarget() const
    301301{
    302302    if (!m_playbackTarget || !m_playbackTarget->hasActiveRoute())
     
    306306}
    307307
    308 bool HTMLMediaSession::isPlayingToWirelessPlaybackTarget() const
     308bool MediaElementSession::isPlayingToWirelessPlaybackTarget() const
    309309{
    310310    if (!m_playbackTarget || !m_playbackTarget->hasActiveRoute())
     
    314314}
    315315
    316 void HTMLMediaSession::setShouldPlayToPlaybackTarget(bool shouldPlay)
    317 {
    318     LOG(Media, "HTMLMediaSession::setShouldPlayToPlaybackTarget - shouldPlay %s", shouldPlay ? "TRUE" : "FALSE");
     316void MediaElementSession::setShouldPlayToPlaybackTarget(bool shouldPlay)
     317{
     318    LOG(Media, "MediaElementSession::setShouldPlayToPlaybackTarget - shouldPlay %s", shouldPlay ? "TRUE" : "FALSE");
    319319    m_shouldPlayToPlaybackTarget = shouldPlay;
    320320    client().setShouldPlayToPlaybackTarget(shouldPlay);
    321321}
    322322
    323 void HTMLMediaSession::mediaStateDidChange(const HTMLMediaElement& element, MediaProducer::MediaStateFlags state)
     323void MediaElementSession::mediaStateDidChange(const HTMLMediaElement& element, MediaProducer::MediaStateFlags state)
    324324{
    325325    element.document().playbackTargetPickerClientStateDidChange(*this, state);
     
    327327#endif
    328328
    329 MediaPlayer::Preload HTMLMediaSession::effectivePreloadForElement(const HTMLMediaElement& element) const
     329MediaPlayer::Preload MediaElementSession::effectivePreloadForElement(const HTMLMediaElement& element) const
    330330{
    331331    MediaSessionManager::SessionRestrictions restrictions = MediaSessionManager::sharedManager().restrictions(mediaType());
     
    343343}
    344344
    345 bool HTMLMediaSession::requiresFullscreenForVideoPlayback(const HTMLMediaElement& element) const
     345bool MediaElementSession::requiresFullscreenForVideoPlayback(const HTMLMediaElement& element) const
    346346{
    347347    if (!MediaSessionManager::sharedManager().sessionRestrictsInlineVideoPlayback(*this))
     
    363363}
    364364
    365 void HTMLMediaSession::mediaEngineUpdated(const HTMLMediaElement& element)
    366 {
    367     LOG(Media, "HTMLMediaSession::mediaEngineUpdated");
     365void MediaElementSession::mediaEngineUpdated(const HTMLMediaElement& element)
     366{
     367    LOG(Media, "MediaElementSession::mediaEngineUpdated");
    368368
    369369#if ENABLE(WIRELESS_PLAYBACK_TARGET)
     
    380380}
    381381
    382 bool HTMLMediaSession::allowsAlternateFullscreen(const HTMLMediaElement& element) const
     382bool MediaElementSession::allowsAlternateFullscreen(const HTMLMediaElement& element) const
    383383{
    384384    Settings* settings = element.document().settings();
     
    390390const unsigned fiveMinutesStereoAudio = 14 * 1024 * 1024; // 14 MB is approximately 5 minutes of 384kbps content.
    391391
    392 size_t HTMLMediaSession::maximumMediaSourceBufferSize(const SourceBuffer& buffer) const
     392size_t MediaElementSession::maximumMediaSourceBufferSize(const SourceBuffer& buffer) const
    393393{
    394394    // A good quality 1080p video uses 8,000 kbps and stereo audio uses 384 kbps, so assume 95% for video and 5% for audio.
  • trunk/Source/WebCore/html/MediaElementSession.h

    r184965 r184966  
    2424 */
    2525
    26 #ifndef HTMLMediaSession_h
    27 #define HTMLMediaSession_h
     26#ifndef MediaElementSession_h
     27#define MediaElementSession_h
    2828
    2929#if ENABLE(VIDEO)
     
    3939class SourceBuffer;
    4040
    41 class HTMLMediaSession final : public MediaSession {
     41class MediaElementSession final : public MediaSession {
    4242    WTF_MAKE_FAST_ALLOCATED;
    4343public:
    44     explicit HTMLMediaSession(MediaSessionClient&);
    45     virtual ~HTMLMediaSession() { }
     44    explicit MediaElementSession(MediaSessionClient&);
     45    virtual ~MediaElementSession() { }
    4646
    4747    void registerWithDocument(const HTMLMediaElement&);
     
    130130}
    131131
    132 #endif // MediaSession_h
     132#endif // MediaElementSession_h
    133133
    134134#endif // ENABLE(VIDEO)
  • trunk/Source/WebCore/testing/Internals.cpp

    r184799 r184966  
    26492649    }
    26502650
    2651     HTMLMediaSession::BehaviorRestrictions restrictions = element->mediaSession().behaviorRestrictions();
     2651    MediaElementSession::BehaviorRestrictions restrictions = element->mediaSession().behaviorRestrictions();
    26522652    element->mediaSession().removeBehaviorRestriction(restrictions);
    26532653
    2654     restrictions = HTMLMediaSession::NoRestrictions;
     2654    restrictions = MediaElementSession::NoRestrictions;
    26552655
    26562656    Vector<String> restrictionsArray;
     
    26582658    for (auto& restrictionString : restrictionsArray) {
    26592659        if (equalIgnoringCase(restrictionString, "NoRestrictions"))
    2660             restrictions |= HTMLMediaSession::NoRestrictions;
     2660            restrictions |= MediaElementSession::NoRestrictions;
    26612661        if (equalIgnoringCase(restrictionString, "RequireUserGestureForLoad"))
    2662             restrictions |= HTMLMediaSession::RequireUserGestureForLoad;
     2662            restrictions |= MediaElementSession::RequireUserGestureForLoad;
    26632663        if (equalIgnoringCase(restrictionString, "RequireUserGestureForRateChange"))
    2664             restrictions |= HTMLMediaSession::RequireUserGestureForRateChange;
     2664            restrictions |= MediaElementSession::RequireUserGestureForRateChange;
    26652665        if (equalIgnoringCase(restrictionString, "RequireUserGestureForFullscreen"))
    2666             restrictions |= HTMLMediaSession::RequireUserGestureForFullscreen;
     2666            restrictions |= MediaElementSession::RequireUserGestureForFullscreen;
    26672667        if (equalIgnoringCase(restrictionString, "RequirePageConsentToLoadMedia"))
    2668             restrictions |= HTMLMediaSession::RequirePageConsentToLoadMedia;
     2668            restrictions |= MediaElementSession::RequirePageConsentToLoadMedia;
    26692669        if (equalIgnoringCase(restrictionString, "RequirePageConsentToResumeMedia"))
    2670             restrictions |= HTMLMediaSession::RequirePageConsentToResumeMedia;
     2670            restrictions |= MediaElementSession::RequirePageConsentToResumeMedia;
    26712671#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    26722672        if (equalIgnoringCase(restrictionString, "RequireUserGestureToShowPlaybackTargetPicker"))
    2673             restrictions |= HTMLMediaSession::RequireUserGestureToShowPlaybackTargetPicker;
     2673            restrictions |= MediaElementSession::RequireUserGestureToShowPlaybackTargetPicker;
    26742674        if (equalIgnoringCase(restrictionString, "WirelessVideoPlaybackDisabled"))
    2675             restrictions |= HTMLMediaSession::WirelessVideoPlaybackDisabled;
     2675            restrictions |= MediaElementSession::WirelessVideoPlaybackDisabled;
    26762676#endif
    26772677        if (equalIgnoringCase(restrictionString, "RequireUserGestureForAudioRateChange"))
    2678             restrictions |= HTMLMediaSession::RequireUserGestureForAudioRateChange;
     2678            restrictions |= MediaElementSession::RequireUserGestureForAudioRateChange;
    26792679    }
    26802680    element->mediaSession().addBehaviorRestriction(restrictions);
     
    27282728    context->removeBehaviorRestriction(restrictions);
    27292729
    2730     restrictions = HTMLMediaSession::NoRestrictions;
     2730    restrictions = MediaElementSession::NoRestrictions;
    27312731
    27322732    Vector<String> restrictionsArray;
Note: See TracChangeset for help on using the changeset viewer.