Changeset 185006 in webkit


Ignore:
Timestamp:
May 29, 2015 2:53:30 PM (9 years ago)
Author:
commit-queue@webkit.org
Message:

Rename MediaSession and MediaSessionClient to PlatformMediaSession and PlatformMediaSessionClient so we can use MediaSession for the formal implementation of the Media Session spec.
​https://bugs.webkit.org/show_bug.cgi?id=145447

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

  • Modules/webaudio/AudioContext.cpp:

(WebCore::AudioContext::AudioContext):
(WebCore::AudioContext::suspendPlayback):

  • Modules/webaudio/AudioContext.h:
  • WebCore.vcxproj/WebCore.vcxproj:
  • WebCore.vcxproj/WebCore.vcxproj.filters:
  • WebCore.xcodeproj/project.pbxproj:
  • html/HTMLAudioElement.h:
  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::pausedForUserInteraction):
(WebCore::HTMLMediaElement::mediaType):
(WebCore::HTMLMediaElement::presentationType):
(WebCore::HTMLMediaElement::displayType):
(WebCore::HTMLMediaElement::didReceiveRemoteControlCommand):

  • html/HTMLMediaElement.h:
  • html/HTMLMediaSession.cpp:

(WebCore::HTMLMediaSession::HTMLMediaSession):
(WebCore::HTMLMediaSession::requiresFullscreenForVideoPlayback):

  • html/HTMLMediaSession.h:
  • html/HTMLVideoElement.h:
  • platform/RemoteCommandListener.h:
  • platform/audio/MediaSessionManager.cpp:

(WebCore::MediaSessionManager::resetRestrictions):
(WebCore::MediaSessionManager::has):
(WebCore::MediaSessionManager::activeAudioSessionRequired):
(WebCore::MediaSessionManager::count):
(WebCore::MediaSessionManager::beginInterruption):
(WebCore::MediaSessionManager::endInterruption):
(WebCore::MediaSessionManager::addSession):
(WebCore::MediaSessionManager::removeSession):
(WebCore::MediaSessionManager::addRestriction):
(WebCore::MediaSessionManager::removeRestriction):
(WebCore::MediaSessionManager::restrictions):
(WebCore::MediaSessionManager::sessionWillBeginPlayback):
(WebCore::MediaSessionManager::sessionWillEndPlayback):
(WebCore::MediaSessionManager::setCurrentSession):
(WebCore::MediaSessionManager::currentSession):
(WebCore::MediaSessionManager::sessionRestrictsInlineVideoPlayback):
(WebCore::MediaSessionManager::sessionCanLoadMedia):
(WebCore::MediaSessionManager::applicationWillEnterBackground):
(WebCore::MediaSessionManager::applicationWillEnterForeground):
(WebCore::MediaSessionManager::didReceiveRemoteControlCommand):
(WebCore::MediaSessionManager::systemWillSleep):
(WebCore::MediaSessionManager::systemDidWake):

  • platform/audio/MediaSessionManager.h:

(WebCore::MediaSessionManager::sessions):

  • platform/audio/PlatformMediaSession.cpp: Renamed from Source/WebCore/platform/audio/MediaSession.cpp.

(WebCore::stateName):
(WebCore::PlatformMediaSession::create):
(WebCore::PlatformMediaSession::PlatformMediaSession):
(WebCore::PlatformMediaSession::~PlatformMediaSession):
(WebCore::PlatformMediaSession::setState):
(WebCore::PlatformMediaSession::beginInterruption):
(WebCore::PlatformMediaSession::endInterruption):
(WebCore::PlatformMediaSession::clientWillBeginPlayback):
(WebCore::PlatformMediaSession::clientWillPausePlayback):
(WebCore::PlatformMediaSession::pauseSession):
(WebCore::PlatformMediaSession::mediaType):
(WebCore::PlatformMediaSession::presentationType):
(WebCore::PlatformMediaSession::title):
(WebCore::PlatformMediaSession::duration):
(WebCore::PlatformMediaSession::currentTime):
(WebCore::PlatformMediaSession::canReceiveRemoteControlCommands):
(WebCore::PlatformMediaSession::didReceiveRemoteControlCommand):
(WebCore::PlatformMediaSession::visibilityChanged):
(WebCore::PlatformMediaSession::clientDataBufferingTimerFired):
(WebCore::PlatformMediaSession::updateClientDataBuffering):
(WebCore::PlatformMediaSession::isHidden):
(WebCore::PlatformMediaSession::displayType):
(WebCore::PlatformMediaSessionClient::mediaSessionTitle):
(WebCore::PlatformMediaSessionClient::mediaSessionDuration):
(WebCore::PlatformMediaSessionClient::mediaSessionCurrentTime):

  • platform/audio/PlatformMediaSession.h: Renamed from Source/WebCore/platform/audio/MediaSession.h.

(WebCore::PlatformMediaSession::state):
(WebCore::PlatformMediaSession::canPlayToWirelessPlaybackTarget):
(WebCore::PlatformMediaSession::isPlayingToWirelessPlaybackTarget):
(WebCore::PlatformMediaSession::requiresPlaybackTargetRouteMonitoring):
(WebCore::PlatformMediaSession::client):
(WebCore::PlatformMediaSessionClient::PlatformMediaSessionClient):
(WebCore::PlatformMediaSessionClient::displayType):
(WebCore::PlatformMediaSessionClient::setShouldBufferData):
(WebCore::PlatformMediaSessionClient::elementIsHidden):
(WebCore::PlatformMediaSessionClient::wirelessRoutesAvailableDidChange):
(WebCore::PlatformMediaSessionClient::setWirelessPlaybackTarget):
(WebCore::PlatformMediaSessionClient::canPlayToWirelessPlaybackTarget):
(WebCore::PlatformMediaSessionClient::isPlayingToWirelessPlaybackTarget):
(WebCore::PlatformMediaSessionClient::setShouldPlayToPlaybackTarget):
(WebCore::PlatformMediaSessionClient::~PlatformMediaSessionClient):

  • platform/audio/ios/MediaSessionManagerIOS.h:
  • platform/audio/ios/MediaSessionManagerIOS.mm:

(WebCore::MediaSessionManageriOS::resetRestrictions):
(WebCore::MediaSessionManageriOS::sessionWillBeginPlayback):
(WebCore::MediaSessionManageriOS::sessionWillEndPlayback):
(WebCore::MediaSessionManageriOS::updateNowPlayingInfo):
(WebCore::MediaSessionManageriOS::sessionCanLoadMedia):
(-[WebMediaSessionHelper interruption:]):

  • platform/audio/mac/MediaSessionManagerMac.cpp:

(MediaSessionManager::updateSessionState):

  • platform/graphics/MediaPlayer.cpp:

(WebCore::MediaPlayer::handlePlaybackCommand):

  • platform/graphics/MediaPlayer.h:

(WebCore::MediaPlayerClient::mediaPlayerHandlePlaybackCommand):

  • platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp:

(WebCore::MediaPlayerPrivateAVFoundation::rateChanged):

  • platform/ios/RemoteCommandListenerIOS.mm:

(WebCore::RemoteCommandListenerIOS::RemoteCommandListenerIOS):

  • testing/Internals.cpp:

(WebCore::Internals::beginMediaSessionInterruption):
(WebCore::Internals::endMediaSessionInterruption):
(WebCore::Internals::setMediaSessionRestrictions):
(WebCore::Internals::postRemoteControlCommand):

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

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/CMakeLists.txt

    r184966 r185006  
    21022102    platform/audio/HRTFKernel.cpp
    21032103    platform/audio/HRTFPanner.cpp
    2104     platform/audio/MediaSession.cpp
    21052104    platform/audio/MediaSessionManager.cpp
    21062105    platform/audio/MultiChannelResampler.cpp
    21072106    platform/audio/Panner.cpp
     2107    platform/audio/PlatformMediaSession.cpp
    21082108    platform/audio/Reverb.cpp
    21092109    platform/audio/ReverbAccumulationBuffer.cpp

  • trunk/Source/WebCore/ChangeLog

    r185004 r185006  
     12015-05-29  Matt Rajca  <mrajca@apple.com>
     2
     3        Rename MediaSession and MediaSessionClient to PlatformMediaSession and PlatformMediaSessionClient so we can use MediaSession for the formal implementation of the Media Session spec.
     4        https://bugs.webkit.org/show_bug.cgi?id=145447
     5
     6        Reviewed by Eric Carlson.
     7
     8        * Modules/webaudio/AudioContext.cpp:
     9        (WebCore::AudioContext::AudioContext):
     10        (WebCore::AudioContext::suspendPlayback):
     11        * Modules/webaudio/AudioContext.h:
     12        * WebCore.vcxproj/WebCore.vcxproj:
     13        * WebCore.vcxproj/WebCore.vcxproj.filters:
     14        * WebCore.xcodeproj/project.pbxproj:
     15        * html/HTMLAudioElement.h:
     16        * html/HTMLMediaElement.cpp:
     17        (WebCore::HTMLMediaElement::pausedForUserInteraction):
     18        (WebCore::HTMLMediaElement::mediaType):
     19        (WebCore::HTMLMediaElement::presentationType):
     20        (WebCore::HTMLMediaElement::displayType):
     21        (WebCore::HTMLMediaElement::didReceiveRemoteControlCommand):
     22        * html/HTMLMediaElement.h:
     23        * html/HTMLMediaSession.cpp:
     24        (WebCore::HTMLMediaSession::HTMLMediaSession):
     25        (WebCore::HTMLMediaSession::requiresFullscreenForVideoPlayback):
     26        * html/HTMLMediaSession.h:
     27        * html/HTMLVideoElement.h:
     28        * platform/RemoteCommandListener.h:
     29        * platform/audio/MediaSessionManager.cpp:
     30        (WebCore::MediaSessionManager::resetRestrictions):
     31        (WebCore::MediaSessionManager::has):
     32        (WebCore::MediaSessionManager::activeAudioSessionRequired):
     33        (WebCore::MediaSessionManager::count):
     34        (WebCore::MediaSessionManager::beginInterruption):
     35        (WebCore::MediaSessionManager::endInterruption):
     36        (WebCore::MediaSessionManager::addSession):
     37        (WebCore::MediaSessionManager::removeSession):
     38        (WebCore::MediaSessionManager::addRestriction):
     39        (WebCore::MediaSessionManager::removeRestriction):
     40        (WebCore::MediaSessionManager::restrictions):
     41        (WebCore::MediaSessionManager::sessionWillBeginPlayback):
     42        (WebCore::MediaSessionManager::sessionWillEndPlayback):
     43        (WebCore::MediaSessionManager::setCurrentSession):
     44        (WebCore::MediaSessionManager::currentSession):
     45        (WebCore::MediaSessionManager::sessionRestrictsInlineVideoPlayback):
     46        (WebCore::MediaSessionManager::sessionCanLoadMedia):
     47        (WebCore::MediaSessionManager::applicationWillEnterBackground):
     48        (WebCore::MediaSessionManager::applicationWillEnterForeground):
     49        (WebCore::MediaSessionManager::didReceiveRemoteControlCommand):
     50        (WebCore::MediaSessionManager::systemWillSleep):
     51        (WebCore::MediaSessionManager::systemDidWake):
     52        * platform/audio/MediaSessionManager.h:
     53        (WebCore::MediaSessionManager::sessions):
     54        * platform/audio/PlatformMediaSession.cpp: Renamed from Source/WebCore/platform/audio/MediaSession.cpp.
     55        (WebCore::stateName):
     56        (WebCore::PlatformMediaSession::create):
     57        (WebCore::PlatformMediaSession::PlatformMediaSession):
     58        (WebCore::PlatformMediaSession::~PlatformMediaSession):
     59        (WebCore::PlatformMediaSession::setState):
     60        (WebCore::PlatformMediaSession::beginInterruption):
     61        (WebCore::PlatformMediaSession::endInterruption):
     62        (WebCore::PlatformMediaSession::clientWillBeginPlayback):
     63        (WebCore::PlatformMediaSession::clientWillPausePlayback):
     64        (WebCore::PlatformMediaSession::pauseSession):
     65        (WebCore::PlatformMediaSession::mediaType):
     66        (WebCore::PlatformMediaSession::presentationType):
     67        (WebCore::PlatformMediaSession::title):
     68        (WebCore::PlatformMediaSession::duration):
     69        (WebCore::PlatformMediaSession::currentTime):
     70        (WebCore::PlatformMediaSession::canReceiveRemoteControlCommands):
     71        (WebCore::PlatformMediaSession::didReceiveRemoteControlCommand):
     72        (WebCore::PlatformMediaSession::visibilityChanged):
     73        (WebCore::PlatformMediaSession::clientDataBufferingTimerFired):
     74        (WebCore::PlatformMediaSession::updateClientDataBuffering):
     75        (WebCore::PlatformMediaSession::isHidden):
     76        (WebCore::PlatformMediaSession::displayType):
     77        (WebCore::PlatformMediaSessionClient::mediaSessionTitle):
     78        (WebCore::PlatformMediaSessionClient::mediaSessionDuration):
     79        (WebCore::PlatformMediaSessionClient::mediaSessionCurrentTime):
     80        * platform/audio/PlatformMediaSession.h: Renamed from Source/WebCore/platform/audio/MediaSession.h.
     81        (WebCore::PlatformMediaSession::state):
     82        (WebCore::PlatformMediaSession::canPlayToWirelessPlaybackTarget):
     83        (WebCore::PlatformMediaSession::isPlayingToWirelessPlaybackTarget):
     84        (WebCore::PlatformMediaSession::requiresPlaybackTargetRouteMonitoring):
     85        (WebCore::PlatformMediaSession::client):
     86        (WebCore::PlatformMediaSessionClient::PlatformMediaSessionClient):
     87        (WebCore::PlatformMediaSessionClient::displayType):
     88        (WebCore::PlatformMediaSessionClient::setShouldBufferData):
     89        (WebCore::PlatformMediaSessionClient::elementIsHidden):
     90        (WebCore::PlatformMediaSessionClient::wirelessRoutesAvailableDidChange):
     91        (WebCore::PlatformMediaSessionClient::setWirelessPlaybackTarget):
     92        (WebCore::PlatformMediaSessionClient::canPlayToWirelessPlaybackTarget):
     93        (WebCore::PlatformMediaSessionClient::isPlayingToWirelessPlaybackTarget):
     94        (WebCore::PlatformMediaSessionClient::setShouldPlayToPlaybackTarget):
     95        (WebCore::PlatformMediaSessionClient::~PlatformMediaSessionClient):
     96        * platform/audio/ios/MediaSessionManagerIOS.h:
     97        * platform/audio/ios/MediaSessionManagerIOS.mm:
     98        (WebCore::MediaSessionManageriOS::resetRestrictions):
     99        (WebCore::MediaSessionManageriOS::sessionWillBeginPlayback):
     100        (WebCore::MediaSessionManageriOS::sessionWillEndPlayback):
     101        (WebCore::MediaSessionManageriOS::updateNowPlayingInfo):
     102        (WebCore::MediaSessionManageriOS::sessionCanLoadMedia):
     103        (-[WebMediaSessionHelper interruption:]):
     104        * platform/audio/mac/MediaSessionManagerMac.cpp:
     105        (MediaSessionManager::updateSessionState):
     106        * platform/graphics/MediaPlayer.cpp:
     107        (WebCore::MediaPlayer::handlePlaybackCommand):
     108        * platform/graphics/MediaPlayer.h:
     109        (WebCore::MediaPlayerClient::mediaPlayerHandlePlaybackCommand):
     110        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp:
     111        (WebCore::MediaPlayerPrivateAVFoundation::rateChanged):
     112        * platform/ios/RemoteCommandListenerIOS.mm:
     113        (WebCore::RemoteCommandListenerIOS::RemoteCommandListenerIOS):
     114        * testing/Internals.cpp:
     115        (WebCore::Internals::beginMediaSessionInterruption):
     116        (WebCore::Internals::endMediaSessionInterruption):
     117        (WebCore::Internals::setMediaSessionRestrictions):
     118        (WebCore::Internals::postRemoteControlCommand):
     119
    11202015-05-29  Alex Christensen  <achristensen@webkit.org>
    2121

  • trunk/Source/WebCore/Modules/webaudio/AudioContext.cpp

    r184802 r185006  
    130130AudioContext::AudioContext(Document& document)
    131131    : ActiveDOMObject(&document)
    132     , m_mediaSession(MediaSession::create(*this))
     132    , m_mediaSession(PlatformMediaSession::create(*this))
    133133    , m_eventQueue(std::make_unique<GenericEventQueue>(*this))
    134134    , m_graphOwnerThread(UndefinedThreadIdentifier)
    … …  
    146146    : ActiveDOMObject(&document)
    147147    , m_isOfflineContext(true)
    148     , m_mediaSession(MediaSession::create(*this))
     148    , m_mediaSession(PlatformMediaSession::create(*this))
    149149    , m_eventQueue(std::make_unique<GenericEventQueue>(*this))
    150150    , m_graphOwnerThread(UndefinedThreadIdentifier)
    … …  
    12011201
    12021202    if (m_state == State::Suspended) {
    1203         if (m_mediaSession->state() == MediaSession::Interrupted)
     1203        if (m_mediaSession->state() == PlatformMediaSession::Interrupted)
    12041204            setState(State::Interrupted);
    12051205        return;
    … …  
    12101210    RefPtr<AudioContext> strongThis(this);
    12111211    m_destinationNode->suspend([strongThis] {
    1212         bool interrupted = strongThis->m_mediaSession->state() == MediaSession::Interrupted;
     1212        bool interrupted = strongThis->m_mediaSession->state() == PlatformMediaSession::Interrupted;
    12131213        strongThis->setState(interrupted ? State::Interrupted : State::Suspended);
    12141214    });

  • trunk/Source/WebCore/Modules/webaudio/AudioContext.h

    r184651 r185006  
    3434#include "MediaCanStartListener.h"
    3535#include "MediaProducer.h"
    36 #include "MediaSession.h"
     36#include "PlatformMediaSession.h"
    3737#include <atomic>
    3838#include <wtf/HashSet.h>
    … …  
    7777// For thread safety between the audio thread and the main thread, it has a rendering graph locking mechanism.
    7878
    79 class AudioContext : public ActiveDOMObject, public ThreadSafeRefCounted<AudioContext>, public EventTargetWithInlineData, public MediaCanStartListener, public MediaProducer, private MediaSessionClient {
     79class AudioContext : public ActiveDOMObject, public ThreadSafeRefCounted<AudioContext>, public EventTargetWithInlineData, public MediaCanStartListener, public MediaProducer, private PlatformMediaSessionClient {
    8080public:
    8181    // Create an AudioContext for rendering to the audio hardware.
    … …  
    309309    void derefUnfinishedSourceNodes();
    310310
    311     // MediaSessionClient
    312     virtual MediaSession::MediaType mediaType() const override { return MediaSession::WebAudio; }
    313     virtual MediaSession::MediaType presentationType() const override { return MediaSession::WebAudio; }
     311    // PlatformMediaSessionClient
     312    virtual PlatformMediaSession::MediaType mediaType() const override { return PlatformMediaSession::WebAudio; }
     313    virtual PlatformMediaSession::MediaType presentationType() const override { return PlatformMediaSession::WebAudio; }
    314314    virtual void mayResumePlayback(bool shouldResume) override;
    315315    virtual void suspendPlayback() override;
    316316    virtual bool canReceiveRemoteControlCommands() const override { return false; }
    317     virtual void didReceiveRemoteControlCommand(MediaSession::RemoteControlCommandType) override { }
     317    virtual void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType) override { }
    318318    virtual bool overrideBackgroundPlaybackRestriction() const override { return false; }
    319319
    … …  
    364364    Vector<Vector<std::function<void()>>> m_stateReactions;
    365365
    366     std::unique_ptr<MediaSession> m_mediaSession;
     366    std::unique_ptr<PlatformMediaSession> m_mediaSession;
    367367    std::unique_ptr<GenericEventQueue> m_eventQueue;
    368368

  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj

    r184966 r185006  
    73967396    <ClCompile Include="..\platform\graphics\ISOVTTCue.cpp" />
    73977397    <ClCompile Include="..\platform\audio\AudioSession.cpp" />
    7398     <ClCompile Include="..\platform\audio\MediaSession.cpp" />
     7398    <ClCompile Include="..\platform\audio\PlatformMediaSession.cpp" />
    73997399    <ClCompile Include="..\platform\audio\MediaSessionManager.cpp" />
    74007400    <ClCompile Include="..\platform\graphics\ANGLEWebKitBridge.cpp" />
    … …  
    1976519765    <ClInclude Include="..\platform\GenericTaskQueue.h" />
    1976619766    <ClInclude Include="..\platform\audio\AudioSession.h" />
    19767     <ClInclude Include="..\platform\audio\MediaSession.h" />
     19767    <ClInclude Include="..\platform\audio\PlatformMediaSession.h" />
    1976819768    <ClInclude Include="..\platform\audio\MediaSessionManager.h" />
    1976919769    <ClInclude Include="..\platform\graphics\ANGLEWebKitBridge.h" />

  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters

    r184966 r185006  
    70527052      <Filter>rendering\line</Filter>
    70537053    </ClCompile>
    7054     <ClCompile Include="..\platform\audio\MediaSession.cpp">
     7054    <ClCompile Include="..\platform\audio\PlatformMediaSession.cpp">
    70557055      <Filter>platform\audio</Filter>
    70567056    </ClCompile>
    … …  
    1449914499      <Filter>platform\audio</Filter>
    1450014500    </ClInclude>
    14501     <ClInclude Include="..\platform\audio\MediaSession.h">
     14501    <ClInclude Include="..\platform\audio\PlatformMediaSession.h">
    1450214502      <Filter>platform\audio</Filter>
    1450314503    </ClInclude>

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r184966 r185006  
    120120                0709D7951AE55A29004E42F8 /* WebMediaSessionManagerClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 0709D7941AE55A29004E42F8 /* WebMediaSessionManagerClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
    121121                0709FC4E1025DEE30059CDBA /* AccessibilitySlider.h in Headers */ = {isa = PBXBuildFile; fileRef = 0709FC4D1025DEE30059CDBA /* AccessibilitySlider.h */; };
    122                 070E09191875EEFC003A1D3C /* MediaSession.h in Headers */ = {isa = PBXBuildFile; fileRef = 070E09181875ED93003A1D3C /* MediaSession.h */; settings = {ATTRIBUTES = (Private, ); }; };
    123                 070E091B1875EF71003A1D3C /* MediaSession.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 070E091A1875EF71003A1D3C /* MediaSession.cpp */; };
     122                070E09191875EEFC003A1D3C /* PlatformMediaSession.h in Headers */ = {isa = PBXBuildFile; fileRef = 070E09181875ED93003A1D3C /* PlatformMediaSession.h */; settings = {ATTRIBUTES = (Private, ); }; };
     123                070E091B1875EF71003A1D3C /* PlatformMediaSession.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 070E091A1875EF71003A1D3C /* PlatformMediaSession.cpp */; };
    124124                070F549817F12F6B00169E04 /* MediaStreamConstraintsValidationClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 070F549717F12F6B00169E04 /* MediaStreamConstraintsValidationClient.h */; };
    125125                070F549E17F2402700169E04 /* AudioDestinationConsumer.h in Headers */ = {isa = PBXBuildFile; fileRef = 070F549D17F2402700169E04 /* AudioDestinationConsumer.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    71357135                0709FC4D1025DEE30059CDBA /* AccessibilitySlider.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AccessibilitySlider.h; sourceTree = "<group>"; };
    71367136                070DD8F50F01868000727DEB /* mediaControls.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = mediaControls.css; sourceTree = "<group>"; };
    7137                 070E09181875ED93003A1D3C /* MediaSession.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaSession.h; sourceTree = "<group>"; };
    7138                 070E091A1875EF71003A1D3C /* MediaSession.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaSession.cpp; sourceTree = "<group>"; };
     7137                070E09181875ED93003A1D3C /* PlatformMediaSession.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlatformMediaSession.h; sourceTree = "<group>"; };
     7138                070E091A1875EF71003A1D3C /* PlatformMediaSession.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PlatformMediaSession.cpp; sourceTree = "<group>"; };
    71397139                070F549717F12F6B00169E04 /* MediaStreamConstraintsValidationClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaStreamConstraintsValidationClient.h; sourceTree = "<group>"; };
    71407140                070F549D17F2402700169E04 /* AudioDestinationConsumer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AudioDestinationConsumer.h; sourceTree = "<group>"; };
    … …  
    2354923549                                FD31606A12B026F700C1A359 /* HRTFPanner.cpp */,
    2355023550                                FD31606B12B026F700C1A359 /* HRTFPanner.h */,
    23551                                 070E091A1875EF71003A1D3C /* MediaSession.cpp */,
    23552                                 070E09181875ED93003A1D3C /* MediaSession.h */,
    2355323551                                CDAE8C071746B95700532D78 /* MediaSessionManager.cpp */,
    2355423552                                CDAE8C081746B95700532D78 /* MediaSessionManager.h */,
    … …  
    2355723555                                FD31606C12B026F700C1A359 /* Panner.cpp */,
    2355823556                                FD31606D12B026F700C1A359 /* Panner.h */,
     23557                                070E091A1875EF71003A1D3C /* PlatformMediaSession.cpp */,
     23558                                070E09181875ED93003A1D3C /* PlatformMediaSession.h */,
    2355923559                                FD31606E12B026F700C1A359 /* Reverb.cpp */,
    2356023560                                FD31606F12B026F700C1A359 /* Reverb.h */,
    … …  
    2580025800                                CEEFCD7A19DB31F7003876D7 /* MediaResourceLoader.h in Headers */,
    2580125801                                CDBEAEAD19D92B6C00BEBA88 /* MediaSelectionGroupAVFObjC.h in Headers */,
    25802                                 070E09191875EEFC003A1D3C /* MediaSession.h in Headers */,
    2580325802                                07F944161864D046005D31CB /* MediaSessionManager.h in Headers */,
    2580425803                                07638A991884487200E15A1B /* MediaSessionManagerIOS.h in Headers */,
    … …  
    2602426023                                F544F78915CFB2A800AF33A8 /* PlatformLocale.h in Headers */,
    2602526024                                CEEFCD7C19DB33DC003876D7 /* PlatformMediaResourceLoader.h in Headers */,
     26025                                070E09191875EEFC003A1D3C /* PlatformMediaSession.h in Headers */,
    2602626026                                932871C00B20DEB70049035A /* PlatformMenuDescription.h in Headers */,
    2602726027                                41BF70100FE86F61005E8DEC /* PlatformMessagePortChannel.h in Headers */,
    … …  
    2937929379                                CEEFCD7919DB31F7003876D7 /* MediaResourceLoader.cpp in Sources */,
    2938029380                                CDBEAEAC19D92B6C00BEBA88 /* MediaSelectionGroupAVFObjC.mm in Sources */,
    29381                                 070E091B1875EF71003A1D3C /* MediaSession.cpp in Sources */,
    2938229381                                CDAE8C091746B95700532D78 /* MediaSessionManager.cpp in Sources */,
    2938329382                                07638A9A1884487200E15A1B /* MediaSessionManagerIOS.mm in Sources */,
    … …  
    2955029549                                BCAA486F14A052530088FAC4 /* PlatformEventFactoryMac.mm in Sources */,
    2955129550                                F544F78815CFB2A800AF33A8 /* PlatformLocale.cpp in Sources */,
     29551                                070E091B1875EF71003A1D3C /* PlatformMediaSession.cpp in Sources */,
    2955229552                                41BF700F0FE86F61005E8DEC /* PlatformMessagePortChannel.cpp in Sources */,
    2955329553                                C5278B0C17F212EA003A2998 /* PlatformPasteboardIOS.mm in Sources */,

  • trunk/Source/WebCore/html/HTMLAudioElement.h

    r177996 r185006  
    4343    HTMLAudioElement(const QualifiedName&, Document&, bool);
    4444
    45     virtual MediaSession::MediaType presentationType() const override { return MediaSession::Audio; }
     45    virtual PlatformMediaSession::MediaType presentationType() const override { return PlatformMediaSession::Audio; }
    4646};
    4747

  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r184966 r185006  
    45344534bool HTMLMediaElement::pausedForUserInteraction() const
    45354535{
    4536     if (m_mediaSession->state() == MediaSession::Interrupted)
     4536    if (m_mediaSession->state() == PlatformMediaSession::Interrupted)
    45374537        return true;
    45384538
    … …  
    61686168}
    61696169
    6170 MediaSession::MediaType HTMLMediaElement::mediaType() const
     6170PlatformMediaSession::MediaType HTMLMediaElement::mediaType() const
    61716171{
    61726172    if (m_player && m_readyState >= HAVE_METADATA)
    6173         return hasVideo() ? MediaSession::Video : MediaSession::Audio;
     6173        return hasVideo() ? PlatformMediaSession::Video : PlatformMediaSession::Audio;
    61746174
    61756175    return presentationType();
    61766176}
    61776177
    6178 MediaSession::MediaType HTMLMediaElement::presentationType() const
     6178PlatformMediaSession::MediaType HTMLMediaElement::presentationType() const
    61796179{
    61806180    if (hasTagName(HTMLNames::videoTag))
    6181         return MediaSession::Video;
    6182 
    6183     return MediaSession::Audio;
    6184 }
    6185 
    6186 MediaSession::DisplayType HTMLMediaElement::displayType() const
     6181        return PlatformMediaSession::Video;
     6182
     6183    return PlatformMediaSession::Audio;
     6184}
     6185
     6186PlatformMediaSession::DisplayType HTMLMediaElement::displayType() const
    61876187{
    61886188    if (m_videoFullscreenMode == VideoFullscreenModeStandard)
    6189         return MediaSession::Fullscreen;
     6189        return PlatformMediaSession::Fullscreen;
    61906190    if (m_videoFullscreenMode & VideoFullscreenModeOptimized)
    6191         return MediaSession::Optimized;
     6191        return PlatformMediaSession::Optimized;
    61926192    if (m_videoFullscreenMode == VideoFullscreenModeNone)
    6193         return MediaSession::Normal;
     6193        return PlatformMediaSession::Normal;
    61946194
    61956195    ASSERT_NOT_REACHED();
    6196     return MediaSession::Normal;
     6196    return PlatformMediaSession::Normal;
    61976197}
    61986198
    … …  
    62266226}
    62276227
    6228 void HTMLMediaElement::didReceiveRemoteControlCommand(MediaSession::RemoteControlCommandType command)
     6228void HTMLMediaElement::didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType command)
    62296229{
    62306230    LOG(Media, "HTMLMediaElement::didReceiveRemoteControlCommand(%p) - %i", this, static_cast<int>(command));
    62316231
    62326232    switch (command) {
    6233     case MediaSession::PlayCommand:
     6233    case PlatformMediaSession::PlayCommand:
    62346234        play();
    62356235        break;
    6236     case MediaSession::PauseCommand:
     6236    case PlatformMediaSession::PauseCommand:
    62376237        pause();
    62386238        break;
    6239     case MediaSession::TogglePlayPauseCommand:
     6239    case PlatformMediaSession::TogglePlayPauseCommand:
    62406240        canPlay() ? play() : pause();
    62416241        break;
    6242     case MediaSession::BeginSeekingBackwardCommand:
     6242    case PlatformMediaSession::BeginSeekingBackwardCommand:
    62436243        beginScanning(Backward);
    62446244        break;
    6245     case MediaSession::BeginSeekingForwardCommand:
     6245    case PlatformMediaSession::BeginSeekingForwardCommand:
    62466246        beginScanning(Forward);
    62476247        break;
    6248     case MediaSession::EndSeekingBackwardCommand:
    6249     case MediaSession::EndSeekingForwardCommand:
     6248    case PlatformMediaSession::EndSeekingBackwardCommand:
     6249    case PlatformMediaSession::EndSeekingForwardCommand:
    62506250        endScanning();
    62516251        break;

  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r184966 r185006  
    9898class HTMLMediaElement
    9999    : public HTMLElement
    100     , private MediaPlayerClient, public MediaPlayerSupportsTypeClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface , public MediaSessionClient, private MediaProducer
     100    , private MediaPlayerClient, public MediaPlayerSupportsTypeClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface , public PlatformMediaSessionClient, private MediaProducer
    101101#if ENABLE(VIDEO_TRACK)
    102102    , private AudioTrackClient
    … …  
    569569
    570570    virtual bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) override;
    571     virtual void mediaPlayerHandlePlaybackCommand(MediaSession::RemoteControlCommandType command) override { didReceiveRemoteControlCommand(command); }
     571    virtual void mediaPlayerHandlePlaybackCommand(PlatformMediaSession::RemoteControlCommandType command) override { didReceiveRemoteControlCommand(command); }
    572572    virtual String mediaPlayerSourceApplicationIdentifier() const override;
    573573    virtual Vector<String> mediaPlayerPreferredAudioCharacteristics() const override;
    … …  
    691691#endif
    692692
    693     // MediaSessionClient Overrides
    694     virtual MediaSession::MediaType mediaType() const override;
    695     virtual MediaSession::MediaType presentationType() const override;
    696     virtual MediaSession::DisplayType displayType() const override;
     693    // PlatformMediaSessionClient Overrides
     694    virtual PlatformMediaSession::MediaType mediaType() const override;
     695    virtual PlatformMediaSession::MediaType presentationType() const override;
     696    virtual PlatformMediaSession::DisplayType displayType() const override;
    697697    virtual void suspendPlayback() override;
    698698    virtual void mayResumePlayback(bool shouldResume) override;
    … …  
    701701    virtual double mediaSessionCurrentTime() const override { return currentTime(); }
    702702    virtual bool canReceiveRemoteControlCommands() const override { return true; }
    703     virtual void didReceiveRemoteControlCommand(MediaSession::RemoteControlCommandType) override;
     703    virtual void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType) override;
    704704    virtual bool overrideBackgroundPlaybackRestriction() const override;
    705705

  • trunk/Source/WebCore/html/HTMLVideoElement.h

    r183160 r185006  
    105105    virtual void setDisplayMode(DisplayMode) override;
    106106
    107     virtual MediaSession::MediaType presentationType() const override { return MediaSession::Video; }
     107    virtual PlatformMediaSession::MediaType presentationType() const override { return PlatformMediaSession::Video; }
    108108
    109109    std::unique_ptr<HTMLImageLoader> m_imageLoader;

  • trunk/Source/WebCore/html/MediaElementSession.cpp

    r184966 r185006  
    7979#endif
    8080
    81 MediaElementSession::MediaElementSession(MediaSessionClient& client)
    82     : MediaSession(client)
     81MediaElementSession::MediaElementSession(PlatformMediaSessionClient& client)
     82    : PlatformMediaSession(client)
    8383    , m_restrictions(NoRestrictions)
    8484#if ENABLE(WIRELESS_PLAYBACK_TARGET)

  • trunk/Source/WebCore/html/MediaElementSession.h

    r184966 r185006  
    3030
    3131#include "MediaPlayer.h"
    32 #include "MediaSession.h"
     32#include "PlatformMediaSession.h"
    3333#include "Timer.h"
    3434
    … …  
    3939class SourceBuffer;
    4040
    41 class MediaElementSession final : public MediaSession {
     41class MediaElementSession final : public PlatformMediaSession {
    4242    WTF_MAKE_FAST_ALLOCATED;
    4343public:
    44     explicit MediaElementSession(MediaSessionClient&);
     44    explicit MediaElementSession(PlatformMediaSessionClient&);
    4545    virtual ~MediaElementSession() { }
    4646

  • trunk/Source/WebCore/platform/RemoteCommandListener.h

    r182068 r185006  
    2727#define RemoteCommandListener_h
    2828
    29 #include "MediaSession.h"
     29#include "PlatformMediaSession.h"
    3030
    3131namespace WebCore {
    … …  
    3535public:
    3636    virtual ~RemoteCommandListenerClient() { }
    37     virtual void didReceiveRemoteControlCommand(MediaSession::RemoteControlCommandType) = 0;
     37    virtual void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType) = 0;
    3838};
    3939

  • trunk/Source/WebCore/platform/audio/MediaSessionManager.cpp

    r183096 r185006  
    3232#include "Logging.h"
    3333#include "NotImplemented.h"
    34 #include "MediaSession.h"
     34#include "PlatformMediaSession.h"
    3535
    3636namespace WebCore {
    … …  
    5252void MediaSessionManager::resetRestrictions()
    5353{
    54     m_restrictions[MediaSession::Video] = NoRestrictions;
    55     m_restrictions[MediaSession::Audio] = NoRestrictions;
    56     m_restrictions[MediaSession::WebAudio] = NoRestrictions;
    57 }
    58 
    59 bool MediaSessionManager::has(MediaSession::MediaType type) const
    60 {
    61     ASSERT(type >= MediaSession::None && type <= MediaSession::WebAudio);
     54    m_restrictions[PlatformMediaSession::Video] = NoRestrictions;
     55    m_restrictions[PlatformMediaSession::Audio] = NoRestrictions;
     56    m_restrictions[PlatformMediaSession::WebAudio] = NoRestrictions;
     57}
     58
     59bool MediaSessionManager::has(PlatformMediaSession::MediaType type) const
     60{
     61    ASSERT(type >= PlatformMediaSession::None && type <= PlatformMediaSession::WebAudio);
    6262
    6363    for (auto* session : m_sessions) {
    … …  
    7272{
    7373    for (auto* session : m_sessions) {
    74         if (session->mediaType() != MediaSession::None && session->state() == MediaSession::State::Playing)
     74        if (session->mediaType() != PlatformMediaSession::None && session->state() == PlatformMediaSession::State::Playing)
    7575            return true;
    7676    }
    … …  
    7979}
    8080
    81 int MediaSessionManager::count(MediaSession::MediaType type) const
    82 {
    83     ASSERT(type >= MediaSession::None && type <= MediaSession::WebAudio);
     81int MediaSessionManager::count(PlatformMediaSession::MediaType type) const
     82{
     83    ASSERT(type >= PlatformMediaSession::None && type <= PlatformMediaSession::WebAudio);
    8484
    8585    int count = 0;
    … …  
    9292}
    9393
    94 void MediaSessionManager::beginInterruption(MediaSession::InterruptionType type)
     94void MediaSessionManager::beginInterruption(PlatformMediaSession::InterruptionType type)
    9595{
    9696    LOG(Media, "MediaSessionManager::beginInterruption");
    9797
    9898    m_interrupted = true;
    99     Vector<MediaSession*> sessions = m_sessions;
     99    Vector<PlatformMediaSession*> sessions = m_sessions;
    100100    for (auto* session : sessions)
    101101        session->beginInterruption(type);
    … …  
    103103}
    104104
    105 void MediaSessionManager::endInterruption(MediaSession::EndInterruptionFlags flags)
     105void MediaSessionManager::endInterruption(PlatformMediaSession::EndInterruptionFlags flags)
    106106{
    107107    LOG(Media, "MediaSessionManager::endInterruption");
    108108
    109109    m_interrupted = false;
    110     Vector<MediaSession*> sessions = m_sessions;
     110    Vector<PlatformMediaSession*> sessions = m_sessions;
    111111    for (auto* session : sessions)
    112112        session->endInterruption(flags);
    113113}
    114114
    115 void MediaSessionManager::addSession(MediaSession& session)
     115void MediaSessionManager::addSession(PlatformMediaSession& session)
    116116{
    117117    LOG(Media, "MediaSessionManager::addSession - %p", &session);
    … …  
    119119    m_sessions.append(&session);
    120120    if (m_interrupted)
    121         session.setState(MediaSession::Interrupted);
     121        session.setState(PlatformMediaSession::Interrupted);
    122122
    123123    if (!m_remoteCommandListener)
    … …  
    130130}
    131131
    132 void MediaSessionManager::removeSession(MediaSession& session)
     132void MediaSessionManager::removeSession(PlatformMediaSession& session)
    133133{
    134134    LOG(Media, "MediaSessionManager::removeSession - %p", &session);
    … …  
    149149}
    150150
    151 void MediaSessionManager::addRestriction(MediaSession::MediaType type, SessionRestrictions restriction)
    152 {
    153     ASSERT(type > MediaSession::None && type <= MediaSession::WebAudio);
     151void MediaSessionManager::addRestriction(PlatformMediaSession::MediaType type, SessionRestrictions restriction)
     152{
     153    ASSERT(type > PlatformMediaSession::None && type <= PlatformMediaSession::WebAudio);
    154154    m_restrictions[type] |= restriction;
    155155}
    156156
    157 void MediaSessionManager::removeRestriction(MediaSession::MediaType type, SessionRestrictions restriction)
    158 {
    159     ASSERT(type > MediaSession::None && type <= MediaSession::WebAudio);
     157void MediaSessionManager::removeRestriction(PlatformMediaSession::MediaType type, SessionRestrictions restriction)
     158{
     159    ASSERT(type > PlatformMediaSession::None && type <= PlatformMediaSession::WebAudio);
    160160    m_restrictions[type] &= ~restriction;
    161161}
    162162
    163 MediaSessionManager::SessionRestrictions MediaSessionManager::restrictions(MediaSession::MediaType type)
    164 {
    165     ASSERT(type > MediaSession::None && type <= MediaSession::WebAudio);
     163MediaSessionManager::SessionRestrictions MediaSessionManager::restrictions(PlatformMediaSession::MediaType type)
     164{
     165    ASSERT(type > PlatformMediaSession::None && type <= PlatformMediaSession::WebAudio);
    166166    return m_restrictions[type];
    167167}
    168168
    169 bool MediaSessionManager::sessionWillBeginPlayback(MediaSession& session)
     169bool MediaSessionManager::sessionWillBeginPlayback(PlatformMediaSession& session)
    170170{
    171171    LOG(Media, "MediaSessionManager::sessionWillBeginPlayback - %p", &session);
    … …  
    173173    setCurrentSession(session);
    174174
    175     MediaSession::MediaType sessionType = session.mediaType();
     175    PlatformMediaSession::MediaType sessionType = session.mediaType();
    176176    SessionRestrictions restrictions = m_restrictions[sessionType];
    177     if (session.state() == MediaSession::Interrupted && restrictions & InterruptedPlaybackNotPermitted)
     177    if (session.state() == PlatformMediaSession::Interrupted && restrictions & InterruptedPlaybackNotPermitted)
    178178        return false;
    179179
    … …  
    184184
    185185    if (m_interrupted)
    186         endInterruption(MediaSession::NoFlags);
    187 
    188     Vector<MediaSession*> sessions = m_sessions;
     186        endInterruption(PlatformMediaSession::NoFlags);
     187
     188    Vector<PlatformMediaSession*> sessions = m_sessions;
    189189    for (auto* oneSession : sessions) {
    190190        if (oneSession == &session)
    … …  
    198198}
    199199   
    200 void MediaSessionManager::sessionWillEndPlayback(MediaSession& session)
     200void MediaSessionManager::sessionWillEndPlayback(PlatformMediaSession& session)
    201201{
    202202    LOG(Media, "MediaSessionManager::sessionWillEndPlayback - %p", &session);
    … …  
    208208    size_t lastPlayingSessionIndex = notFound;
    209209    for (size_t i = 0; i < m_sessions.size(); ++i) {
    210         MediaSession* oneSession = m_sessions[i];
     210        PlatformMediaSession* oneSession = m_sessions[i];
    211211       
    212212        if (oneSession == &session) {
    … …  
    214214            continue;
    215215        }
    216         if (oneSession->state() == MediaSession::Playing) {
     216        if (oneSession->state() == PlatformMediaSession::Playing) {
    217217            lastPlayingSessionIndex = i;
    218218            continue;
    219219        }
    220         if (oneSession->state() != MediaSession::Playing)
     220        if (oneSession->state() != PlatformMediaSession::Playing)
    221221            break;
    222222    }
    … …  
    233233}
    234234
    235 void MediaSessionManager::setCurrentSession(MediaSession& session)
     235void MediaSessionManager::setCurrentSession(PlatformMediaSession& session)
    236236{
    237237    LOG(Media, "MediaSessionManager::setCurrentSession - %p", &session);
    … …  
    251251}
    252252   
    253 MediaSession* MediaSessionManager::currentSession()
     253PlatformMediaSession* MediaSessionManager::currentSession()
    254254{
    255255    if (!m_sessions.size())
    … …  
    259259}
    260260   
    261 bool MediaSessionManager::sessionRestrictsInlineVideoPlayback(const MediaSession& session) const
    262 {
    263     MediaSession::MediaType sessionType = session.presentationType();
    264     if (sessionType != MediaSession::Video)
     261bool MediaSessionManager::sessionRestrictsInlineVideoPlayback(const PlatformMediaSession& session) const
     262{
     263    PlatformMediaSession::MediaType sessionType = session.presentationType();
     264    if (sessionType != PlatformMediaSession::Video)
    265265        return false;
    266266
    … …  
    268268}
    269269
    270 bool MediaSessionManager::sessionCanLoadMedia(const MediaSession& session) const
    271 {
    272     return session.state() == MediaSession::Playing || !session.isHidden() || session.isPlayingToWirelessPlaybackTarget();
     270bool MediaSessionManager::sessionCanLoadMedia(const PlatformMediaSession& session) const
     271{
     272    return session.state() == PlatformMediaSession::Playing || !session.isHidden() || session.isPlayingToWirelessPlaybackTarget();
    273273}
    274274
    … …  
    276276{
    277277    LOG(Media, "MediaSessionManager::applicationWillEnterBackground");
    278     Vector<MediaSession*> sessions = m_sessions;
     278    Vector<PlatformMediaSession*> sessions = m_sessions;
    279279    for (auto* session : sessions) {
    280280        if (m_restrictions[session->mediaType()] & BackgroundProcessPlaybackRestricted)
    281             session->beginInterruption(MediaSession::EnteringBackground);
     281            session->beginInterruption(PlatformMediaSession::EnteringBackground);
    282282    }
    283283}
    … …  
    286286{
    287287    LOG(Media, "MediaSessionManager::applicationWillEnterForeground");
    288     Vector<MediaSession*> sessions = m_sessions;
     288    Vector<PlatformMediaSession*> sessions = m_sessions;
    289289    for (auto* session : sessions) {
    290290        if (m_restrictions[session->mediaType()] & BackgroundProcessPlaybackRestricted)
    291             session->endInterruption(MediaSession::MayResumePlaying);
     291            session->endInterruption(PlatformMediaSession::MayResumePlaying);
    292292    }
    293293}
    … …  
    299299#endif
    300300
    301 void MediaSessionManager::didReceiveRemoteControlCommand(MediaSession::RemoteControlCommandType command)
    302 {
    303     MediaSession* activeSession = currentSession();
     301void MediaSessionManager::didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType command)
     302{
     303    PlatformMediaSession* activeSession = currentSession();
    304304    if (!activeSession || !activeSession->canReceiveRemoteControlCommands())
    305305        return;
    … …  
    313313
    314314    for (auto session : m_sessions)
    315         session->beginInterruption(MediaSession::SystemSleep);
     315        session->beginInterruption(PlatformMediaSession::SystemSleep);
    316316}
    317317
    … …  
    322322
    323323    for (auto session : m_sessions)
    324         session->endInterruption(MediaSession::MayResumePlaying);
     324        session->endInterruption(PlatformMediaSession::MayResumePlaying);
    325325}
    326326

  • trunk/Source/WebCore/platform/audio/MediaSessionManager.h

    r183096 r185006  
    2828
    2929#include "AudioHardwareListener.h"
    30 #include "MediaSession.h"
     30#include "PlatformMediaSession.h"
    3131#include "RemoteCommandListener.h"
    3232#include "Settings.h"
    … …  
    3838
    3939class HTMLMediaElement;
    40 class MediaSession;
     40class PlatformMediaSession;
    4141class RemoteCommandListener;
    4242
    … …  
    4747    virtual ~MediaSessionManager() { }
    4848
    49     bool has(MediaSession::MediaType) const;
    50     int count(MediaSession::MediaType) const;
     49    bool has(PlatformMediaSession::MediaType) const;
     50    int count(PlatformMediaSession::MediaType) const;
    5151    bool activeAudioSessionRequired() const;
    5252
    53     WEBCORE_EXPORT void beginInterruption(MediaSession::InterruptionType);
    54     WEBCORE_EXPORT void endInterruption(MediaSession::EndInterruptionFlags);
     53    WEBCORE_EXPORT void beginInterruption(PlatformMediaSession::InterruptionType);
     54    WEBCORE_EXPORT void endInterruption(PlatformMediaSession::EndInterruptionFlags);
    5555
    5656    WEBCORE_EXPORT void applicationWillEnterForeground() const;
    … …  
    6969    typedef unsigned SessionRestrictions;
    7070
    71     WEBCORE_EXPORT void addRestriction(MediaSession::MediaType, SessionRestrictions);
    72     WEBCORE_EXPORT void removeRestriction(MediaSession::MediaType, SessionRestrictions);
    73     WEBCORE_EXPORT SessionRestrictions restrictions(MediaSession::MediaType);
     71    WEBCORE_EXPORT void addRestriction(PlatformMediaSession::MediaType, SessionRestrictions);
     72    WEBCORE_EXPORT void removeRestriction(PlatformMediaSession::MediaType, SessionRestrictions);
     73    WEBCORE_EXPORT SessionRestrictions restrictions(PlatformMediaSession::MediaType);
    7474    virtual void resetRestrictions();
    7575
    76     virtual bool sessionWillBeginPlayback(MediaSession&);
    77     virtual void sessionWillEndPlayback(MediaSession&);
     76    virtual bool sessionWillBeginPlayback(PlatformMediaSession&);
     77    virtual void sessionWillEndPlayback(PlatformMediaSession&);
    7878
    79     bool sessionRestrictsInlineVideoPlayback(const MediaSession&) const;
     79    bool sessionRestrictsInlineVideoPlayback(const PlatformMediaSession&) const;
    8080
    81     virtual bool sessionCanLoadMedia(const MediaSession&) const;
     81    virtual bool sessionCanLoadMedia(const PlatformMediaSession&) const;
    8282
    8383#if PLATFORM(IOS)
    … …  
    8686#endif
    8787
    88     void setCurrentSession(MediaSession&);
    89     MediaSession* currentSession();
     88    void setCurrentSession(PlatformMediaSession&);
     89    PlatformMediaSession* currentSession();
    9090
    9191protected:
    92     friend class MediaSession;
     92    friend class PlatformMediaSession;
    9393    explicit MediaSessionManager();
    9494
    95     void addSession(MediaSession&);
    96     void removeSession(MediaSession&);
     95    void addSession(PlatformMediaSession&);
     96    void removeSession(PlatformMediaSession&);
    9797
    98     Vector<MediaSession*> sessions() { return m_sessions; }
     98    Vector<PlatformMediaSession*> sessions() { return m_sessions; }
    9999
    100100private:
    … …  
    104104
    105105    // RemoteCommandListenerClient
    106     WEBCORE_EXPORT virtual void didReceiveRemoteControlCommand(MediaSession::RemoteControlCommandType) override;
     106    WEBCORE_EXPORT virtual void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType) override;
    107107
    108108    // AudioHardwareListenerClient
    … …  
    115115    virtual void systemDidWake() override;
    116116
    117     SessionRestrictions m_restrictions[MediaSession::WebAudio + 1];
    118     Vector<MediaSession*> m_sessions;
     117    SessionRestrictions m_restrictions[PlatformMediaSession::WebAudio + 1];
     118    Vector<PlatformMediaSession*> m_sessions;
    119119    std::unique_ptr<RemoteCommandListener> m_remoteCommandListener;
    120120    std::unique_ptr<SystemSleepListener> m_systemSleepListener;

  • trunk/Source/WebCore/platform/audio/PlatformMediaSession.cpp

    r185005 r185006  
    2525
    2626#include "config.h"
    27 #include "MediaSession.h"
     27#include "PlatformMediaSession.h"
    2828
    2929#if ENABLE(VIDEO)
    … …  
    3838
    3939#if !LOG_DISABLED
    40 static const char* stateName(MediaSession::State state)
    41 {
    42 #define CASE(state) case MediaSession::state: return #state
     40static const char* stateName(PlatformMediaSession::State state)
     41{
     42#define CASE(state) case PlatformMediaSession::state: return #state
    4343    switch (state) {
    4444    CASE(Idle);
    … …  
    5353#endif
    5454
    55 std::unique_ptr<MediaSession> MediaSession::create(MediaSessionClient& client)
    56 {
    57     return std::make_unique<MediaSession>(client);
    58 }
    59 
    60 MediaSession::MediaSession(MediaSessionClient& client)
     55std::unique_ptr<PlatformMediaSession> PlatformMediaSession::create(PlatformMediaSessionClient& client)
     56{
     57    return std::make_unique<PlatformMediaSession>(client);
     58}
     59
     60PlatformMediaSession::PlatformMediaSession(PlatformMediaSessionClient& client)
    6161    : m_client(client)
    62     , m_clientDataBufferingTimer(*this, &MediaSession::clientDataBufferingTimerFired)
     62    , m_clientDataBufferingTimer(*this, &PlatformMediaSession::clientDataBufferingTimerFired)
    6363    , m_state(Idle)
    6464    , m_stateToRestore(Idle)
    … …  
    6969}
    7070
    71 MediaSession::~MediaSession()
     71PlatformMediaSession::~PlatformMediaSession()
    7272{
    7373    MediaSessionManager::sharedManager().removeSession(*this);
    7474}
    7575
    76 void MediaSession::setState(State state)
    77 {
    78     LOG(Media, "MediaSession::setState(%p) - %s", this, stateName(state));
     76void PlatformMediaSession::setState(State state)
     77{
     78    LOG(Media, "PlatformMediaSession::setState(%p) - %s", this, stateName(state));
    7979    m_state = state;
    8080}
    8181
    82 void MediaSession::beginInterruption(InterruptionType type)
    83 {
    84     LOG(Media, "MediaSession::beginInterruption(%p), state = %s, interruption count = %i", this, stateName(m_state), m_interruptionCount);
     82void PlatformMediaSession::beginInterruption(InterruptionType type)
     83{
     84    LOG(Media, "PlatformMediaSession::beginInterruption(%p), state = %s, interruption count = %i", this, stateName(m_state), m_interruptionCount);
    8585
    8686    if (++m_interruptionCount > 1 || (type == EnteringBackground && client().overrideBackgroundPlaybackRestriction()))
    … …  
    9494}
    9595
    96 void MediaSession::endInterruption(EndInterruptionFlags flags)
    97 {
    98     LOG(Media, "MediaSession::endInterruption(%p) - flags = %i, stateToRestore = %s, interruption count = %i", this, (int)flags, stateName(m_stateToRestore), m_interruptionCount);
     96void PlatformMediaSession::endInterruption(EndInterruptionFlags flags)
     97{
     98    LOG(Media, "PlatformMediaSession::endInterruption(%p) - flags = %i, stateToRestore = %s, interruption count = %i", this, (int)flags, stateName(m_stateToRestore), m_interruptionCount);
    9999
    100100    if (!m_interruptionCount) {
    101         LOG(Media, "MediaSession::endInterruption(%p) - !! ignoring spurious interruption end !!", this);
     101        LOG(Media, "PlatformMediaSession::endInterruption(%p) - !! ignoring spurious interruption end !!", this);
    102102        return;
    103103    }
    … …  
    114114}
    115115
    116 bool MediaSession::clientWillBeginPlayback()
     116bool PlatformMediaSession::clientWillBeginPlayback()
    117117{
    118118    if (m_notifyingClient)
    … …  
    130130}
    131131
    132 bool MediaSession::clientWillPausePlayback()
     132bool PlatformMediaSession::clientWillPausePlayback()
    133133{
    134134    if (m_notifyingClient)
    135135        return true;
    136136
    137     LOG(Media, "MediaSession::clientWillPausePlayback(%p)- state = %s", this, stateName(m_state));
     137    LOG(Media, "PlatformMediaSession::clientWillPausePlayback(%p)- state = %s", this, stateName(m_state));
    138138    if (state() == Interrupted) {
    139139        m_stateToRestore = Paused;
    … …  
    149149}
    150150
    151 void MediaSession::pauseSession()
    152 {
    153     LOG(Media, "MediaSession::pauseSession(%p)", this);
     151void PlatformMediaSession::pauseSession()
     152{
     153    LOG(Media, "PlatformMediaSession::pauseSession(%p)", this);
    154154    m_client.suspendPlayback();
    155155}
    156156
    157 MediaSession::MediaType MediaSession::mediaType() const
     157PlatformMediaSession::MediaType PlatformMediaSession::mediaType() const
    158158{
    159159    return m_client.mediaType();
    160160}
    161161
    162 MediaSession::MediaType MediaSession::presentationType() const
     162PlatformMediaSession::MediaType PlatformMediaSession::presentationType() const
    163163{
    164164    return m_client.presentationType();
    165165}
    166166
    167 String MediaSession::title() const
     167String PlatformMediaSession::title() const
    168168{
    169169    return m_client.mediaSessionTitle();
    170170}
    171171
    172 double MediaSession::duration() const
     172double PlatformMediaSession::duration() const
    173173{
    174174    return m_client.mediaSessionDuration();
    175175}
    176176
    177 double MediaSession::currentTime() const
     177double PlatformMediaSession::currentTime() const
    178178{
    179179    return m_client.mediaSessionCurrentTime();
    180180}
    181181   
    182 bool MediaSession::canReceiveRemoteControlCommands() const
     182bool PlatformMediaSession::canReceiveRemoteControlCommands() const
    183183{
    184184    return m_client.canReceiveRemoteControlCommands();
    185185}
    186186
    187 void MediaSession::didReceiveRemoteControlCommand(RemoteControlCommandType command)
     187void PlatformMediaSession::didReceiveRemoteControlCommand(RemoteControlCommandType command)
    188188{
    189189    m_client.didReceiveRemoteControlCommand(command);
    190190}
    191191
    192 void MediaSession::visibilityChanged()
     192void PlatformMediaSession::visibilityChanged()
    193193{
    194194    if (!m_clientDataBufferingTimer.isActive())
    … …  
    196196}
    197197
    198 void MediaSession::clientDataBufferingTimerFired()
    199 {
    200     LOG(Media, "MediaSession::clientDataBufferingTimerFired(%p)- visible = %s", this, m_client.elementIsHidden() ? "false" : "true");
     198void PlatformMediaSession::clientDataBufferingTimerFired()
     199{
     200    LOG(Media, "PlatformMediaSession::clientDataBufferingTimerFired(%p)- visible = %s", this, m_client.elementIsHidden() ? "false" : "true");
    201201
    202202    updateClientDataBuffering();
    … …  
    210210}
    211211
    212 void MediaSession::updateClientDataBuffering()
     212void PlatformMediaSession::updateClientDataBuffering()
    213213{
    214214    if (m_clientDataBufferingTimer.isActive())
    … …  
    218218}
    219219
    220 bool MediaSession::isHidden() const
     220bool PlatformMediaSession::isHidden() const
    221221{
    222222    return m_client.elementIsHidden();
    223223}
    224224
    225 MediaSession::DisplayType MediaSession::displayType() const
     225PlatformMediaSession::DisplayType PlatformMediaSession::displayType() const
    226226{
    227227    return m_client.displayType();
    228228}
    229229
    230 String MediaSessionClient::mediaSessionTitle() const
     230String PlatformMediaSessionClient::mediaSessionTitle() const
    231231{
    232232    return String();
    233233}
    234234
    235 double MediaSessionClient::mediaSessionDuration() const
     235double PlatformMediaSessionClient::mediaSessionDuration() const
    236236{
    237237    return MediaPlayer::invalidTime();
    238238}
    239239
    240 double MediaSessionClient::mediaSessionCurrentTime() const
     240double PlatformMediaSessionClient::mediaSessionCurrentTime() const
    241241{
    242242    return MediaPlayer::invalidTime();

  • trunk/Source/WebCore/platform/audio/PlatformMediaSession.h

    r185005 r185006  
    2424 */
    2525
    26 #ifndef MediaSession_h
    27 #define MediaSession_h
     26#ifndef PlatformMediaSession_h
     27#define PlatformMediaSession_h
    2828
    2929#include "MediaProducer.h"
    … …  
    3939
    4040class MediaPlaybackTarget;
    41 class MediaSessionClient;
     41class PlatformMediaSessionClient;
    4242
    43 class MediaSession
     43class PlatformMediaSession
    4444#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    4545    : public MediaPlaybackTargetClient
    … …  
    4747{
    4848public:
    49     static std::unique_ptr<MediaSession> create(MediaSessionClient&);
     49    static std::unique_ptr<PlatformMediaSession> create(PlatformMediaSessionClient&);
    5050
    51     MediaSession(MediaSessionClient&);
    52     virtual ~MediaSession();
     51    PlatformMediaSession(PlatformMediaSessionClient&);
     52    virtual ~PlatformMediaSession();
    5353
    5454    enum MediaType {
    … …  
    134134
    135135protected:
    136     MediaSessionClient& client() const { return m_client; }
     136    PlatformMediaSessionClient& client() const { return m_client; }
    137137
    138138private:
    … …  
    140140    void updateClientDataBuffering();
    141141
    142     MediaSessionClient& m_client;
     142    PlatformMediaSessionClient& m_client;
    143143    Timer m_clientDataBufferingTimer;
    144144    State m_state;
    … …  
    148148};
    149149
    150 class MediaSessionClient {
    151     WTF_MAKE_NONCOPYABLE(MediaSessionClient);
     150class PlatformMediaSessionClient {
     151    WTF_MAKE_NONCOPYABLE(PlatformMediaSessionClient);
    152152public:
    153     MediaSessionClient() { }
     153    PlatformMediaSessionClient() { }
    154154   
    155     virtual MediaSession::MediaType mediaType() const = 0;
    156     virtual MediaSession::MediaType presentationType() const = 0;
    157     virtual MediaSession::DisplayType displayType() const { return MediaSession::Normal; }
     155    virtual PlatformMediaSession::MediaType mediaType() const = 0;
     156    virtual PlatformMediaSession::MediaType presentationType() const = 0;
     157    virtual PlatformMediaSession::DisplayType displayType() const { return PlatformMediaSession::Normal; }
    158158
    159159    virtual void mayResumePlayback(bool shouldResume) = 0;
    … …  
    165165   
    166166    virtual bool canReceiveRemoteControlCommands() const = 0;
    167     virtual void didReceiveRemoteControlCommand(MediaSession::RemoteControlCommandType) = 0;
     167    virtual void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType) = 0;
    168168
    169169    virtual void setShouldBufferData(bool) { }
    … …  
    179179
    180180protected:
    181     virtual ~MediaSessionClient() { }
     181    virtual ~PlatformMediaSessionClient() { }
    182182};
    183183
    184184}
    185185
    186 #endif // MediaSession_h
     186#endif // PlatformMediaSession_h

  • trunk/Source/WebCore/platform/audio/ios/MediaSessionManagerIOS.h

    r182141 r185006  
    5454    MediaSessionManageriOS();
    5555
    56     virtual bool sessionWillBeginPlayback(MediaSession&) override;
    57     virtual void sessionWillEndPlayback(MediaSession&) override;
     56    virtual bool sessionWillBeginPlayback(PlatformMediaSession&) override;
     57    virtual void sessionWillEndPlayback(PlatformMediaSession&) override;
    5858   
    5959    void updateNowPlayingInfo();
    … …  
    6363    virtual void configureWireLessTargetMonitoring() override;
    6464
    65     virtual bool sessionCanLoadMedia(const MediaSession&) const override;
     65    virtual bool sessionCanLoadMedia(const PlatformMediaSession&) const override;
    6666   
    6767    RetainPtr<WebMediaSessionHelper> m_objcObserver;

  • trunk/Source/WebCore/platform/audio/ios/MediaSessionManagerIOS.mm

    r183181 r185006  
    3232#import "MediaPlayer.h"
    3333#import "MediaPlayerSPI.h"
    34 #import "MediaSession.h"
     34#import "PlatformMediaSession.h"
    3535#import "SoftLinking.h"
    3636#import "SystemMemory.h"
    … …  
    139139    static wkDeviceClass deviceClass = iosDeviceClass();
    140140    if (deviceClass == wkDeviceClassiPhone || deviceClass == wkDeviceClassiPod)
    141         addRestriction(MediaSession::Video, InlineVideoPlaybackRestricted);
     141        addRestriction(PlatformMediaSession::Video, InlineVideoPlaybackRestricted);
    142142
    143143    if (ramSize() < systemMemoryRequiredForVideoInBackgroundTabs) {
    144144        LOG(Media, "MediaSessionManageriOS::resetRestrictions - restricting video in background tabs because system memory = %zul", ramSize());
    145         addRestriction(MediaSession::Video, BackgroundTabPlaybackRestricted);
     145        addRestriction(PlatformMediaSession::Video, BackgroundTabPlaybackRestricted);
    146146    }
    147147
    148     addRestriction(MediaSession::Video, ConcurrentPlaybackNotPermitted);
    149     addRestriction(MediaSession::Video, BackgroundProcessPlaybackRestricted);
    150 
    151     removeRestriction(MediaSession::Audio, ConcurrentPlaybackNotPermitted);
    152     removeRestriction(MediaSession::Audio, BackgroundProcessPlaybackRestricted);
    153 
    154     removeRestriction(MediaSession::WebAudio, ConcurrentPlaybackNotPermitted);
    155     removeRestriction(MediaSession::WebAudio, BackgroundProcessPlaybackRestricted);
    156 
    157     removeRestriction(MediaSession::Audio, MetadataPreloadingNotPermitted);
    158     removeRestriction(MediaSession::Video, MetadataPreloadingNotPermitted);
    159 
    160     addRestriction(MediaSession::Audio, AutoPreloadingNotPermitted);
    161     addRestriction(MediaSession::Video, AutoPreloadingNotPermitted);
     148    addRestriction(PlatformMediaSession::Video, ConcurrentPlaybackNotPermitted);
     149    addRestriction(PlatformMediaSession::Video, BackgroundProcessPlaybackRestricted);
     150
     151    removeRestriction(PlatformMediaSession::Audio, ConcurrentPlaybackNotPermitted);
     152    removeRestriction(PlatformMediaSession::Audio, BackgroundProcessPlaybackRestricted);
     153
     154    removeRestriction(PlatformMediaSession::WebAudio, ConcurrentPlaybackNotPermitted);
     155    removeRestriction(PlatformMediaSession::WebAudio, BackgroundProcessPlaybackRestricted);
     156
     157    removeRestriction(PlatformMediaSession::Audio, MetadataPreloadingNotPermitted);
     158    removeRestriction(PlatformMediaSession::Video, MetadataPreloadingNotPermitted);
     159
     160    addRestriction(PlatformMediaSession::Audio, AutoPreloadingNotPermitted);
     161    addRestriction(PlatformMediaSession::Video, AutoPreloadingNotPermitted);
    162162}
    163163
    … …  
    169169void MediaSessionManageriOS::configureWireLessTargetMonitoring()
    170170{
    171     Vector<MediaSession*> sessions = this->sessions();
     171    Vector<PlatformMediaSession*> sessions = this->sessions();
    172172    bool requiresMonitoring = false;
    173173
    … …  
    187187}
    188188
    189 bool MediaSessionManageriOS::sessionWillBeginPlayback(MediaSession& session)
     189bool MediaSessionManageriOS::sessionWillBeginPlayback(PlatformMediaSession& session)
    190190{
    191191    if (!MediaSessionManager::sessionWillBeginPlayback(session))
    … …  
    196196}
    197197   
    198 void MediaSessionManageriOS::sessionWillEndPlayback(MediaSession& session)
     198void MediaSessionManageriOS::sessionWillEndPlayback(PlatformMediaSession& session)
    199199{
    200200    MediaSessionManager::sessionWillEndPlayback(session);
    … …  
    207207
    208208    MPNowPlayingInfoCenter *nowPlaying = (MPNowPlayingInfoCenter *)[getMPNowPlayingInfoCenterClass() defaultCenter];
    209     const MediaSession* currentSession = this->currentSession();
     209    const PlatformMediaSession* currentSession = this->currentSession();
    210210   
    211211    if (!currentSession) {
    … …  
    228228        [info setValue:@(currentTime) forKey:MPNowPlayingInfoPropertyElapsedPlaybackTime];
    229229   
    230     [info setValue:(currentSession->state() == MediaSession::Playing ? @YES : @NO) forKey:MPNowPlayingInfoPropertyPlaybackRate];
     230    [info setValue:(currentSession->state() == PlatformMediaSession::Playing ? @YES : @NO) forKey:MPNowPlayingInfoPropertyPlaybackRate];
    231231    [nowPlaying setNowPlayingInfo:info.get()];
    232232}
    233233
    234 bool MediaSessionManageriOS::sessionCanLoadMedia(const MediaSession& session) const
    235 {
    236     return session.state() == MediaSession::Playing || !session.isHidden() || session.displayType() == MediaSession::Optimized;
     234bool MediaSessionManageriOS::sessionCanLoadMedia(const PlatformMediaSession& session) const
     235{
     236    return session.state() == PlatformMediaSession::Playing || !session.isHidden() || session.displayType() == PlatformMediaSession::Optimized;
    237237}
    238238
    239239void MediaSessionManageriOS::externalOutputDeviceAvailableDidChange()
    240240{
    241     Vector<MediaSession*> sessionList = sessions();
     241    Vector<PlatformMediaSession*> sessionList = sessions();
    242242    bool haveTargets = [m_objcObserver hasWirelessTargetsAvailable];
    243243    for (auto* session : sessionList)
    … …  
    384384
    385385    NSUInteger type = [[[notification userInfo] objectForKey:AVAudioSessionInterruptionTypeKey] unsignedIntegerValue];
    386     MediaSession::EndInterruptionFlags flags = MediaSession::NoFlags;
     386    PlatformMediaSession::EndInterruptionFlags flags = PlatformMediaSession::NoFlags;
    387387
    388388    LOG(Media, "-[WebMediaSessionHelper interruption] - type = %i", (int)type);
    389389
    390390    if (type == AVAudioSessionInterruptionTypeEnded && [[[notification userInfo] objectForKey:AVAudioSessionInterruptionOptionKey] unsignedIntegerValue] == AVAudioSessionInterruptionOptionShouldResume)
    391         flags = MediaSession::MayResumePlaying;
     391        flags = PlatformMediaSession::MayResumePlaying;
    392392
    393393    WebThreadRun(^{
    … …  
    396396
    397397        if (type == AVAudioSessionInterruptionTypeBegan)
    398             _callback->beginInterruption(MediaSession::SystemInterruption);
     398            _callback->beginInterruption(PlatformMediaSession::SystemInterruption);
    399399        else
    400400            _callback->endInterruption(flags);

  • trunk/Source/WebCore/platform/audio/mac/MediaSessionManagerMac.cpp

    r182141 r185006  
    4040void MediaSessionManager::updateSessionState()
    4141{
    42     LOG(Media, "MediaSessionManager::updateSessionState() - types: Video(%d), Audio(%d), WebAudio(%d)", count(MediaSession::Video), count(MediaSession::Audio), count(MediaSession::WebAudio));
     42    LOG(Media, "MediaSessionManager::updateSessionState() - types: Video(%d), Audio(%d), WebAudio(%d)", count(PlatformMediaSession::Video), count(PlatformMediaSession::Audio), count(PlatformMediaSession::WebAudio));
    4343
    44     if (has(MediaSession::WebAudio))
     44    if (has(PlatformMediaSession::WebAudio))
    4545        AudioSession::sharedSession().setPreferredBufferSize(kWebAudioBufferSize);
    46     else if ((has(MediaSession::Video) || has(MediaSession::Audio)) && Settings::lowPowerVideoAudioBufferSizeEnabled()) {
     46    else if ((has(PlatformMediaSession::Video) || has(PlatformMediaSession::Audio)) && Settings::lowPowerVideoAudioBufferSizeEnabled()) {
    4747        // FIXME: <http://webkit.org/b/116725> Figure out why enabling the code below
    4848        // causes media LayoutTests to fail on 10.8.
    … …  
    6161        return;
    6262
    63     if (has(MediaSession::Video) || has(MediaSession::Audio))
     63    if (has(PlatformMediaSession::Video) || has(PlatformMediaSession::Audio))
    6464        AudioSession::sharedSession().setCategory(AudioSession::MediaPlayback);
    65     else if (has(MediaSession::WebAudio))
     65    else if (has(PlatformMediaSession::WebAudio))
    6666        AudioSession::sharedSession().setCategory(AudioSession::AmbientSound);
    6767#endif

  • trunk/Source/WebCore/platform/graphics/MediaPlayer.cpp

    r184814 r185006  
    13481348}
    13491349
    1350 void MediaPlayer::handlePlaybackCommand(MediaSession::RemoteControlCommandType command)
     1350void MediaPlayer::handlePlaybackCommand(PlatformMediaSession::RemoteControlCommandType command)
    13511351{
    13521352    m_client.mediaPlayerHandlePlaybackCommand(command);

  • trunk/Source/WebCore/platform/graphics/MediaPlayer.h

    r184814 r185006  
    3737#include "LayoutRect.h"
    3838#include "MediaPlayerEnums.h"
    39 #include "MediaSession.h"
    4039#include "NativeImagePtr.h"
    4140#include "PlatformLayer.h"
    4241#include "PlatformMediaResourceLoader.h"
     42#include "PlatformMediaSession.h"
    4343#include "Timer.h"
    4444#include "VideoTrackPrivate.h"
    … …  
    269269   
    270270    virtual bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) { return false; }
    271     virtual void mediaPlayerHandlePlaybackCommand(MediaSession::RemoteControlCommandType) { }
     271    virtual void mediaPlayerHandlePlaybackCommand(PlatformMediaSession::RemoteControlCommandType) { }
    272272
    273273    virtual String mediaPlayerSourceApplicationIdentifier() const { return emptyString(); }
    … …  
    595595
    596596    bool shouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&);
    597     void handlePlaybackCommand(MediaSession::RemoteControlCommandType);
     597    void handlePlaybackCommand(PlatformMediaSession::RemoteControlCommandType);
    598598    String sourceApplicationIdentifier() const;
    599599    Vector<String> preferredAudioCharacteristics() const;

  • trunk/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp

    r182240 r185006  
    622622#if ENABLE(WIRELESS_PLAYBACK_TARGET) && PLATFORM(IOS)
    623623    if (isCurrentPlaybackTargetWireless())
    624         m_player->handlePlaybackCommand(rate() ? MediaSession::PlayCommand : MediaSession::PauseCommand);
     624        m_player->handlePlaybackCommand(rate() ? PlatformMediaSession::PlayCommand : PlatformMediaSession::PauseCommand);
    625625#endif
    626626

  • trunk/Source/WebCore/platform/ios/RemoteCommandListenerIOS.mm

    r167590 r185006  
    5656            if (!weakThis)
    5757                return;
    58             weakThis->m_client.didReceiveRemoteControlCommand(MediaSession::PauseCommand);
     58            weakThis->m_client.didReceiveRemoteControlCommand(PlatformMediaSession::PauseCommand);
    5959        });
    6060
    … …  
    6666            if (!weakThis)
    6767                return;
    68             weakThis->m_client.didReceiveRemoteControlCommand(MediaSession::PlayCommand);
     68            weakThis->m_client.didReceiveRemoteControlCommand(PlatformMediaSession::PlayCommand);
    6969        });
    7070
    … …  
    7676            if (!weakThis)
    7777                return;
    78             weakThis->m_client.didReceiveRemoteControlCommand(MediaSession::TogglePlayPauseCommand);
     78            weakThis->m_client.didReceiveRemoteControlCommand(PlatformMediaSession::TogglePlayPauseCommand);
    7979        });
    8080
    … …  
    8686
    8787        MPSeekCommandEvent* seekEvent = static_cast<MPSeekCommandEvent *>(event);
    88         MediaSession::RemoteControlCommandType command = [seekEvent type] == MPSeekCommandEventTypeBeginSeeking ? MediaSession::BeginSeekingBackwardCommand : MediaSession::EndSeekingBackwardCommand;
     88        PlatformMediaSession::RemoteControlCommandType command = [seekEvent type] == MPSeekCommandEventTypeBeginSeeking ? PlatformMediaSession::BeginSeekingBackwardCommand : PlatformMediaSession::EndSeekingBackwardCommand;
    8989
    9090        callOnMainThread([weakThis, command] {
    … …  
    101101        MPSeekCommandEvent* seekEvent = static_cast<MPSeekCommandEvent *>(event);
    102102
    103         MediaSession::RemoteControlCommandType command = [seekEvent type] == MPSeekCommandEventTypeBeginSeeking ? MediaSession::BeginSeekingForwardCommand : MediaSession::EndSeekingForwardCommand;
     103        PlatformMediaSession::RemoteControlCommandType command = [seekEvent type] == MPSeekCommandEventTypeBeginSeeking ? PlatformMediaSession::BeginSeekingForwardCommand : PlatformMediaSession::EndSeekingForwardCommand;
    104104
    105105        callOnMainThread([weakThis, command] {

  • trunk/Source/WebCore/testing/Internals.cpp

    r184990 r185006  
    25792579void Internals::beginMediaSessionInterruption()
    25802580{
    2581     MediaSessionManager::sharedManager().beginInterruption(MediaSession::SystemInterruption);
     2581    MediaSessionManager::sharedManager().beginInterruption(PlatformMediaSession::SystemInterruption);
    25822582}
    25832583
    25842584void Internals::endMediaSessionInterruption(const String& flagsString)
    25852585{
    2586     MediaSession::EndInterruptionFlags flags = MediaSession::NoFlags;
     2586    PlatformMediaSession::EndInterruptionFlags flags = PlatformMediaSession::NoFlags;
    25872587
    25882588    if (equalIgnoringCase(flagsString, "MayResumePlaying"))
    2589         flags = MediaSession::MayResumePlaying;
     2589        flags = PlatformMediaSession::MayResumePlaying;
    25902590   
    25912591    MediaSessionManager::sharedManager().endInterruption(flags);
    … …  
    26042604void Internals::setMediaSessionRestrictions(const String& mediaTypeString, const String& restrictionsString, ExceptionCode& ec)
    26052605{
    2606     MediaSession::MediaType mediaType = MediaSession::None;
     2606    PlatformMediaSession::MediaType mediaType = PlatformMediaSession::None;
    26072607    if (equalIgnoringCase(mediaTypeString, "Video"))
    2608         mediaType = MediaSession::Video;
     2608        mediaType = PlatformMediaSession::Video;
    26092609    else if (equalIgnoringCase(mediaTypeString, "Audio"))
    2610         mediaType = MediaSession::Audio;
     2610        mediaType = PlatformMediaSession::Audio;
    26112611    else if (equalIgnoringCase(mediaTypeString, "WebAudio"))
    2612         mediaType = MediaSession::WebAudio;
     2612        mediaType = PlatformMediaSession::WebAudio;
    26132613    else {
    26142614        ec = INVALID_ACCESS_ERR;
    … …  
    26832683void Internals::postRemoteControlCommand(const String& commandString, ExceptionCode& ec)
    26842684{
    2685     MediaSession::RemoteControlCommandType command;
     2685    PlatformMediaSession::RemoteControlCommandType command;
    26862686   
    26872687    if (equalIgnoringCase(commandString, "Play"))
    2688         command = MediaSession::PlayCommand;
     2688        command = PlatformMediaSession::PlayCommand;
    26892689    else if (equalIgnoringCase(commandString, "Pause"))
    2690         command = MediaSession::PauseCommand;
     2690        command = PlatformMediaSession::PauseCommand;
    26912691    else if (equalIgnoringCase(commandString, "Stop"))
    2692         command = MediaSession::StopCommand;
     2692        command = PlatformMediaSession::StopCommand;
    26932693    else if (equalIgnoringCase(commandString, "TogglePlayPause"))
    2694         command = MediaSession::TogglePlayPauseCommand;
     2694        command = PlatformMediaSession::TogglePlayPauseCommand;
    26952695    else if (equalIgnoringCase(commandString, "BeginSeekingBackward"))
    2696         command = MediaSession::BeginSeekingBackwardCommand;
     2696        command = PlatformMediaSession::BeginSeekingBackwardCommand;
    26972697    else if (equalIgnoringCase(commandString, "EndSeekingBackward"))
    2698         command = MediaSession::EndSeekingBackwardCommand;
     2698        command = PlatformMediaSession::EndSeekingBackwardCommand;
    26992699    else if (equalIgnoringCase(commandString, "BeginSeekingForward"))
    2700         command = MediaSession::BeginSeekingForwardCommand;
     2700        command = PlatformMediaSession::BeginSeekingForwardCommand;
    27012701    else if (equalIgnoringCase(commandString, "EndSeekingForward"))
    2702         command = MediaSession::EndSeekingForwardCommand;
     2702        command = PlatformMediaSession::EndSeekingForwardCommand;
    27032703    else {
    27042704        ec = INVALID_ACCESS_ERR;
Note: See TracChangeset for help on using the changeset viewer.