Attachment #402679 for bug #212392

View Details Raw Unified Return to Bug 212392

| Differences between



2020-06-24  David Kilzer  <ddkilzer@apple.com>

        Use ObjectIdentifier<> instead of uint64_t for context IDs in VideoFullscreenManagerProxy
        <https://webkit.org/b/212392>
        <rdar://problem/61799040>

        Reviewed by Youenn Fablet.

        Switch from uint64_t to WebKit::PlaybackSessionContextIdentifier
        for contextId values.

        * Scripts/webkit/messages.py:
        (types_that_cannot_be_forward_declared):
        - Add WebKit::PlaybackSessionContextIdentifier to list.
        * UIProcess/Cocoa/PlaybackSessionManagerProxy.h:
        (WebKit::PlaybackSessionManagerProxy::controlsManagerContextId const):
        * UIProcess/Cocoa/PlaybackSessionManagerProxy.messages.in:
        * UIProcess/Cocoa/PlaybackSessionManagerProxy.mm:
        (WebKit::PlaybackSessionManagerProxy::createModelAndInterface):
        (WebKit::PlaybackSessionManagerProxy::ensureModelAndInterface):
        (WebKit::PlaybackSessionManagerProxy::ensureModel):
        (WebKit::PlaybackSessionManagerProxy::ensureInterface):
        (WebKit::PlaybackSessionManagerProxy::addClientForContext):
        (WebKit::PlaybackSessionManagerProxy::removeClientForContext):
        (WebKit::PlaybackSessionManagerProxy::setUpPlaybackControlsManagerWithID):
        (WebKit::PlaybackSessionManagerProxy::clearPlaybackControlsManager):
        (WebKit::PlaybackSessionManagerProxy::currentTimeChanged):
        (WebKit::PlaybackSessionManagerProxy::bufferedTimeChanged):
        (WebKit::PlaybackSessionManagerProxy::seekableRangesVectorChanged):
        (WebKit::PlaybackSessionManagerProxy::canPlayFastReverseChanged):
        (WebKit::PlaybackSessionManagerProxy::audioMediaSelectionOptionsChanged):
        (WebKit::PlaybackSessionManagerProxy::legibleMediaSelectionOptionsChanged):
        (WebKit::PlaybackSessionManagerProxy::audioMediaSelectionIndexChanged):
        (WebKit::PlaybackSessionManagerProxy::legibleMediaSelectionIndexChanged):
        (WebKit::PlaybackSessionManagerProxy::externalPlaybackPropertiesChanged):
        (WebKit::PlaybackSessionManagerProxy::wirelessVideoPlaybackDisabledChanged):
        (WebKit::PlaybackSessionManagerProxy::mutedChanged):
        (WebKit::PlaybackSessionManagerProxy::volumeChanged):
        (WebKit::PlaybackSessionManagerProxy::durationChanged):
        (WebKit::PlaybackSessionManagerProxy::playbackStartedTimeChanged):
        (WebKit::PlaybackSessionManagerProxy::rateChanged):
        (WebKit::PlaybackSessionManagerProxy::pictureInPictureSupportedChanged):
        (WebKit::PlaybackSessionManagerProxy::handleControlledElementIDResponse const):
        (WebKit::PlaybackSessionManagerProxy::play):
        (WebKit::PlaybackSessionManagerProxy::pause):
        (WebKit::PlaybackSessionManagerProxy::togglePlayState):
        (WebKit::PlaybackSessionManagerProxy::beginScrubbing):
        (WebKit::PlaybackSessionManagerProxy::endScrubbing):
        (WebKit::PlaybackSessionManagerProxy::seekToTime):
        (WebKit::PlaybackSessionManagerProxy::fastSeek):
        (WebKit::PlaybackSessionManagerProxy::beginScanningForward):
        (WebKit::PlaybackSessionManagerProxy::beginScanningBackward):
        (WebKit::PlaybackSessionManagerProxy::endScanning):
        (WebKit::PlaybackSessionManagerProxy::selectAudioMediaOption):
        (WebKit::PlaybackSessionManagerProxy::selectLegibleMediaOption):
        (WebKit::PlaybackSessionManagerProxy::togglePictureInPicture):
        (WebKit::PlaybackSessionManagerProxy::toggleMuted):
        (WebKit::PlaybackSessionManagerProxy::setMuted):
        (WebKit::PlaybackSessionManagerProxy::setVolume):
        (WebKit::PlaybackSessionManagerProxy::setPlayingOnSecondScreen):
        - Remove MESSAGE_CHECK_CONTEXTID() since it is now redundant.
        * UIProcess/Cocoa/VideoFullscreenManagerProxy.h:
        * UIProcess/Cocoa/VideoFullscreenManagerProxy.messages.in:
        * UIProcess/Cocoa/VideoFullscreenManagerProxy.mm:
        (WebKit::VideoFullscreenModelContext::VideoFullscreenModelContext):
        (WebKit::VideoFullscreenManagerProxy::requestRouteSharingPolicyAndContextUID):
        (WebKit::VideoFullscreenManagerProxy::createModelAndInterface):
        (WebKit::VideoFullscreenManagerProxy::ensureModelAndInterface):
        (WebKit::VideoFullscreenManagerProxy::ensureModel):
        (WebKit::VideoFullscreenManagerProxy::ensureInterface):
        (WebKit::VideoFullscreenManagerProxy::findInterface):
        (WebKit::VideoFullscreenManagerProxy::addClientForContext):
        (WebKit::VideoFullscreenManagerProxy::removeClientForContext):
        (WebKit::VideoFullscreenManagerProxy::setupFullscreenWithID):
        (WebKit::VideoFullscreenManagerProxy::setHasVideo):
        (WebKit::VideoFullscreenManagerProxy::setVideoDimensions):
        (WebKit::VideoFullscreenManagerProxy::enterFullscreen):
        (WebKit::VideoFullscreenManagerProxy::exitFullscreen):
        (WebKit::VideoFullscreenManagerProxy::exitFullscreenWithoutAnimationToMode):
        (WebKit::VideoFullscreenManagerProxy::setInlineRect):
        (WebKit::VideoFullscreenManagerProxy::setHasVideoContentLayer):
        (WebKit::VideoFullscreenManagerProxy::cleanupFullscreen):
        (WebKit::VideoFullscreenManagerProxy::preparedToReturnToInline):
        (WebKit::VideoFullscreenManagerProxy::preparedToExitFullscreen):
        (WebKit::VideoFullscreenManagerProxy::requestFullscreenMode):
        (WebKit::VideoFullscreenManagerProxy::requestUpdateInlineRect):
        (WebKit::VideoFullscreenManagerProxy::requestVideoContentLayer):
        (WebKit::VideoFullscreenManagerProxy::returnVideoContentLayer):
        (WebKit::VideoFullscreenManagerProxy::didSetupFullscreen):
        (WebKit::VideoFullscreenManagerProxy::willExitFullscreen):
        (WebKit::VideoFullscreenManagerProxy::didExitFullscreen):
        (WebKit::VideoFullscreenManagerProxy::didEnterFullscreen):
        (WebKit::VideoFullscreenManagerProxy::didCleanupFullscreen):
        (WebKit::VideoFullscreenManagerProxy::setVideoLayerFrame):
        (WebKit::VideoFullscreenManagerProxy::setVideoLayerGravity):
        (WebKit::VideoFullscreenManagerProxy::fullscreenModeChanged):
        (WebKit::VideoFullscreenManagerProxy::fullscreenMayReturnToInline):
        - Remove MESSAGE_CHECK_CONTEXTID() since it is now redundant.
        * WebKit.xcodeproj/project.pbxproj:
        - Add PlaybackSessionContextIdentifier.h to the project.
        * WebProcess/cocoa/PlaybackSessionContextIdentifier.h: Add.
        * WebProcess/cocoa/PlaybackSessionManager.h:
        * WebProcess/cocoa/PlaybackSessionManager.messages.in:
        * WebProcess/cocoa/PlaybackSessionManager.mm:
        (WebKit::PlaybackSessionInterfaceContext::PlaybackSessionInterfaceContext):
        (WebKit::PlaybackSessionManager::createModelAndInterface):
        (WebKit::PlaybackSessionManager::ensureModelAndInterface):
        (WebKit::PlaybackSessionManager::ensureModel):
        (WebKit::PlaybackSessionManager::ensureInterface):
        (WebKit::PlaybackSessionManager::removeContext):
        (WebKit::PlaybackSessionManager::addClientForContext):
        (WebKit::PlaybackSessionManager::removeClientForContext):
        (WebKit::PlaybackSessionManager::setUpPlaybackControlsManager):
        (WebKit::PlaybackSessionManager::clearPlaybackControlsManager):
        (WebKit::PlaybackSessionManager::contextIdForMediaElement):
        (WebKit::PlaybackSessionManager::durationChanged):
        (WebKit::PlaybackSessionManager::currentTimeChanged):
        (WebKit::PlaybackSessionManager::bufferedTimeChanged):
        (WebKit::PlaybackSessionManager::playbackStartedTimeChanged):
        (WebKit::PlaybackSessionManager::rateChanged):
        (WebKit::PlaybackSessionManager::seekableRangesChanged):
        (WebKit::PlaybackSessionManager::canPlayFastReverseChanged):
        (WebKit::PlaybackSessionManager::audioMediaSelectionOptionsChanged):
        (WebKit::PlaybackSessionManager::legibleMediaSelectionOptionsChanged):
        (WebKit::PlaybackSessionManager::externalPlaybackChanged):
        (WebKit::PlaybackSessionManager::audioMediaSelectionIndexChanged):
        (WebKit::PlaybackSessionManager::legibleMediaSelectionIndexChanged):
        (WebKit::PlaybackSessionManager::wirelessVideoPlaybackDisabledChanged):
        (WebKit::PlaybackSessionManager::mutedChanged):
        (WebKit::PlaybackSessionManager::volumeChanged):
        (WebKit::PlaybackSessionManager::isPictureInPictureSupportedChanged):
        (WebKit::PlaybackSessionManager::play):
        (WebKit::PlaybackSessionManager::pause):
        (WebKit::PlaybackSessionManager::togglePlayState):
        (WebKit::PlaybackSessionManager::beginScrubbing):
        (WebKit::PlaybackSessionManager::endScrubbing):
        (WebKit::PlaybackSessionManager::seekToTime):
        (WebKit::PlaybackSessionManager::fastSeek):
        (WebKit::PlaybackSessionManager::beginScanningForward):
        (WebKit::PlaybackSessionManager::beginScanningBackward):
        (WebKit::PlaybackSessionManager::endScanning):
        (WebKit::PlaybackSessionManager::selectAudioMediaOption):
        (WebKit::PlaybackSessionManager::selectLegibleMediaOption):
        (WebKit::PlaybackSessionManager::handleControlledElementIDRequest):
        (WebKit::PlaybackSessionManager::togglePictureInPicture):
        (WebKit::PlaybackSessionManager::toggleMuted):
        (WebKit::PlaybackSessionManager::setMuted):
        (WebKit::PlaybackSessionManager::setVolume):
        (WebKit::PlaybackSessionManager::setPlayingOnSecondScreen):
        (WebKit::nextContextId): Delete.
        - Replace with PlaybackSessionContextIdentifier::generate().
        * WebProcess/cocoa/VideoFullscreenManager.h:
        (WebKit::VideoFullscreenInterfaceContext::create):
        * WebProcess/cocoa/VideoFullscreenManager.messages.in:
        * WebProcess/cocoa/VideoFullscreenManager.mm:
        (WebKit::VideoFullscreenInterfaceContext::VideoFullscreenInterfaceContext):
        (WebKit::VideoFullscreenManager::createModelAndInterface):
        (WebKit::VideoFullscreenManager::ensureModelAndInterface):
        (WebKit::VideoFullscreenManager::ensureModel):
        (WebKit::VideoFullscreenManager::ensureInterface):
        (WebKit::VideoFullscreenManager::removeContext):
        (WebKit::VideoFullscreenManager::addClientForContext):
        (WebKit::VideoFullscreenManager::removeClientForContext):
        (WebKit::VideoFullscreenManager::enterVideoFullscreenForVideoElement):
        (WebKit::VideoFullscreenManager::exitVideoFullscreenForVideoElement):
        (WebKit::VideoFullscreenManager::exitVideoFullscreenToModeWithoutAnimation):
        (WebKit::VideoFullscreenManager::hasVideoChanged):
        (WebKit::VideoFullscreenManager::videoDimensionsChanged):
        (WebKit::VideoFullscreenManager::requestFullscreenMode):
        (WebKit::VideoFullscreenManager::fullscreenModeChanged):
        (WebKit::VideoFullscreenManager::requestUpdateInlineRect):
        (WebKit::VideoFullscreenManager::requestVideoContentLayer):
        (WebKit::VideoFullscreenManager::returnVideoContentLayer):
        (WebKit::VideoFullscreenManager::didSetupFullscreen):
        (WebKit::VideoFullscreenManager::willExitFullscreen):
        (WebKit::VideoFullscreenManager::didEnterFullscreen):
        (WebKit::VideoFullscreenManager::didExitFullscreen):
        (WebKit::VideoFullscreenManager::didCleanupFullscreen):
        (WebKit::VideoFullscreenManager::setVideoLayerGravityEnum):
        (WebKit::VideoFullscreenManager::fullscreenMayReturnToInline):
        (WebKit::VideoFullscreenManager::requestRouteSharingPolicyAndContextUID):
        (WebKit::VideoFullscreenManager::setVideoLayerFrameFenced):

2020-06-23  Wenson Hsieh  <wenson_hsieh@apple.com>

        REGRESSION (r244633): Mail flashes when copying text in an email

Lines 241-246 def types_that_cannot_be_forward_declared(): a/Source/WebKit/Scripts/webkit/messages.py_sec1
- a/Source/WebKit/Scripts/webkit/messages.py +1 lines
241	'WebKit::MDNSRegisterIdentifier',	241	'WebKit::MDNSRegisterIdentifier',
242	'WebKit::MediaPlayerPrivateRemoteIdentifier',	242	'WebKit::MediaPlayerPrivateRemoteIdentifier',
243	'WebKit::MediaRecorderIdentifier',	243	'WebKit::MediaRecorderIdentifier',
		244	'WebKit::PlaybackSessionContextIdentifier',
244	'WebKit::PluginProcessType',	245	'WebKit::PluginProcessType',
245	'WebKit::RemoteAudioDestinationIdentifier',	246	'WebKit::RemoteAudioDestinationIdentifier',
246	'WebKit::RemoteAudioSessionIdentifier',	247	'WebKit::RemoteAudioSessionIdentifier',



#if PLATFORM(IOS_FAMILY) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))

#include "MessageReceiver.h"
#include "PlaybackSessionContextIdentifier.h"
#include <WebCore/GraphicsLayer.h>
#include <WebCore/MediaSelectionOption.h>
#include <WebCore/PlatformView.h>


class PlaybackSessionModelContext final: public RefCounted<PlaybackSessionModelContext>, public WebCore::PlaybackSessionModel  {
public:
    static Ref<PlaybackSessionModelContext> create(PlaybackSessionManagerProxy& manager, PlaybackSessionContextIdentifier contextId)
    {
        return adoptRef(*new PlaybackSessionModelContext(manager, contextId));
    }

private:
    friend class VideoFullscreenModelContext;

    PlaybackSessionModelContext(PlaybackSessionManagerProxy& manager, PlaybackSessionContextIdentifier contextId)
        : m_manager(&manager)
        , m_contextId(contextId)
    {

    bool isPictureInPictureActive() const final { return m_pictureInPictureActive; }

    PlaybackSessionManagerProxy* m_manager;
    PlaybackSessionContextIdentifier m_contextId;
    HashSet<WebCore::PlaybackSessionModelClient*> m_clients;
    double m_playbackStartedTime { 0 };
    bool m_playbackStartedTimeNeedsUpdate { false };

    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;

    typedef std::tuple<RefPtr<PlaybackSessionModelContext>, RefPtr<PlatformPlaybackSessionInterface>> ModelInterfaceTuple;
    ModelInterfaceTuple createModelAndInterface(PlaybackSessionContextIdentifier);
    ModelInterfaceTuple& ensureModelAndInterface(PlaybackSessionContextIdentifier);
    PlaybackSessionModelContext& ensureModel(PlaybackSessionContextIdentifier);
    PlatformPlaybackSessionInterface& ensureInterface(PlaybackSessionContextIdentifier);
    void addClientForContext(PlaybackSessionContextIdentifier);
    void removeClientForContext(PlaybackSessionContextIdentifier);

    PlaybackSessionContextIdentifier controlsManagerContextId() const { return m_controlsManagerContextId; }

    // Messages from PlaybackSessionManager
    void setUpPlaybackControlsManagerWithID(PlaybackSessionContextIdentifier);
    void clearPlaybackControlsManager();
    void currentTimeChanged(PlaybackSessionContextIdentifier, double currentTime, double hostTime);
    void bufferedTimeChanged(PlaybackSessionContextIdentifier, double bufferedTime);
    void seekableRangesVectorChanged(PlaybackSessionContextIdentifier, Vector<std::pair<double, double>> ranges, double lastModifiedTime, double liveUpdateInterval);
    void canPlayFastReverseChanged(PlaybackSessionContextIdentifier, bool value);
    void audioMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier, Vector<WebCore::MediaSelectionOption> options, uint64_t selectedIndex);
    void legibleMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier, Vector<WebCore::MediaSelectionOption> options, uint64_t selectedIndex);
    void audioMediaSelectionIndexChanged(PlaybackSessionContextIdentifier, uint64_t selectedIndex);
    void legibleMediaSelectionIndexChanged(PlaybackSessionContextIdentifier, uint64_t selectedIndex);
    void externalPlaybackPropertiesChanged(PlaybackSessionContextIdentifier, bool enabled, uint32_t targetType, String localizedDeviceName);
    void wirelessVideoPlaybackDisabledChanged(PlaybackSessionContextIdentifier, bool);
    void durationChanged(PlaybackSessionContextIdentifier, double duration);
    void playbackStartedTimeChanged(PlaybackSessionContextIdentifier, double playbackStartedTime);
    void rateChanged(PlaybackSessionContextIdentifier, bool isPlaying, double rate);
    void handleControlledElementIDResponse(PlaybackSessionContextIdentifier, String) const;
    void mutedChanged(PlaybackSessionContextIdentifier, bool muted);
    void volumeChanged(PlaybackSessionContextIdentifier, double volume);
    void pictureInPictureSupportedChanged(PlaybackSessionContextIdentifier, bool pictureInPictureSupported);

    // Messages to PlaybackSessionManager
    void play(PlaybackSessionContextIdentifier);
    void pause(PlaybackSessionContextIdentifier);
    void togglePlayState(PlaybackSessionContextIdentifier);
    void beginScrubbing(PlaybackSessionContextIdentifier);
    void endScrubbing(PlaybackSessionContextIdentifier);
    void seekToTime(PlaybackSessionContextIdentifier, double time, double before, double after);
    void fastSeek(PlaybackSessionContextIdentifier, double time);
    void beginScanningForward(PlaybackSessionContextIdentifier);
    void beginScanningBackward(PlaybackSessionContextIdentifier);
    void endScanning(PlaybackSessionContextIdentifier);
    void selectAudioMediaOption(PlaybackSessionContextIdentifier, uint64_t index);
    void selectLegibleMediaOption(PlaybackSessionContextIdentifier, uint64_t index);
    void togglePictureInPicture(PlaybackSessionContextIdentifier);
    void toggleMuted(PlaybackSessionContextIdentifier);
    void setMuted(PlaybackSessionContextIdentifier, bool);
    void setVolume(PlaybackSessionContextIdentifier, double);
    void setPlayingOnSecondScreen(PlaybackSessionContextIdentifier, bool);

    WebPageProxy* m_page;
    HashMap<PlaybackSessionContextIdentifier, ModelInterfaceTuple> m_contextMap;
    PlaybackSessionContextIdentifier m_controlsManagerContextId;
    HashCountedSet<PlaybackSessionContextIdentifier> m_clientCounts;
};

} // namespace WebKit




#if PLATFORM(IOS_FAMILY) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
messages -> PlaybackSessionManagerProxy {
    CurrentTimeChanged(WebKit::PlaybackSessionContextIdentifier contextId, double currentTime, double hostTime)
    BufferedTimeChanged(WebKit::PlaybackSessionContextIdentifier contextId, double bufferedTime)
    SeekableRangesVectorChanged(WebKit::PlaybackSessionContextIdentifier contextId, Vector<std::pair<double, double>> ranges, double lastModifiedTime, double liveUpdateInterval)
    CanPlayFastReverseChanged(WebKit::PlaybackSessionContextIdentifier contextId, bool value)
    AudioMediaSelectionOptionsChanged(WebKit::PlaybackSessionContextIdentifier contextId, Vector<WebCore::MediaSelectionOption> options, uint64_t selectedIndex)
    LegibleMediaSelectionOptionsChanged(WebKit::PlaybackSessionContextIdentifier contextId, Vector<WebCore::MediaSelectionOption> options, uint64_t selectedIndex)
    AudioMediaSelectionIndexChanged(WebKit::PlaybackSessionContextIdentifier contextId, uint64_t selectedIndex)
    LegibleMediaSelectionIndexChanged(WebKit::PlaybackSessionContextIdentifier contextId, uint64_t selectedIndex)
    ExternalPlaybackPropertiesChanged(WebKit::PlaybackSessionContextIdentifier contextId, bool enabled, uint32_t targetType, String localizedDeviceName)
    WirelessVideoPlaybackDisabledChanged(WebKit::PlaybackSessionContextIdentifier contextId, bool disabled)
    DurationChanged(WebKit::PlaybackSessionContextIdentifier contextId, double duration)
    PlaybackStartedTimeChanged(WebKit::PlaybackSessionContextIdentifier contextId, double playbackStartedTime)
    RateChanged(WebKit::PlaybackSessionContextIdentifier contextId, bool isPlaying, double rate)
    MutedChanged(WebKit::PlaybackSessionContextIdentifier contextId, bool muted);
    VolumeChanged(WebKit::PlaybackSessionContextIdentifier contextId, double volume);
    PictureInPictureSupportedChanged(WebKit::PlaybackSessionContextIdentifier contextId, bool pictureInPictureSupported)
    SetUpPlaybackControlsManagerWithID(WebKit::PlaybackSessionContextIdentifier contextId)
    ClearPlaybackControlsManager()

    HandleControlledElementIDResponse(WebKit::PlaybackSessionContextIdentifier contextId, String id)
}
#endif



/*
 * Copyright (C) 2016-2020 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

#import "WebPageProxy.h"
#import "WebProcessProxy.h"

#define MESSAGE_CHECK_CONTEXTID(identifier) MESSAGE_CHECK_BASE(m_contextMap.isValidKey(identifier), m_page->process().connection())

namespace WebKit {
using namespace WebCore;


        interface->invalidate();
}

PlaybackSessionManagerProxy::ModelInterfaceTuple PlaybackSessionManagerProxy::createModelAndInterface(PlaybackSessionContextIdentifier contextId)
{
    Ref<PlaybackSessionModelContext> model = PlaybackSessionModelContext::create(*this, contextId);
    Ref<PlatformPlaybackSessionInterface> interface = PlatformPlaybackSessionInterface::create(model);

    return std::make_tuple(WTFMove(model), WTFMove(interface));
}

PlaybackSessionManagerProxy::ModelInterfaceTuple& PlaybackSessionManagerProxy::ensureModelAndInterface(PlaybackSessionContextIdentifier contextId)
{
    auto addResult = m_contextMap.add(contextId, ModelInterfaceTuple());
    if (addResult.isNewEntry)

    return addResult.iterator->value;
}

PlaybackSessionModelContext& PlaybackSessionManagerProxy::ensureModel(PlaybackSessionContextIdentifier contextId)
{
    return *std::get<0>(ensureModelAndInterface(contextId));
}

PlatformPlaybackSessionInterface& PlaybackSessionManagerProxy::ensureInterface(PlaybackSessionContextIdentifier contextId)
{
    return *std::get<1>(ensureModelAndInterface(contextId));
}

void PlaybackSessionManagerProxy::addClientForContext(PlaybackSessionContextIdentifier contextId)
{
    m_clientCounts.add(contextId);
}

void PlaybackSessionManagerProxy::removeClientForContext(PlaybackSessionContextIdentifier contextId)
{
    if (!m_clientCounts.remove(contextId))
        return;


#pragma mark Messages from PlaybackSessionManager

void PlaybackSessionManagerProxy::setUpPlaybackControlsManagerWithID(PlaybackSessionContextIdentifier contextId)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    if (m_controlsManagerContextId == contextId)
        return;


        return;

    removeClientForContext(m_controlsManagerContextId);
    m_controlsManagerContextId = { };
    m_page->videoControlsManagerDidChange();
}

void PlaybackSessionManagerProxy::currentTimeChanged(PlaybackSessionContextIdentifier contextId, double currentTime, double hostTime)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).currentTimeChanged(currentTime);
}

void PlaybackSessionManagerProxy::bufferedTimeChanged(PlaybackSessionContextIdentifier contextId, double bufferedTime)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).bufferedTimeChanged(bufferedTime);
}

void PlaybackSessionManagerProxy::seekableRangesVectorChanged(PlaybackSessionContextIdentifier contextId, Vector<std::pair<double, double>> ranges, double lastModifiedTime, double liveUpdateInterval)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    Ref<TimeRanges> timeRanges = TimeRanges::create();
    for (const auto& range : ranges) {
        ASSERT(isfinite(range.first));

    ensureModel(contextId).seekableRangesChanged(timeRanges, lastModifiedTime, liveUpdateInterval);
}

void PlaybackSessionManagerProxy::canPlayFastReverseChanged(PlaybackSessionContextIdentifier contextId, bool value)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).canPlayFastReverseChanged(value);
}

void PlaybackSessionManagerProxy::audioMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier contextId, Vector<MediaSelectionOption> options, uint64_t selectedIndex)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).audioMediaSelectionOptionsChanged(options, selectedIndex);
}

void PlaybackSessionManagerProxy::legibleMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier contextId, Vector<MediaSelectionOption> options, uint64_t selectedIndex)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).legibleMediaSelectionOptionsChanged(options, selectedIndex);
}

void PlaybackSessionManagerProxy::audioMediaSelectionIndexChanged(PlaybackSessionContextIdentifier contextId, uint64_t selectedIndex)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).audioMediaSelectionIndexChanged(selectedIndex);
}

void PlaybackSessionManagerProxy::legibleMediaSelectionIndexChanged(PlaybackSessionContextIdentifier contextId, uint64_t selectedIndex)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).legibleMediaSelectionIndexChanged(selectedIndex);
}

void PlaybackSessionManagerProxy::externalPlaybackPropertiesChanged(PlaybackSessionContextIdentifier contextId, bool enabled, uint32_t targetType, String localizedDeviceName)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    PlaybackSessionModel::ExternalPlaybackTargetType type = static_cast<PlaybackSessionModel::ExternalPlaybackTargetType>(targetType);
    ASSERT(type == PlaybackSessionModel::TargetTypeAirPlay || type == PlaybackSessionModel::TargetTypeTVOut || type == PlaybackSessionModel::TargetTypeNone);

    ensureModel(contextId).externalPlaybackChanged(enabled, type, localizedDeviceName);
}

void PlaybackSessionManagerProxy::wirelessVideoPlaybackDisabledChanged(PlaybackSessionContextIdentifier contextId, bool disabled)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).wirelessVideoPlaybackDisabledChanged(disabled);
}

void PlaybackSessionManagerProxy::mutedChanged(PlaybackSessionContextIdentifier contextId, bool muted)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).mutedChanged(muted);
}

void PlaybackSessionManagerProxy::volumeChanged(PlaybackSessionContextIdentifier contextId, double volume)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).volumeChanged(volume);
}

void PlaybackSessionManagerProxy::durationChanged(PlaybackSessionContextIdentifier contextId, double duration)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).durationChanged(duration);
}

void PlaybackSessionManagerProxy::playbackStartedTimeChanged(PlaybackSessionContextIdentifier contextId, double playbackStartedTime)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).playbackStartedTimeChanged(playbackStartedTime);
}

void PlaybackSessionManagerProxy::rateChanged(PlaybackSessionContextIdentifier contextId, bool isPlaying, double rate)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).rateChanged(isPlaying, rate);
}

void PlaybackSessionManagerProxy::pictureInPictureSupportedChanged(PlaybackSessionContextIdentifier contextId, bool supported)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    ensureModel(contextId).pictureInPictureSupportedChanged(supported);
}

void PlaybackSessionManagerProxy::handleControlledElementIDResponse(PlaybackSessionContextIdentifier contextId, String identifier) const
{
    MESSAGE_CHECK_CONTEXTID(contextId);
#if PLATFORM(MAC)
    if (contextId == m_controlsManagerContextId)
        m_page->handleControlledElementIDResponse(identifier);


#pragma mark Messages to PlaybackSessionManager

void PlaybackSessionManagerProxy::play(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::PlaybackSessionManager::Play(contextId));
}

void PlaybackSessionManagerProxy::pause(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::PlaybackSessionManager::Pause(contextId));
}

void PlaybackSessionManagerProxy::togglePlayState(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::PlaybackSessionManager::TogglePlayState(contextId));
}

void PlaybackSessionManagerProxy::beginScrubbing(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::PlaybackSessionManager::BeginScrubbing(contextId));
}

void PlaybackSessionManagerProxy::endScrubbing(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::PlaybackSessionManager::EndScrubbing(contextId));
}

void PlaybackSessionManagerProxy::seekToTime(PlaybackSessionContextIdentifier contextId, double time, double toleranceBefore, double toleranceAfter)
{
    m_page->send(Messages::PlaybackSessionManager::SeekToTime(contextId, time, toleranceBefore, toleranceAfter));
}

void PlaybackSessionManagerProxy::fastSeek(PlaybackSessionContextIdentifier contextId, double time)
{
    m_page->send(Messages::PlaybackSessionManager::FastSeek(contextId, time));
}

void PlaybackSessionManagerProxy::beginScanningForward(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::PlaybackSessionManager::BeginScanningForward(contextId));
}

void PlaybackSessionManagerProxy::beginScanningBackward(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::PlaybackSessionManager::BeginScanningBackward(contextId));
}

void PlaybackSessionManagerProxy::endScanning(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::PlaybackSessionManager::EndScanning(contextId));
}

void PlaybackSessionManagerProxy::selectAudioMediaOption(PlaybackSessionContextIdentifier contextId, uint64_t index)
{
    m_page->send(Messages::PlaybackSessionManager::SelectAudioMediaOption(contextId, index));
}

void PlaybackSessionManagerProxy::selectLegibleMediaOption(PlaybackSessionContextIdentifier contextId, uint64_t index)
{
    m_page->send(Messages::PlaybackSessionManager::SelectLegibleMediaOption(contextId, index));
}

void PlaybackSessionManagerProxy::togglePictureInPicture(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::PlaybackSessionManager::TogglePictureInPicture(contextId));
}

void PlaybackSessionManagerProxy::toggleMuted(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::PlaybackSessionManager::ToggleMuted(contextId));
}

void PlaybackSessionManagerProxy::setMuted(PlaybackSessionContextIdentifier contextId, bool muted)
{
    m_page->send(Messages::PlaybackSessionManager::SetMuted(contextId, muted));
}

void PlaybackSessionManagerProxy::setVolume(PlaybackSessionContextIdentifier contextId, double volume)
{
    m_page->send(Messages::PlaybackSessionManager::SetVolume(contextId, volume));
}

void PlaybackSessionManagerProxy::setPlayingOnSecondScreen(PlaybackSessionContextIdentifier contextId, bool value)
{
    if (m_page)
        m_page->send(Messages::PlaybackSessionManager::SetPlayingOnSecondScreen(contextId, value));


} // namespace WebKit

#undef MESSAGE_CHECK_CONTEXTID

#endif // PLATFORM(IOS_FAMILY) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))



#if ENABLE(VIDEO_PRESENTATION_MODE)

#include "MessageReceiver.h"
#include "PlaybackSessionContextIdentifier.h"
#include <WebCore/AudioSession.h>
#include <WebCore/GraphicsLayer.h>
#include <WebCore/PlatformView.h>

    , public WebCore::VideoFullscreenModel
    , public WebCore::VideoFullscreenChangeObserver  {
public:
    static Ref<VideoFullscreenModelContext> create(VideoFullscreenManagerProxy& manager, PlaybackSessionModelContext& playbackSessionModel, PlaybackSessionContextIdentifier contextId)
    {
        return adoptRef(*new VideoFullscreenModelContext(manager, playbackSessionModel, contextId));
    }

    void setLayerHostView(RetainPtr<PlatformView>&& layerHostView) { m_layerHostView = WTFMove(layerHostView); }

private:
    VideoFullscreenModelContext(VideoFullscreenManagerProxy&, PlaybackSessionModelContext&, PlaybackSessionContextIdentifier);

    // VideoFullscreenModel
    void addClient(WebCore::VideoFullscreenModelClient&) override;


    VideoFullscreenManagerProxy* m_manager;
    Ref<PlaybackSessionModelContext> m_playbackSessionModel;
    PlaybackSessionContextIdentifier m_contextId;
    RetainPtr<PlatformView> m_layerHostView;
    HashSet<WebCore::VideoFullscreenModelClient*> m_clients;
    WebCore::FloatSize m_videoDimensions;


    void setMockVideoPresentationModeEnabled(bool enabled) { m_mockVideoPresentationModeEnabled = enabled; }

    void requestRouteSharingPolicyAndContextUID(PlaybackSessionContextIdentifier, CompletionHandler<void(WebCore::RouteSharingPolicy, String)>&&);

    bool isPlayingVideoInEnhancedFullscreen() const;


    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;

    typedef std::tuple<RefPtr<VideoFullscreenModelContext>, RefPtr<PlatformVideoFullscreenInterface>> ModelInterfaceTuple;
    ModelInterfaceTuple createModelAndInterface(PlaybackSessionContextIdentifier);
    ModelInterfaceTuple& ensureModelAndInterface(PlaybackSessionContextIdentifier);
    VideoFullscreenModelContext& ensureModel(PlaybackSessionContextIdentifier);
    PlatformVideoFullscreenInterface& ensureInterface(PlaybackSessionContextIdentifier);
    PlatformVideoFullscreenInterface* findInterface(PlaybackSessionContextIdentifier);
    void addClientForContext(PlaybackSessionContextIdentifier);
    void removeClientForContext(PlaybackSessionContextIdentifier);

    void hasVideoInPictureInPictureDidChange(bool);

    // Messages from VideoFullscreenManager
    void setupFullscreenWithID(PlaybackSessionContextIdentifier, uint32_t videoLayerID, const WebCore::IntRect& initialRect, float hostingScaleFactor, WebCore::HTMLMediaElementEnums::VideoFullscreenMode, bool allowsPictureInPicture, bool standby);
    void setInlineRect(PlaybackSessionContextIdentifier, const WebCore::IntRect& inlineRect, bool visible);
    void setHasVideoContentLayer(PlaybackSessionContextIdentifier, bool value);
    void setHasVideo(PlaybackSessionContextIdentifier, bool);
    void setVideoDimensions(PlaybackSessionContextIdentifier, const WebCore::FloatSize&);
    void enterFullscreen(PlaybackSessionContextIdentifier);
    void exitFullscreen(PlaybackSessionContextIdentifier, WebCore::IntRect finalRect);
    void cleanupFullscreen(PlaybackSessionContextIdentifier);
    void preparedToReturnToInline(PlaybackSessionContextIdentifier, bool visible, WebCore::IntRect inlineRect);
    void preparedToExitFullscreen(PlaybackSessionContextIdentifier);
    void exitFullscreenWithoutAnimationToMode(PlaybackSessionContextIdentifier, WebCore::HTMLMediaElementEnums::VideoFullscreenMode);

    // Messages to VideoFullscreenManager
    void requestFullscreenMode(PlaybackSessionContextIdentifier, WebCore::HTMLMediaElementEnums::VideoFullscreenMode, bool finishedWithMedia = false);
    void requestUpdateInlineRect(PlaybackSessionContextIdentifier);
    void requestVideoContentLayer(PlaybackSessionContextIdentifier);
    void returnVideoContentLayer(PlaybackSessionContextIdentifier);
    void didSetupFullscreen(PlaybackSessionContextIdentifier);
    void willExitFullscreen(PlaybackSessionContextIdentifier);
    void didExitFullscreen(PlaybackSessionContextIdentifier);
    void didEnterFullscreen(PlaybackSessionContextIdentifier);
    void didCleanupFullscreen(PlaybackSessionContextIdentifier);
    void setVideoLayerFrame(PlaybackSessionContextIdentifier, WebCore::FloatRect);
    void setVideoLayerGravity(PlaybackSessionContextIdentifier, WebCore::MediaPlayerEnums::VideoGravity);
    void fullscreenModeChanged(PlaybackSessionContextIdentifier, WebCore::HTMLMediaElementEnums::VideoFullscreenMode);
    void fullscreenMayReturnToInline(PlaybackSessionContextIdentifier);

    bool m_mockVideoPresentationModeEnabled { false };

    WebPageProxy* m_page;
    Ref<PlaybackSessionManagerProxy> m_playbackSessionManagerProxy;
    HashMap<PlaybackSessionContextIdentifier, ModelInterfaceTuple> m_contextMap;
    PlaybackSessionContextIdentifier m_controlsManagerContextId;
    HashMap<PlaybackSessionContextIdentifier, int> m_clientCounts;
};

} // namespace WebKit




#if ENABLE(VIDEO_PRESENTATION_MODE)
messages -> VideoFullscreenManagerProxy {
    SetHasVideo(WebKit::PlaybackSessionContextIdentifier contextId, bool hasVideo)
    SetVideoDimensions(WebKit::PlaybackSessionContextIdentifier contextId, WebCore::FloatSize videoDimensions)
    SetupFullscreenWithID(WebKit::PlaybackSessionContextIdentifier contextId, uint32_t videoLayerID, WebCore::IntRect initialRect, float hostingScaleFactor, WebCore::HTMLMediaElementEnums::VideoFullscreenMode videoFullscreenMode, bool allowsPictureInPicture, bool standby)
    EnterFullscreen(WebKit::PlaybackSessionContextIdentifier contextId)
    ExitFullscreen(WebKit::PlaybackSessionContextIdentifier contextId, WebCore::IntRect finalRect)
    SetInlineRect(WebKit::PlaybackSessionContextIdentifier contextId, WebCore::IntRect inlineRect, bool visible)
    SetHasVideoContentLayer(WebKit::PlaybackSessionContextIdentifier contextId, bool value)
    CleanupFullscreen(WebKit::PlaybackSessionContextIdentifier contextId)
    PreparedToReturnToInline(WebKit::PlaybackSessionContextIdentifier contextId, bool visible, WebCore::IntRect inlineRect)
    PreparedToExitFullscreen(WebKit::PlaybackSessionContextIdentifier contextId)
    ExitFullscreenWithoutAnimationToMode(WebKit::PlaybackSessionContextIdentifier contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode videoFullscreenMode)
}
#endif



#endif

#define MESSAGE_CHECK(assertion) MESSAGE_CHECK_BASE(assertion, m_page->process().connection())
#define MESSAGE_CHECK_CONTEXTID(identifier) MESSAGE_CHECK_BASE(m_contextMap.isValidKey(identifier), m_page->process().connection())

namespace WebKit {
using namespace WebCore;


#pragma mark - VideoFullscreenModelContext

VideoFullscreenModelContext::VideoFullscreenModelContext(VideoFullscreenManagerProxy& manager, PlaybackSessionModelContext& playbackSessionModel, PlaybackSessionContextIdentifier contextId)
    : m_manager(&manager)
    , m_playbackSessionModel(playbackSessionModel)
    , m_contextId(contextId)

        interface->applicationDidBecomeActive();
}

void VideoFullscreenManagerProxy::requestRouteSharingPolicyAndContextUID(PlaybackSessionContextIdentifier contextId, CompletionHandler<void(WebCore::RouteSharingPolicy, String)>&& callback)
{
    m_page->sendWithAsyncReply(Messages::VideoFullscreenManager::RequestRouteSharingPolicyAndContextUID(contextId), WTFMove(callback));
}

VideoFullscreenManagerProxy::ModelInterfaceTuple VideoFullscreenManagerProxy::createModelAndInterface(PlaybackSessionContextIdentifier contextId)
{
    auto& playbackSessionModel = m_playbackSessionManagerProxy->ensureModel(contextId);
    Ref<VideoFullscreenModelContext> model = VideoFullscreenModelContext::create(*this, playbackSessionModel, contextId);

    return std::make_tuple(WTFMove(model), WTFMove(interface));
}

VideoFullscreenManagerProxy::ModelInterfaceTuple& VideoFullscreenManagerProxy::ensureModelAndInterface(PlaybackSessionContextIdentifier contextId)
{
    auto addResult = m_contextMap.add(contextId, ModelInterfaceTuple());
    if (addResult.isNewEntry)

    return addResult.iterator->value;
}

VideoFullscreenModelContext& VideoFullscreenManagerProxy::ensureModel(PlaybackSessionContextIdentifier contextId)
{
    return *std::get<0>(ensureModelAndInterface(contextId));
}

PlatformVideoFullscreenInterface& VideoFullscreenManagerProxy::ensureInterface(PlaybackSessionContextIdentifier contextId)
{
    return *std::get<1>(ensureModelAndInterface(contextId));
}

PlatformVideoFullscreenInterface* VideoFullscreenManagerProxy::findInterface(PlaybackSessionContextIdentifier contextId)
{
    auto it = m_contextMap.find(contextId);
    if (it == m_contextMap.end())

    return std::get<1>(it->value).get();
}

void VideoFullscreenManagerProxy::addClientForContext(PlaybackSessionContextIdentifier contextId)
{
    auto addResult = m_clientCounts.add(contextId, 1);
    if (!addResult.isNewEntry)
        addResult.iterator->value++;
}

void VideoFullscreenManagerProxy::removeClientForContext(PlaybackSessionContextIdentifier contextId)
{
    ASSERT(m_clientCounts.contains(contextId));



#pragma mark Messages from VideoFullscreenManager

void VideoFullscreenManagerProxy::setupFullscreenWithID(PlaybackSessionContextIdentifier contextId, uint32_t videoLayerID, const WebCore::IntRect& initialRect, float hostingDeviceScaleFactor, HTMLMediaElementEnums::VideoFullscreenMode videoFullscreenMode, bool allowsPictureInPicture, bool standby)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    MESSAGE_CHECK(videoLayerID);

    auto& [model, interface] = ensureModelAndInterface(contextId);

#endif
}

void VideoFullscreenManagerProxy::setHasVideo(PlaybackSessionContextIdentifier contextId, bool hasVideo)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    if (m_mockVideoPresentationModeEnabled)
        return;


        interface->hasVideoChanged(hasVideo);
}

void VideoFullscreenManagerProxy::setVideoDimensions(PlaybackSessionContextIdentifier contextId, const FloatSize& videoDimensions)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    if (m_mockVideoPresentationModeEnabled)
        return;


        interface->videoDimensionsChanged(videoDimensions);
}

void VideoFullscreenManagerProxy::enterFullscreen(PlaybackSessionContextIdentifier contextId)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    if (m_mockVideoPresentationModeEnabled) {
        didEnterFullscreen(contextId);
        setVideoLayerFrame(contextId, {0, 0, 200, 150});

    }
}

void VideoFullscreenManagerProxy::exitFullscreen(PlaybackSessionContextIdentifier contextId, WebCore::IntRect finalRect)
{
    MESSAGE_CHECK_CONTEXTID(contextId);

    ASSERT(m_contextMap.contains(contextId));
    if (!m_contextMap.contains(contextId))
        return;

#endif
}

void VideoFullscreenManagerProxy::exitFullscreenWithoutAnimationToMode(PlaybackSessionContextIdentifier contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode targetMode)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    if (m_mockVideoPresentationModeEnabled)
        return;



#if PLATFORM(IOS_FAMILY)

void VideoFullscreenManagerProxy::setInlineRect(PlaybackSessionContextIdentifier contextId, const WebCore::IntRect& inlineRect, bool visible)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    if (m_mockVideoPresentationModeEnabled)
        return;

    ensureInterface(contextId).setInlineRect(inlineRect, visible);
}

void VideoFullscreenManagerProxy::setHasVideoContentLayer(PlaybackSessionContextIdentifier contextId, bool value)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    if (m_mockVideoPresentationModeEnabled) {
        if (value)
            didSetupFullscreen(contextId);


#else

NO_RETURN_DUE_TO_ASSERT void VideoFullscreenManagerProxy::setInlineRect(PlaybackSessionContextIdentifier, const WebCore::IntRect&, bool)
{
    ASSERT_NOT_REACHED();
}

NO_RETURN_DUE_TO_ASSERT void VideoFullscreenManagerProxy::setHasVideoContentLayer(PlaybackSessionContextIdentifier, bool)
{
    ASSERT_NOT_REACHED();
}

#endif

void VideoFullscreenManagerProxy::cleanupFullscreen(PlaybackSessionContextIdentifier contextId)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    if (m_mockVideoPresentationModeEnabled) {
        didCleanupFullscreen(contextId);
        return;

    ensureInterface(contextId).cleanupFullscreen();
}

void VideoFullscreenManagerProxy::preparedToReturnToInline(PlaybackSessionContextIdentifier contextId, bool visible, WebCore::IntRect inlineRect)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    m_page->fullscreenMayReturnToInline();

#if !PLATFORM(IOS_FAMILY)

#endif
}

void VideoFullscreenManagerProxy::preparedToExitFullscreen(PlaybackSessionContextIdentifier contextId)
{
    MESSAGE_CHECK_CONTEXTID(contextId);
    if (m_mockVideoPresentationModeEnabled)
        return;



#pragma mark Messages to VideoFullscreenManager

void VideoFullscreenManagerProxy::requestFullscreenMode(PlaybackSessionContextIdentifier contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode mode, bool finishedWithMedia)
{
    m_page->send(Messages::VideoFullscreenManager::RequestFullscreenMode(contextId, mode, finishedWithMedia));
}

void VideoFullscreenManagerProxy::requestUpdateInlineRect(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::VideoFullscreenManager::RequestUpdateInlineRect(contextId));
}

void VideoFullscreenManagerProxy::requestVideoContentLayer(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::VideoFullscreenManager::RequestVideoContentLayer(contextId));
}

void VideoFullscreenManagerProxy::returnVideoContentLayer(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::VideoFullscreenManager::ReturnVideoContentLayer(contextId));
}

void VideoFullscreenManagerProxy::didSetupFullscreen(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::VideoFullscreenManager::DidSetupFullscreen(contextId));
}

void VideoFullscreenManagerProxy::willExitFullscreen(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::VideoFullscreenManager::WillExitFullscreen(contextId));
}

void VideoFullscreenManagerProxy::didExitFullscreen(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::VideoFullscreenManager::DidExitFullscreen(contextId));
    m_page->didExitFullscreen();
}

void VideoFullscreenManagerProxy::didEnterFullscreen(PlaybackSessionContextIdentifier contextId)
{
    m_page->send(Messages::VideoFullscreenManager::DidEnterFullscreen(contextId));
    m_page->didEnterFullscreen();
}

void VideoFullscreenManagerProxy::didCleanupFullscreen(PlaybackSessionContextIdentifier contextId)
{
    auto& [model, interface] = ensureModelAndInterface(contextId);


    removeClientForContext(contextId);
}

void VideoFullscreenManagerProxy::setVideoLayerFrame(PlaybackSessionContextIdentifier contextId, WebCore::FloatRect frame)
{
    @autoreleasepool {
#if PLATFORM(IOS_FAMILY)

    }
}

void VideoFullscreenManagerProxy::setVideoLayerGravity(PlaybackSessionContextIdentifier contextId, WebCore::MediaPlayerEnums::VideoGravity gravity)
{
    m_page->send(Messages::VideoFullscreenManager::SetVideoLayerGravityEnum(contextId, (unsigned)gravity));
}

void VideoFullscreenManagerProxy::fullscreenModeChanged(PlaybackSessionContextIdentifier contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode mode)
{
    m_page->send(Messages::VideoFullscreenManager::FullscreenModeChanged(contextId, mode));
}

void VideoFullscreenManagerProxy::fullscreenMayReturnToInline(PlaybackSessionContextIdentifier contextId)
{
    bool isViewVisible = m_page->isViewVisible();
    m_page->send(Messages::VideoFullscreenManager::FullscreenMayReturnToInline(contextId, isViewVisible));


} // namespace WebKit

#undef MESSAGE_CHECK_CONTEXTID
#undef MESSAGE_CHECK

#endif // ENABLE(VIDEO_PRESENTATION_MODE)



		41FAF5F51E3C0649001AE678 /* WebRTCResolver.h in Headers */ = {isa = PBXBuildFile; fileRef = 41FAF5F41E3C0641001AE678 /* WebRTCResolver.h */; };
		41FAF5F81E3C1021001AE678 /* LibWebRTCResolver.h in Headers */ = {isa = PBXBuildFile; fileRef = 41FAF5F61E3C0B47001AE678 /* LibWebRTCResolver.h */; };
		4459984222833E8700E61373 /* SyntheticEditingCommandType.h in Headers */ = {isa = PBXBuildFile; fileRef = 4459984122833E6000E61373 /* SyntheticEditingCommandType.h */; };
		446DC64C24A2D8E50061F390 /* PlaybackSessionContextIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 446DC64B24A2D8AD0061F390 /* PlaybackSessionContextIdentifier.h */; };
		4482734724528F6000A95493 /* CocoaImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 4482734624528F6000A95493 /* CocoaImage.h */; };
		449D90DA21FDC30B00F677C0 /* LocalAuthenticationSoftLink.mm in Sources */ = {isa = PBXBuildFile; fileRef = 449D90D821FD63FE00F677C0 /* LocalAuthenticationSoftLink.mm */; };
		44E936FD2447C2D8009FA3E3 /* LegacyCustomProtocolID.h in Headers */ = {isa = PBXBuildFile; fileRef = 44E936FC2447C256009FA3E3 /* LegacyCustomProtocolID.h */; };

		41FCD6BF23CE044000C62567 /* RemoteSampleBufferDisplayLayerManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RemoteSampleBufferDisplayLayerManager.h; sourceTree = "<group>"; };
		4450AEBF1DC3FAE5009943F2 /* SharedMemoryCocoa.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SharedMemoryCocoa.cpp; sourceTree = "<group>"; };
		4459984122833E6000E61373 /* SyntheticEditingCommandType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SyntheticEditingCommandType.h; sourceTree = "<group>"; };
		446DC64B24A2D8AD0061F390 /* PlaybackSessionContextIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlaybackSessionContextIdentifier.h; sourceTree = "<group>"; };
		4482734624528F6000A95493 /* CocoaImage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CocoaImage.h; sourceTree = "<group>"; };
		449D90D821FD63FE00F677C0 /* LocalAuthenticationSoftLink.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LocalAuthenticationSoftLink.mm; sourceTree = "<group>"; };
		44A481C621F2D27B00F2F919 /* ClientCertificateAuthenticationXPCConstants.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ClientCertificateAuthenticationXPCConstants.cpp; sourceTree = "<group>"; };

			children = (
				CD4570CB2440FB2A00A3DCEB /* AudioSessionRoutingArbitrator.cpp */,
				CD4570CA2440FB2A00A3DCEB /* AudioSessionRoutingArbitrator.h */,
				446DC64B24A2D8AD0061F390 /* PlaybackSessionContextIdentifier.h */,
				CDA29A191CBDBF4100901CCF /* PlaybackSessionManager.h */,
				CDA29A1C1CBDBF5B00901CCF /* PlaybackSessionManager.messages.in */,
				CDA29A181CBDBF4100901CCF /* PlaybackSessionManager.mm */,

				2D8710171828415D0018FA01 /* PlatformCALayerRemoteCustom.h in Headers */,
				2D8949F1182044F600E898AA /* PlatformCALayerRemoteTiledBacking.h in Headers */,
				BCC43ABB127B95DC00317F16 /* PlatformPopupMenuData.h in Headers */,
				446DC64C24A2D8E50061F390 /* PlaybackSessionContextIdentifier.h in Headers */,
				CDA29A1B1CBDBF4100901CCF /* PlaybackSessionManager.h in Headers */,
				CDA29A291CBEB67A00901CCF /* PlaybackSessionManagerMessages.h in Headers */,
				CDA29A201CBEB5FB00901CCF /* PlaybackSessionManagerProxy.h in Headers */,



/*
 * Copyright (C) 2020 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include <wtf/ObjectIdentifier.h>

namespace WebKit {

enum PlaybackSessionContextIdentifierType { };
using PlaybackSessionContextIdentifier = ObjectIdentifier<PlaybackSessionContextIdentifierType>;

}



/*
 * Copyright (C) 2016-2020 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

#if PLATFORM(IOS_FAMILY) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))

#include "MessageReceiver.h"
#include "PlaybackSessionContextIdentifier.h"
#include <WebCore/EventListener.h>
#include <WebCore/HTMLMediaElementEnums.h>
#include <WebCore/PlatformCALayer.h>

    : public RefCounted<PlaybackSessionInterfaceContext>
    , public WebCore::PlaybackSessionModelClient {
public:
    static Ref<PlaybackSessionInterfaceContext> create(PlaybackSessionManager& manager, PlaybackSessionContextIdentifier contextId)
    {
        return adoptRef(*new PlaybackSessionInterfaceContext(manager, contextId));
    }

    void volumeChanged(double) final;
    void isPictureInPictureSupportedChanged(bool) final;

    PlaybackSessionInterfaceContext(PlaybackSessionManager&, PlaybackSessionContextIdentifier);

    PlaybackSessionManager* m_manager;
    PlaybackSessionContextIdentifier m_contextId;
};

class PlaybackSessionManager : public RefCounted<PlaybackSessionManager>, private IPC::MessageReceiver {


    void setUpPlaybackControlsManager(WebCore::HTMLMediaElement&);
    void clearPlaybackControlsManager();
    PlaybackSessionContextIdentifier contextIdForMediaElement(WebCore::HTMLMediaElement&);

    WebCore::HTMLMediaElement* currentPlaybackControlsElement() const;


    explicit PlaybackSessionManager(WebPage&);

    typedef std::tuple<RefPtr<WebCore::PlaybackSessionModelMediaElement>, RefPtr<PlaybackSessionInterfaceContext>> ModelInterfaceTuple;
    ModelInterfaceTuple createModelAndInterface(PlaybackSessionContextIdentifier);
    ModelInterfaceTuple& ensureModelAndInterface(PlaybackSessionContextIdentifier);
    WebCore::PlaybackSessionModelMediaElement& ensureModel(PlaybackSessionContextIdentifier);
    PlaybackSessionInterfaceContext& ensureInterface(PlaybackSessionContextIdentifier);
    void removeContext(PlaybackSessionContextIdentifier);
    void addClientForContext(PlaybackSessionContextIdentifier);
    void removeClientForContext(PlaybackSessionContextIdentifier);

    // Interface to PlaybackSessionInterfaceContext
    void durationChanged(PlaybackSessionContextIdentifier, double);
    void currentTimeChanged(PlaybackSessionContextIdentifier, double currentTime, double anchorTime);
    void bufferedTimeChanged(PlaybackSessionContextIdentifier, double bufferedTime);
    void playbackStartedTimeChanged(PlaybackSessionContextIdentifier, double playbackStartedTime);
    void rateChanged(PlaybackSessionContextIdentifier, bool isPlaying, float playbackRate);
    void seekableRangesChanged(PlaybackSessionContextIdentifier, const WebCore::TimeRanges&, double lastModifiedTime, double liveUpdateInterval);
    void canPlayFastReverseChanged(PlaybackSessionContextIdentifier, bool value);
    void audioMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier, const Vector<WebCore::MediaSelectionOption>& options, uint64_t selectedIndex);
    void legibleMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier, const Vector<WebCore::MediaSelectionOption>& options, uint64_t selectedIndex);
    void audioMediaSelectionIndexChanged(PlaybackSessionContextIdentifier, uint64_t selectedIndex);
    void legibleMediaSelectionIndexChanged(PlaybackSessionContextIdentifier, uint64_t selectedIndex);
    void externalPlaybackChanged(PlaybackSessionContextIdentifier, bool enabled, WebCore::PlaybackSessionModel::ExternalPlaybackTargetType, String localizedDeviceName);
    void wirelessVideoPlaybackDisabledChanged(PlaybackSessionContextIdentifier, bool);
    void mutedChanged(PlaybackSessionContextIdentifier, bool);
    void volumeChanged(PlaybackSessionContextIdentifier, double);
    void isPictureInPictureSupportedChanged(PlaybackSessionContextIdentifier, bool);

    // Messages from PlaybackSessionManagerProxy
    void play(PlaybackSessionContextIdentifier);
    void pause(PlaybackSessionContextIdentifier);
    void togglePlayState(PlaybackSessionContextIdentifier);
    void beginScrubbing(PlaybackSessionContextIdentifier);
    void endScrubbing(PlaybackSessionContextIdentifier);
    void seekToTime(PlaybackSessionContextIdentifier, double time, double toleranceBefore, double toleranceAfter);
    void fastSeek(PlaybackSessionContextIdentifier, double time);
    void beginScanningForward(PlaybackSessionContextIdentifier);
    void beginScanningBackward(PlaybackSessionContextIdentifier);
    void endScanning(PlaybackSessionContextIdentifier);
    void selectAudioMediaOption(PlaybackSessionContextIdentifier, uint64_t index);
    void selectLegibleMediaOption(PlaybackSessionContextIdentifier, uint64_t index);
    void handleControlledElementIDRequest(PlaybackSessionContextIdentifier);
    void togglePictureInPicture(PlaybackSessionContextIdentifier);
    void toggleMuted(PlaybackSessionContextIdentifier);
    void setMuted(PlaybackSessionContextIdentifier, bool muted);
    void setVolume(PlaybackSessionContextIdentifier, double volume);
    void setPlayingOnSecondScreen(PlaybackSessionContextIdentifier, bool value);

    WebPage* m_page;
    HashMap<WebCore::HTMLMediaElement*, PlaybackSessionContextIdentifier> m_mediaElements;
    HashMap<PlaybackSessionContextIdentifier, ModelInterfaceTuple> m_contextMap;
    PlaybackSessionContextIdentifier m_controlsManagerContextId;
    HashCountedSet<PlaybackSessionContextIdentifier> m_clientCounts;
};

} // namespace WebKit



# Copyright (C) 2016-2020 Apple Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions


#if PLATFORM(IOS_FAMILY) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
messages -> PlaybackSessionManager {
    Play(WebKit::PlaybackSessionContextIdentifier contextId)
    Pause(WebKit::PlaybackSessionContextIdentifier contextId)
    TogglePlayState(WebKit::PlaybackSessionContextIdentifier contextId)
    BeginScrubbing(WebKit::PlaybackSessionContextIdentifier contextId)
    EndScrubbing(WebKit::PlaybackSessionContextIdentifier contextId)
    SeekToTime(WebKit::PlaybackSessionContextIdentifier contextId, double time, double toleranceBefore, double toleranceAfter)
    FastSeek(WebKit::PlaybackSessionContextIdentifier contextId, double time)
    BeginScanningForward(WebKit::PlaybackSessionContextIdentifier contextId)
    BeginScanningBackward(WebKit::PlaybackSessionContextIdentifier contextId)
    EndScanning(WebKit::PlaybackSessionContextIdentifier contextId)
    SelectAudioMediaOption(WebKit::PlaybackSessionContextIdentifier contextId, uint64_t index)
    SelectLegibleMediaOption(WebKit::PlaybackSessionContextIdentifier contextId, uint64_t index)
    HandleControlledElementIDRequest(WebKit::PlaybackSessionContextIdentifier contextId)
    TogglePictureInPicture(WebKit::PlaybackSessionContextIdentifier contextId)
    ToggleMuted(WebKit::PlaybackSessionContextIdentifier contextId)
    SetMuted(WebKit::PlaybackSessionContextIdentifier contextId, bool muted)
    SetVolume(WebKit::PlaybackSessionContextIdentifier contextId, double volume)
    SetPlayingOnSecondScreen(WebKit::PlaybackSessionContextIdentifier contextId, bool value)
}
#endif



/*
 * Copyright (C) 2016-2020 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

namespace WebKit {
using namespace WebCore;

static uint64_t nextContextId()
{
    static uint64_t contextId = 0;
    return ++contextId;
}

#pragma mark - PlaybackSessionInterfaceContext

PlaybackSessionInterfaceContext::PlaybackSessionInterfaceContext(PlaybackSessionManager& manager, PlaybackSessionContextIdentifier contextId)
    : m_manager(&manager)
    , m_contextId(contextId)
{

    m_page = nullptr;
}

PlaybackSessionManager::ModelInterfaceTuple PlaybackSessionManager::createModelAndInterface(PlaybackSessionContextIdentifier contextId)
{
    auto model = PlaybackSessionModelMediaElement::create();
    auto interface = PlaybackSessionInterfaceContext::create(*this, contextId);

    return std::make_tuple(WTFMove(model), WTFMove(interface));
}

PlaybackSessionManager::ModelInterfaceTuple& PlaybackSessionManager::ensureModelAndInterface(PlaybackSessionContextIdentifier contextId)
{
    auto addResult = m_contextMap.add(contextId, ModelInterfaceTuple());
    if (addResult.isNewEntry)

    return addResult.iterator->value;
}

WebCore::PlaybackSessionModelMediaElement& PlaybackSessionManager::ensureModel(PlaybackSessionContextIdentifier contextId)
{
    return *std::get<0>(ensureModelAndInterface(contextId));
}

PlaybackSessionInterfaceContext& PlaybackSessionManager::ensureInterface(PlaybackSessionContextIdentifier contextId)
{
    return *std::get<1>(ensureModelAndInterface(contextId));
}

void PlaybackSessionManager::removeContext(PlaybackSessionContextIdentifier contextId)
{
    auto& [model, interface] = ensureModelAndInterface(contextId);


    m_contextMap.remove(contextId);
}

void PlaybackSessionManager::addClientForContext(PlaybackSessionContextIdentifier contextId)
{
    m_clientCounts.add(contextId);
}

void PlaybackSessionManager::removeClientForContext(PlaybackSessionContextIdentifier contextId)
{
    ASSERT(m_clientCounts.contains(contextId));
    if (m_clientCounts.remove(contextId))

{
    auto foundIterator = m_mediaElements.find(&mediaElement);
    if (foundIterator != m_mediaElements.end()) {
        auto contextId = foundIterator->value;
        if (m_controlsManagerContextId == contextId)
            return;


        if (previousContextId)
            removeClientForContext(previousContextId);
    } else {
        auto contextId = m_mediaElements.ensure(&mediaElement, [&] {
            return PlaybackSessionContextIdentifier::generate();
        }).iterator->value;

        auto previousContextId = m_controlsManagerContextId;
        m_controlsManagerContextId = contextId;

        return;

    removeClientForContext(m_controlsManagerContextId);
    m_controlsManagerContextId = { };

    m_page->videoControlsManagerDidChange();
    m_page->send(Messages::PlaybackSessionManagerProxy::ClearPlaybackControlsManager());
}

PlaybackSessionContextIdentifier PlaybackSessionManager::contextIdForMediaElement(WebCore::HTMLMediaElement& mediaElement)
{
    auto addResult = m_mediaElements.ensure(&mediaElement, [&] {
        return PlaybackSessionContextIdentifier::generate();
    });
    auto contextId = addResult.iterator->value;
    ensureModel(contextId).setMediaElement(&mediaElement);
    return contextId;
}


#pragma mark Interface to PlaybackSessionInterfaceContext:

void PlaybackSessionManager::durationChanged(PlaybackSessionContextIdentifier contextId, double duration)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::DurationChanged(contextId, duration));
}

void PlaybackSessionManager::currentTimeChanged(PlaybackSessionContextIdentifier contextId, double currentTime, double anchorTime)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::CurrentTimeChanged(contextId, currentTime, anchorTime));
}

void PlaybackSessionManager::bufferedTimeChanged(PlaybackSessionContextIdentifier contextId, double bufferedTime)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::BufferedTimeChanged(contextId, bufferedTime));
}

void PlaybackSessionManager::playbackStartedTimeChanged(PlaybackSessionContextIdentifier contextId, double playbackStartedTime)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::PlaybackStartedTimeChanged(contextId, playbackStartedTime));
}

void PlaybackSessionManager::rateChanged(PlaybackSessionContextIdentifier contextId, bool isPlaying, float playbackRate)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::RateChanged(contextId, isPlaying, playbackRate));
}

void PlaybackSessionManager::seekableRangesChanged(PlaybackSessionContextIdentifier contextId, const WebCore::TimeRanges& timeRanges, double lastModifiedTime, double liveUpdateInterval)
{
    Vector<std::pair<double, double>> rangesVector;
    for (unsigned i = 0; i < timeRanges.length(); i++) {

    m_page->send(Messages::PlaybackSessionManagerProxy::SeekableRangesVectorChanged(contextId, WTFMove(rangesVector), lastModifiedTime, liveUpdateInterval));
}

void PlaybackSessionManager::canPlayFastReverseChanged(PlaybackSessionContextIdentifier contextId, bool value)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::CanPlayFastReverseChanged(contextId, value));
}

void PlaybackSessionManager::audioMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier contextId, const Vector<MediaSelectionOption>& options, uint64_t selectedIndex)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::AudioMediaSelectionOptionsChanged(contextId, options, selectedIndex));
}

void PlaybackSessionManager::legibleMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier contextId, const Vector<MediaSelectionOption>& options, uint64_t selectedIndex)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::LegibleMediaSelectionOptionsChanged(contextId, options, selectedIndex));
}

void PlaybackSessionManager::externalPlaybackChanged(PlaybackSessionContextIdentifier contextId, bool enabled, PlaybackSessionModel::ExternalPlaybackTargetType targetType, String localizedDeviceName)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::ExternalPlaybackPropertiesChanged(contextId, enabled, static_cast<uint32_t>(targetType), localizedDeviceName));
}

void PlaybackSessionManager::audioMediaSelectionIndexChanged(PlaybackSessionContextIdentifier contextId, uint64_t selectedIndex)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::AudioMediaSelectionIndexChanged(contextId, selectedIndex));
}

void PlaybackSessionManager::legibleMediaSelectionIndexChanged(PlaybackSessionContextIdentifier contextId, uint64_t selectedIndex)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::LegibleMediaSelectionIndexChanged(contextId, selectedIndex));
}

void PlaybackSessionManager::wirelessVideoPlaybackDisabledChanged(PlaybackSessionContextIdentifier contextId, bool disabled)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::WirelessVideoPlaybackDisabledChanged(contextId, disabled));
}

void PlaybackSessionManager::mutedChanged(PlaybackSessionContextIdentifier contextId, bool muted)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::MutedChanged(contextId, muted));
}

void PlaybackSessionManager::volumeChanged(PlaybackSessionContextIdentifier contextId, double volume)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::VolumeChanged(contextId, volume));
}

void PlaybackSessionManager::isPictureInPictureSupportedChanged(PlaybackSessionContextIdentifier contextId, bool supported)
{
    m_page->send(Messages::PlaybackSessionManagerProxy::PictureInPictureSupportedChanged(contextId, supported));
}

#pragma mark Messages from PlaybackSessionManagerProxy:

void PlaybackSessionManager::play(PlaybackSessionContextIdentifier contextId)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).play();
}

void PlaybackSessionManager::pause(PlaybackSessionContextIdentifier contextId)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).pause();
}

void PlaybackSessionManager::togglePlayState(PlaybackSessionContextIdentifier contextId)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).togglePlayState();
}

void PlaybackSessionManager::beginScrubbing(PlaybackSessionContextIdentifier contextId)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).beginScrubbing();
}

void PlaybackSessionManager::endScrubbing(PlaybackSessionContextIdentifier contextId)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).endScrubbing();
}

void PlaybackSessionManager::seekToTime(PlaybackSessionContextIdentifier contextId, double time, double toleranceBefore, double toleranceAfter)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).seekToTime(time, toleranceBefore, toleranceAfter);
}

void PlaybackSessionManager::fastSeek(PlaybackSessionContextIdentifier contextId, double time)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).fastSeek(time);
}

void PlaybackSessionManager::beginScanningForward(PlaybackSessionContextIdentifier contextId)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).beginScanningForward();
}

void PlaybackSessionManager::beginScanningBackward(PlaybackSessionContextIdentifier contextId)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).beginScanningBackward();
}

void PlaybackSessionManager::endScanning(PlaybackSessionContextIdentifier contextId)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).endScanning();
}

void PlaybackSessionManager::selectAudioMediaOption(PlaybackSessionContextIdentifier contextId, uint64_t index)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).selectAudioMediaOption(index);
}

void PlaybackSessionManager::selectLegibleMediaOption(PlaybackSessionContextIdentifier contextId, uint64_t index)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).selectLegibleMediaOption(index);
}

void PlaybackSessionManager::handleControlledElementIDRequest(PlaybackSessionContextIdentifier contextId)
{
    auto element = ensureModel(contextId).mediaElement();
    if (element)
        m_page->send(Messages::PlaybackSessionManagerProxy::HandleControlledElementIDResponse(contextId, element->getIdAttribute()));
}

void PlaybackSessionManager::togglePictureInPicture(PlaybackSessionContextIdentifier contextId)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).togglePictureInPicture();
}

void PlaybackSessionManager::toggleMuted(PlaybackSessionContextIdentifier contextId)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).toggleMuted();
}

void PlaybackSessionManager::setMuted(PlaybackSessionContextIdentifier contextId, bool muted)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).setMuted(muted);
}

void PlaybackSessionManager::setVolume(PlaybackSessionContextIdentifier contextId, double volume)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).setVolume(volume);
}

void PlaybackSessionManager::setPlayingOnSecondScreen(PlaybackSessionContextIdentifier contextId, bool value)
{
    UserGestureIndicator indicator(ProcessingUserGesture);
    ensureModel(contextId).setPlayingOnSecondScreen(value);



/*
 * Copyright (C) 2014-2020 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions


#include "Connection.h"
#include "MessageReceiver.h"
#include "PlaybackSessionContextIdentifier.h"
#include "VideoFullscreenManagerMessagesReplies.h"
#include <WebCore/EventListener.h>
#include <WebCore/HTMLMediaElementEnums.h>

    : public RefCounted<VideoFullscreenInterfaceContext>
    , public WebCore::VideoFullscreenModelClient {
public:
    static Ref<VideoFullscreenInterfaceContext> create(VideoFullscreenManager& manager, PlaybackSessionContextIdentifier contextId)
    {
        return adoptRef(*new VideoFullscreenInterfaceContext(manager, contextId));
    }

    void hasVideoChanged(bool) override;
    void videoDimensionsChanged(const WebCore::FloatSize&) override;

    VideoFullscreenInterfaceContext(VideoFullscreenManager&, PlaybackSessionContextIdentifier);

    VideoFullscreenManager* m_manager;
    PlaybackSessionContextIdentifier m_contextId;
    std::unique_ptr<LayerHostingContext> m_layerHostingContext;
    AnimationType m_animationType { false };
    bool m_targetIsFullscreen { false };

    explicit VideoFullscreenManager(WebPage&, PlaybackSessionManager&);

    typedef std::tuple<RefPtr<WebCore::VideoFullscreenModelVideoElement>, RefPtr<VideoFullscreenInterfaceContext>> ModelInterfaceTuple;
    ModelInterfaceTuple createModelAndInterface(PlaybackSessionContextIdentifier);
    ModelInterfaceTuple& ensureModelAndInterface(PlaybackSessionContextIdentifier);
    WebCore::VideoFullscreenModelVideoElement& ensureModel(PlaybackSessionContextIdentifier);
    VideoFullscreenInterfaceContext& ensureInterface(PlaybackSessionContextIdentifier);
    void removeContext(PlaybackSessionContextIdentifier);
    void addClientForContext(PlaybackSessionContextIdentifier);
    void removeClientForContext(PlaybackSessionContextIdentifier);

    // Interface to VideoFullscreenInterfaceContext
    void hasVideoChanged(PlaybackSessionContextIdentifier, bool hasVideo);
    void videoDimensionsChanged(PlaybackSessionContextIdentifier, const WebCore::FloatSize&);

    // Messages from VideoFullscreenManagerProxy
    void requestFullscreenMode(PlaybackSessionContextIdentifier, WebCore::HTMLMediaElementEnums::VideoFullscreenMode, bool finishedWithMedia);
    void requestUpdateInlineRect(PlaybackSessionContextIdentifier);
    void requestVideoContentLayer(PlaybackSessionContextIdentifier);
    void returnVideoContentLayer(PlaybackSessionContextIdentifier);
    void didSetupFullscreen(PlaybackSessionContextIdentifier);
    void willExitFullscreen(PlaybackSessionContextIdentifier);
    void didExitFullscreen(PlaybackSessionContextIdentifier);
    void didEnterFullscreen(PlaybackSessionContextIdentifier);
    void didCleanupFullscreen(PlaybackSessionContextIdentifier);
    void setVideoLayerFrameFenced(PlaybackSessionContextIdentifier, WebCore::FloatRect bounds, IPC::Attachment fencePort);
    void setVideoLayerGravityEnum(PlaybackSessionContextIdentifier, unsigned gravity);
    void fullscreenModeChanged(PlaybackSessionContextIdentifier, WebCore::HTMLMediaElementEnums::VideoFullscreenMode);
    void fullscreenMayReturnToInline(PlaybackSessionContextIdentifier, bool isPageVisible);
    void requestRouteSharingPolicyAndContextUID(PlaybackSessionContextIdentifier, Messages::VideoFullscreenManager::RequestRouteSharingPolicyAndContextUIDAsyncReply&&);

    WebPage* m_page;
    Ref<PlaybackSessionManager> m_playbackSessionManager;
    HashMap<WebCore::HTMLVideoElement*, PlaybackSessionContextIdentifier> m_videoElements;
    HashMap<PlaybackSessionContextIdentifier, ModelInterfaceTuple> m_contextMap;
    PlaybackSessionContextIdentifier m_controlsManagerContextId;
    HashMap<PlaybackSessionContextIdentifier, int> m_clientCounts;
};

} // namespace WebKit

#endif // ENABLE(VIDEO_PRESENTATION_MODE)





#if ENABLE(VIDEO_PRESENTATION_MODE)
messages -> VideoFullscreenManager {
    RequestFullscreenMode(WebKit::PlaybackSessionContextIdentifier contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode videoFullscreenMode, bool finishedWithMedia)
    RequestUpdateInlineRect(WebKit::PlaybackSessionContextIdentifier contextId)
    RequestVideoContentLayer(WebKit::PlaybackSessionContextIdentifier contextId)
    ReturnVideoContentLayer(WebKit::PlaybackSessionContextIdentifier contextId)
    DidSetupFullscreen(WebKit::PlaybackSessionContextIdentifier contextId)
    WillExitFullscreen(WebKit::PlaybackSessionContextIdentifier contextId)
    DidExitFullscreen(WebKit::PlaybackSessionContextIdentifier contextId)
    DidEnterFullscreen(WebKit::PlaybackSessionContextIdentifier contextId)
    DidCleanupFullscreen(WebKit::PlaybackSessionContextIdentifier contextId)
    SetVideoLayerFrameFenced(WebKit::PlaybackSessionContextIdentifier contextId, WebCore::FloatRect bounds, IPC::Attachment fencePort)
    SetVideoLayerGravityEnum(WebKit::PlaybackSessionContextIdentifier contextId, unsigned gravity)
    FullscreenModeChanged(WebKit::PlaybackSessionContextIdentifier contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode videoFullscreenMode)
    FullscreenMayReturnToInline(WebKit::PlaybackSessionContextIdentifier contextId, bool isPageVisible)
    RequestRouteSharingPolicyAndContextUID(WebKit::PlaybackSessionContextIdentifier contextId) -> (enum:uint8_t WebCore::RouteSharingPolicy routeSharingPolicy, String routingContextUID) Async
}
#endif




#pragma mark - VideoFullscreenInterfaceContext

VideoFullscreenInterfaceContext::VideoFullscreenInterfaceContext(VideoFullscreenManager& manager, PlaybackSessionContextIdentifier contextId)
    : m_manager(&manager)
    , m_contextId(contextId)
{

    m_page = nullptr;
}

VideoFullscreenManager::ModelInterfaceTuple VideoFullscreenManager::createModelAndInterface(PlaybackSessionContextIdentifier contextId)
{
    auto model = VideoFullscreenModelVideoElement::create();
    auto interface = VideoFullscreenInterfaceContext::create(*this, contextId);

    return std::make_tuple(WTFMove(model), WTFMove(interface));
}

VideoFullscreenManager::ModelInterfaceTuple& VideoFullscreenManager::ensureModelAndInterface(PlaybackSessionContextIdentifier contextId)
{
    auto addResult = m_contextMap.add(contextId, ModelInterfaceTuple());
    if (addResult.isNewEntry)

    return addResult.iterator->value;
}

WebCore::VideoFullscreenModelVideoElement& VideoFullscreenManager::ensureModel(PlaybackSessionContextIdentifier contextId)
{
    return *std::get<0>(ensureModelAndInterface(contextId));
}

VideoFullscreenInterfaceContext& VideoFullscreenManager::ensureInterface(PlaybackSessionContextIdentifier contextId)
{
    return *std::get<1>(ensureModelAndInterface(contextId));
}

void VideoFullscreenManager::removeContext(PlaybackSessionContextIdentifier contextId)
{
    auto [model, interface] = ensureModelAndInterface(contextId);


    m_contextMap.remove(contextId);
}

void VideoFullscreenManager::addClientForContext(PlaybackSessionContextIdentifier contextId)
{
    auto addResult = m_clientCounts.add(contextId, 1);
    if (!addResult.isNewEntry)
        addResult.iterator->value++;
}

void VideoFullscreenManager::removeClientForContext(PlaybackSessionContextIdentifier contextId)
{
    ASSERT(m_clientCounts.contains(contextId));


    ASSERT(standby || mode != HTMLMediaElementEnums::VideoFullscreenModeNone);
    LOG(Fullscreen, "VideoFullscreenManager::enterVideoFullscreenForVideoElement(%p)", this);

    auto contextId = m_playbackSessionManager->contextIdForMediaElement(videoElement);
    auto addResult = m_videoElements.add(&videoElement, contextId);
    UNUSED_PARAM(addResult);
    ASSERT(addResult.iterator->value == contextId);

    ASSERT(m_page);
    ASSERT(m_videoElements.contains(&videoElement));

    auto contextId = m_videoElements.get(&videoElement);
    auto& interface = ensureInterface(contextId);
    interface.setTargetIsFullscreen(false);
    if (interface.animationState() != VideoFullscreenInterfaceContext::AnimationType::None)

    ASSERT(m_page);
    ASSERT(m_videoElements.contains(&videoElement));

    auto contextId = m_videoElements.get(&videoElement);
    auto& interface = ensureInterface(contextId);

    interface.setTargetIsFullscreen(false);


#pragma mark Interface to VideoFullscreenInterfaceContext:

void VideoFullscreenManager::hasVideoChanged(PlaybackSessionContextIdentifier contextId, bool hasVideo)
{
    if (m_page)
        m_page->send(Messages::VideoFullscreenManagerProxy::SetHasVideo(contextId, hasVideo));
}

void VideoFullscreenManager::videoDimensionsChanged(PlaybackSessionContextIdentifier contextId, const FloatSize& videoDimensions)
{
    if (m_page)
        m_page->send(Messages::VideoFullscreenManagerProxy::SetVideoDimensions(contextId, videoDimensions));


#pragma mark Messages from VideoFullscreenManagerProxy:

void VideoFullscreenManager::requestFullscreenMode(PlaybackSessionContextIdentifier contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode mode, bool finishedWithMedia)
{
    ensureModel(contextId).requestFullscreenMode(mode, finishedWithMedia);
}

void VideoFullscreenManager::fullscreenModeChanged(PlaybackSessionContextIdentifier contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode videoFullscreenMode)
{
    ensureModel(contextId).fullscreenModeChanged(videoFullscreenMode);
}

void VideoFullscreenManager::requestUpdateInlineRect(PlaybackSessionContextIdentifier contextId)
{
    if (!m_page)
        return;

    m_page->send(Messages::VideoFullscreenManagerProxy::SetInlineRect(contextId, inlineRect, inlineRect != IntRect(0, 0, 0, 0)));
}

void VideoFullscreenManager::requestVideoContentLayer(PlaybackSessionContextIdentifier contextId)
{
    auto [model, interface] = ensureModelAndInterface(contextId);


    });
}

void VideoFullscreenManager::returnVideoContentLayer(PlaybackSessionContextIdentifier contextId)
{
    RefPtr<VideoFullscreenModelVideoElement> model;
    RefPtr<VideoFullscreenInterfaceContext> interface;

    });
}

void VideoFullscreenManager::didSetupFullscreen(PlaybackSessionContextIdentifier contextId)
{
    LOG(Fullscreen, "VideoFullscreenManager::didSetupFullscreen(%p, %x)", this, contextId);


#endif
}

void VideoFullscreenManager::willExitFullscreen(PlaybackSessionContextIdentifier contextId)
{
    LOG(Fullscreen, "VideoFullscreenManager::willExitFullscreen(%p, %x)", this, contextId);


    });
}

void VideoFullscreenManager::didEnterFullscreen(PlaybackSessionContextIdentifier contextId)
{
    LOG(Fullscreen, "VideoFullscreenManager::didEnterFullscreen(%p, %x)", this, contextId);


    });
}

void VideoFullscreenManager::didExitFullscreen(PlaybackSessionContextIdentifier contextId)
{
    LOG(Fullscreen, "VideoFullscreenManager::didExitFullscreen(%p, %x)", this, contextId);


#endif
}
    
void VideoFullscreenManager::didCleanupFullscreen(PlaybackSessionContextIdentifier contextId)
{
    LOG(Fullscreen, "VideoFullscreenManager::didCleanupFullscreen(%p, %x)", this, contextId);


    });
}
    
void VideoFullscreenManager::setVideoLayerGravityEnum(PlaybackSessionContextIdentifier contextId, unsigned gravity)
{
    ensureModel(contextId).setVideoLayerGravity((MediaPlayerEnums::VideoGravity)gravity);
}
    
void VideoFullscreenManager::fullscreenMayReturnToInline(PlaybackSessionContextIdentifier contextId, bool isPageVisible)
{
    if (!m_page)
        return;

    m_page->send(Messages::VideoFullscreenManagerProxy::PreparedToReturnToInline(contextId, true, inlineVideoFrame(*model.videoElement())));
}

void VideoFullscreenManager::requestRouteSharingPolicyAndContextUID(PlaybackSessionContextIdentifier contextId, Messages::VideoFullscreenManager::RequestRouteSharingPolicyAndContextUID::AsyncReply&& reply)
{
    ensureModel(contextId).requestRouteSharingPolicyAndContextUID(WTFMove(reply));
}
    
void VideoFullscreenManager::setVideoLayerFrameFenced(PlaybackSessionContextIdentifier contextId, WebCore::FloatRect bounds, IPC::Attachment fencePort)
{
    LOG(Fullscreen, "VideoFullscreenManager::setVideoLayerFrameFenced(%p, %x)", this, contextId);


Return to Bug 212392

Lines 28-33 a/Source/WebKit/UIProcess/Cocoa/VideoFullscreenManagerProxy.h_sec1
- a/Source/WebKit/UIProcess/Cocoa/VideoFullscreenManagerProxy.h -38 / +39 lines
28	#if ENABLE(VIDEO_PRESENTATION_MODE)	28	#if ENABLE(VIDEO_PRESENTATION_MODE)
29		29
30	#include "MessageReceiver.h"	30	#include "MessageReceiver.h"
		31	#include "PlaybackSessionContextIdentifier.h"
31	#include <WebCore/AudioSession.h>	32	#include <WebCore/AudioSession.h>
32	#include <WebCore/GraphicsLayer.h>	33	#include <WebCore/GraphicsLayer.h>
33	#include <WebCore/PlatformView.h>	34	#include <WebCore/PlatformView.h>
Lines 63-69 class VideoFullscreenModelContext final a/Source/WebKit/UIProcess/Cocoa/VideoFullscreenManagerProxy.h_sec2
63	, public WebCore::VideoFullscreenModel	64	, public WebCore::VideoFullscreenModel
64	, public WebCore::VideoFullscreenChangeObserver {	65	, public WebCore::VideoFullscreenChangeObserver {
65	public:	66	public:
66	static Ref<VideoFullscreenModelContext> create(VideoFullscreenManagerProxy& manager, PlaybackSessionModelContext& playbackSessionModel, uint64_t contextId)	67	static Ref<VideoFullscreenModelContext> create(VideoFullscreenManagerProxy& manager, PlaybackSessionModelContext& playbackSessionModel, PlaybackSessionContextIdentifier contextId)
67	{	68	{
68	return adoptRef(*new VideoFullscreenModelContext(manager, playbackSessionModel, contextId));	69	return adoptRef(*new VideoFullscreenModelContext(manager, playbackSessionModel, contextId));
69	}	70	}
Lines 75-81 public: a/Source/WebKit/UIProcess/Cocoa/VideoFullscreenManagerProxy.h_sec3
75	void setLayerHostView(RetainPtr<PlatformView>&& layerHostView) { m_layerHostView = WTFMove(layerHostView); }	76	void setLayerHostView(RetainPtr<PlatformView>&& layerHostView) { m_layerHostView = WTFMove(layerHostView); }
76		77
77	private:	78	private:
78	VideoFullscreenModelContext(VideoFullscreenManagerProxy&, PlaybackSessionModelContext&, uint64_t);	79	VideoFullscreenModelContext(VideoFullscreenManagerProxy&, PlaybackSessionModelContext&, PlaybackSessionContextIdentifier);
79		80
80	// VideoFullscreenModel	81	// VideoFullscreenModel
81	void addClient(WebCore::VideoFullscreenModelClient&) override;	82	void addClient(WebCore::VideoFullscreenModelClient&) override;
Lines 110-116 private: a/Source/WebKit/UIProcess/Cocoa/VideoFullscreenManagerProxy.h_sec4
110		111
111	VideoFullscreenManagerProxy* m_manager;	112	VideoFullscreenManagerProxy* m_manager;
112	Ref<PlaybackSessionModelContext> m_playbackSessionModel;	113	Ref<PlaybackSessionModelContext> m_playbackSessionModel;
113	uint64_t m_contextId;	114	PlaybackSessionContextIdentifier m_contextId;
114	RetainPtr<PlatformView> m_layerHostView;	115	RetainPtr<PlatformView> m_layerHostView;
115	HashSet<WebCore::VideoFullscreenModelClient*> m_clients;	116	HashSet<WebCore::VideoFullscreenModelClient*> m_clients;
116	WebCore::FloatSize m_videoDimensions;	117	WebCore::FloatSize m_videoDimensions;
Lines 132-138 public: a/Source/WebKit/UIProcess/Cocoa/VideoFullscreenManagerProxy.h_sec5
132		133
133	void setMockVideoPresentationModeEnabled(bool enabled) { m_mockVideoPresentationModeEnabled = enabled; }	134	void setMockVideoPresentationModeEnabled(bool enabled) { m_mockVideoPresentationModeEnabled = enabled; }
134		135
135	void requestRouteSharingPolicyAndContextUID(uint64_t contextId, CompletionHandler<void(WebCore::RouteSharingPolicy, String)>&&);	136	void requestRouteSharingPolicyAndContextUID(PlaybackSessionContextIdentifier, CompletionHandler<void(WebCore::RouteSharingPolicy, String)>&&);
136		137
137	bool isPlayingVideoInEnhancedFullscreen() const;	138	bool isPlayingVideoInEnhancedFullscreen() const;
138		139
Lines 147-197 private: a/Source/WebKit/UIProcess/Cocoa/VideoFullscreenManagerProxy.h_sec6
147	void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;	148	void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
148		149
149	typedef std::tuple<RefPtr<VideoFullscreenModelContext>, RefPtr<PlatformVideoFullscreenInterface>> ModelInterfaceTuple;	150	typedef std::tuple<RefPtr<VideoFullscreenModelContext>, RefPtr<PlatformVideoFullscreenInterface>> ModelInterfaceTuple;
150	ModelInterfaceTuple createModelAndInterface(uint64_t contextId);	151	ModelInterfaceTuple createModelAndInterface(PlaybackSessionContextIdentifier);
151	ModelInterfaceTuple& ensureModelAndInterface(uint64_t contextId);	152	ModelInterfaceTuple& ensureModelAndInterface(PlaybackSessionContextIdentifier);
152	VideoFullscreenModelContext& ensureModel(uint64_t contextId);	153	VideoFullscreenModelContext& ensureModel(PlaybackSessionContextIdentifier);
153	PlatformVideoFullscreenInterface& ensureInterface(uint64_t contextId);	154	PlatformVideoFullscreenInterface& ensureInterface(PlaybackSessionContextIdentifier);
154	PlatformVideoFullscreenInterface* findInterface(uint64_t contextId);	155	PlatformVideoFullscreenInterface* findInterface(PlaybackSessionContextIdentifier);
155	void addClientForContext(uint64_t contextId);	156	void addClientForContext(PlaybackSessionContextIdentifier);
156	void removeClientForContext(uint64_t contextId);	157	void removeClientForContext(PlaybackSessionContextIdentifier);
157		158
158	void hasVideoInPictureInPictureDidChange(bool);	159	void hasVideoInPictureInPictureDidChange(bool);
159		160
160	// Messages from VideoFullscreenManager	161	// Messages from VideoFullscreenManager
161	void setupFullscreenWithID(uint64_t contextId, uint32_t videoLayerID, const WebCore::IntRect& initialRect, float hostingScaleFactor, WebCore::HTMLMediaElementEnums::VideoFullscreenMode, bool allowsPictureInPicture, bool standby);	162	void setupFullscreenWithID(PlaybackSessionContextIdentifier, uint32_t videoLayerID, const WebCore::IntRect& initialRect, float hostingScaleFactor, WebCore::HTMLMediaElementEnums::VideoFullscreenMode, bool allowsPictureInPicture, bool standby);
162	void setInlineRect(uint64_t contextId, const WebCore::IntRect& inlineRect, bool visible);	163	void setInlineRect(PlaybackSessionContextIdentifier, const WebCore::IntRect& inlineRect, bool visible);
163	void setHasVideoContentLayer(uint64_t contextId, bool value);	164	void setHasVideoContentLayer(PlaybackSessionContextIdentifier, bool value);
164	void setHasVideo(uint64_t contextId, bool);	165	void setHasVideo(PlaybackSessionContextIdentifier, bool);
165	void setVideoDimensions(uint64_t contextId, const WebCore::FloatSize&);	166	void setVideoDimensions(PlaybackSessionContextIdentifier, const WebCore::FloatSize&);
166	void enterFullscreen(uint64_t contextId);	167	void enterFullscreen(PlaybackSessionContextIdentifier);
167	void exitFullscreen(uint64_t contextId, WebCore::IntRect finalRect);	168	void exitFullscreen(PlaybackSessionContextIdentifier, WebCore::IntRect finalRect);
168	void cleanupFullscreen(uint64_t contextId);	169	void cleanupFullscreen(PlaybackSessionContextIdentifier);
169	void preparedToReturnToInline(uint64_t contextId, bool visible, WebCore::IntRect inlineRect);	170	void preparedToReturnToInline(PlaybackSessionContextIdentifier, bool visible, WebCore::IntRect inlineRect);
170	void preparedToExitFullscreen(uint64_t contextId);	171	void preparedToExitFullscreen(PlaybackSessionContextIdentifier);
171	void exitFullscreenWithoutAnimationToMode(uint64_t contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode);	172	void exitFullscreenWithoutAnimationToMode(PlaybackSessionContextIdentifier, WebCore::HTMLMediaElementEnums::VideoFullscreenMode);
172		173
173	// Messages to VideoFullscreenManager	174	// Messages to VideoFullscreenManager
174	void requestFullscreenMode(uint64_t contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode, bool finishedWithMedia = false);	175	void requestFullscreenMode(PlaybackSessionContextIdentifier, WebCore::HTMLMediaElementEnums::VideoFullscreenMode, bool finishedWithMedia = false);
175	void requestUpdateInlineRect(uint64_t contextId);	176	void requestUpdateInlineRect(PlaybackSessionContextIdentifier);
176	void requestVideoContentLayer(uint64_t contextId);	177	void requestVideoContentLayer(PlaybackSessionContextIdentifier);
177	void returnVideoContentLayer(uint64_t contextId);	178	void returnVideoContentLayer(PlaybackSessionContextIdentifier);
178	void didSetupFullscreen(uint64_t contextId);	179	void didSetupFullscreen(PlaybackSessionContextIdentifier);
179	void willExitFullscreen(uint64_t contextId);	180	void willExitFullscreen(PlaybackSessionContextIdentifier);
180	void didExitFullscreen(uint64_t contextId);	181	void didExitFullscreen(PlaybackSessionContextIdentifier);
181	void didEnterFullscreen(uint64_t contextId);	182	void didEnterFullscreen(PlaybackSessionContextIdentifier);
182	void didCleanupFullscreen(uint64_t contextId);	183	void didCleanupFullscreen(PlaybackSessionContextIdentifier);
183	void setVideoLayerFrame(uint64_t contextId, WebCore::FloatRect);	184	void setVideoLayerFrame(PlaybackSessionContextIdentifier, WebCore::FloatRect);
184	void setVideoLayerGravity(uint64_t contextId, WebCore::MediaPlayerEnums::VideoGravity);	185	void setVideoLayerGravity(PlaybackSessionContextIdentifier, WebCore::MediaPlayerEnums::VideoGravity);
185	void fullscreenModeChanged(uint64_t contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode);	186	void fullscreenModeChanged(PlaybackSessionContextIdentifier, WebCore::HTMLMediaElementEnums::VideoFullscreenMode);
186	void fullscreenMayReturnToInline(uint64_t contextId);	187	void fullscreenMayReturnToInline(PlaybackSessionContextIdentifier);
187		188
188	bool m_mockVideoPresentationModeEnabled { false };	189	bool m_mockVideoPresentationModeEnabled { false };
189		190
190	WebPageProxy* m_page;	191	WebPageProxy* m_page;
191	Ref<PlaybackSessionManagerProxy> m_playbackSessionManagerProxy;	192	Ref<PlaybackSessionManagerProxy> m_playbackSessionManagerProxy;
192	HashMap<uint64_t, ModelInterfaceTuple> m_contextMap;	193	HashMap<PlaybackSessionContextIdentifier, ModelInterfaceTuple> m_contextMap;
193	uint64_t m_controlsManagerContextId { 0 };	194	PlaybackSessionContextIdentifier m_controlsManagerContextId;
194	HashMap<uint64_t, int> m_clientCounts;	195	HashMap<PlaybackSessionContextIdentifier, int> m_clientCounts;
195	};	196	};
196		197
197	} // namespace WebKit	198	} // namespace WebKit

Lines 1-5 a/Source/WebKit/WebProcess/cocoa/PlaybackSessionManager.h_sec1
- a/Source/WebKit/WebProcess/cocoa/PlaybackSessionManager.h -50 / +51 lines
1	/*	1	/*
2	* Copyright (C) 2016-2017 Apple Inc. All rights reserved.	2	* Copyright (C) 2016-2020 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 28-33 a/Source/WebKit/WebProcess/cocoa/PlaybackSessionManager.h_sec2
28	#if PLATFORM(IOS_FAMILY) \|\| (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))	28	#if PLATFORM(IOS_FAMILY) \|\| (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
29		29
30	#include "MessageReceiver.h"	30	#include "MessageReceiver.h"
		31	#include "PlaybackSessionContextIdentifier.h"
31	#include <WebCore/EventListener.h>	32	#include <WebCore/EventListener.h>
32	#include <WebCore/HTMLMediaElementEnums.h>	33	#include <WebCore/HTMLMediaElementEnums.h>
33	#include <WebCore/PlatformCALayer.h>	34	#include <WebCore/PlatformCALayer.h>
Lines 57-63 class PlaybackSessionInterfaceContext final a/Source/WebKit/WebProcess/cocoa/PlaybackSessionManager.h_sec3
57	: public RefCounted<PlaybackSessionInterfaceContext>	58	: public RefCounted<PlaybackSessionInterfaceContext>
58	, public WebCore::PlaybackSessionModelClient {	59	, public WebCore::PlaybackSessionModelClient {
59	public:	60	public:
60	static Ref<PlaybackSessionInterfaceContext> create(PlaybackSessionManager& manager, uint64_t contextId)	61	static Ref<PlaybackSessionInterfaceContext> create(PlaybackSessionManager& manager, PlaybackSessionContextIdentifier contextId)
61	{	62	{
62	return adoptRef(*new PlaybackSessionInterfaceContext(manager, contextId));	63	return adoptRef(*new PlaybackSessionInterfaceContext(manager, contextId));
63	}	64	}
Lines 86-95 private: a/Source/WebKit/WebProcess/cocoa/PlaybackSessionManager.h_sec4
86	void volumeChanged(double) final;	87	void volumeChanged(double) final;
87	void isPictureInPictureSupportedChanged(bool) final;	88	void isPictureInPictureSupportedChanged(bool) final;
88		89
89	PlaybackSessionInterfaceContext(PlaybackSessionManager&, uint64_t contextId);	90	PlaybackSessionInterfaceContext(PlaybackSessionManager&, PlaybackSessionContextIdentifier);
90		91
91	PlaybackSessionManager* m_manager;	92	PlaybackSessionManager* m_manager;
92	uint64_t m_contextId;	93	PlaybackSessionContextIdentifier m_contextId;
93	};	94	};
94		95
95	class PlaybackSessionManager : public RefCounted<PlaybackSessionManager>, private IPC::MessageReceiver {	96	class PlaybackSessionManager : public RefCounted<PlaybackSessionManager>, private IPC::MessageReceiver {
Lines 103-109 public: a/Source/WebKit/WebProcess/cocoa/PlaybackSessionManager.h_sec5
103		104
104	void setUpPlaybackControlsManager(WebCore::HTMLMediaElement&);	105	void setUpPlaybackControlsManager(WebCore::HTMLMediaElement&);
105	void clearPlaybackControlsManager();	106	void clearPlaybackControlsManager();
106	uint64_t contextIdForMediaElement(WebCore::HTMLMediaElement&);	107	PlaybackSessionContextIdentifier contextIdForMediaElement(WebCore::HTMLMediaElement&);
107		108
108	WebCore::HTMLMediaElement* currentPlaybackControlsElement() const;	109	WebCore::HTMLMediaElement* currentPlaybackControlsElement() const;
109		110
Lines 114-170 protected: a/Source/WebKit/WebProcess/cocoa/PlaybackSessionManager.h_sec6
114	explicit PlaybackSessionManager(WebPage&);	115	explicit PlaybackSessionManager(WebPage&);
115		116
116	typedef std::tuple<RefPtr<WebCore::PlaybackSessionModelMediaElement>, RefPtr<PlaybackSessionInterfaceContext>> ModelInterfaceTuple;	117	typedef std::tuple<RefPtr<WebCore::PlaybackSessionModelMediaElement>, RefPtr<PlaybackSessionInterfaceContext>> ModelInterfaceTuple;
117	ModelInterfaceTuple createModelAndInterface(uint64_t contextId);	118	ModelInterfaceTuple createModelAndInterface(PlaybackSessionContextIdentifier);
118	ModelInterfaceTuple& ensureModelAndInterface(uint64_t contextId);	119	ModelInterfaceTuple& ensureModelAndInterface(PlaybackSessionContextIdentifier);
119	WebCore::PlaybackSessionModelMediaElement& ensureModel(uint64_t contextId);	120	WebCore::PlaybackSessionModelMediaElement& ensureModel(PlaybackSessionContextIdentifier);
120	PlaybackSessionInterfaceContext& ensureInterface(uint64_t contextId);	121	PlaybackSessionInterfaceContext& ensureInterface(PlaybackSessionContextIdentifier);
121	void removeContext(uint64_t contextId);	122	void removeContext(PlaybackSessionContextIdentifier);
122	void addClientForContext(uint64_t contextId);	123	void addClientForContext(PlaybackSessionContextIdentifier);
123	void removeClientForContext(uint64_t contextId);	124	void removeClientForContext(PlaybackSessionContextIdentifier);
124		125
125	// Interface to PlaybackSessionInterfaceContext	126	// Interface to PlaybackSessionInterfaceContext
126	void durationChanged(uint64_t contextId, double);	127	void durationChanged(PlaybackSessionContextIdentifier, double);
127	void currentTimeChanged(uint64_t contextId, double currentTime, double anchorTime);	128	void currentTimeChanged(PlaybackSessionContextIdentifier, double currentTime, double anchorTime);
128	void bufferedTimeChanged(uint64_t contextId, double bufferedTime);	129	void bufferedTimeChanged(PlaybackSessionContextIdentifier, double bufferedTime);
129	void playbackStartedTimeChanged(uint64_t contextId, double playbackStartedTime);	130	void playbackStartedTimeChanged(PlaybackSessionContextIdentifier, double playbackStartedTime);
130	void rateChanged(uint64_t contextId, bool isPlaying, float playbackRate);	131	void rateChanged(PlaybackSessionContextIdentifier, bool isPlaying, float playbackRate);
131	void seekableRangesChanged(uint64_t contextId, const WebCore::TimeRanges&, double lastModifiedTime, double liveUpdateInterval);	132	void seekableRangesChanged(PlaybackSessionContextIdentifier, const WebCore::TimeRanges&, double lastModifiedTime, double liveUpdateInterval);
132	void canPlayFastReverseChanged(uint64_t contextId, bool value);	133	void canPlayFastReverseChanged(PlaybackSessionContextIdentifier, bool value);
133	void audioMediaSelectionOptionsChanged(uint64_t contextId, const Vector<WebCore::MediaSelectionOption>& options, uint64_t selectedIndex);	134	void audioMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier, const Vector<WebCore::MediaSelectionOption>& options, uint64_t selectedIndex);
134	void legibleMediaSelectionOptionsChanged(uint64_t contextId, const Vector<WebCore::MediaSelectionOption>& options, uint64_t selectedIndex);	135	void legibleMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier, const Vector<WebCore::MediaSelectionOption>& options, uint64_t selectedIndex);
135	void audioMediaSelectionIndexChanged(uint64_t contextId, uint64_t selectedIndex);	136	void audioMediaSelectionIndexChanged(PlaybackSessionContextIdentifier, uint64_t selectedIndex);
136	void legibleMediaSelectionIndexChanged(uint64_t contextId, uint64_t selectedIndex);	137	void legibleMediaSelectionIndexChanged(PlaybackSessionContextIdentifier, uint64_t selectedIndex);
137	void externalPlaybackChanged(uint64_t contextId, bool enabled, WebCore::PlaybackSessionModel::ExternalPlaybackTargetType, String localizedDeviceName);	138	void externalPlaybackChanged(PlaybackSessionContextIdentifier, bool enabled, WebCore::PlaybackSessionModel::ExternalPlaybackTargetType, String localizedDeviceName);
138	void wirelessVideoPlaybackDisabledChanged(uint64_t contextId, bool);	139	void wirelessVideoPlaybackDisabledChanged(PlaybackSessionContextIdentifier, bool);
139	void mutedChanged(uint64_t contextId, bool);	140	void mutedChanged(PlaybackSessionContextIdentifier, bool);
140	void volumeChanged(uint64_t contextId, double);	141	void volumeChanged(PlaybackSessionContextIdentifier, double);
141	void isPictureInPictureSupportedChanged(uint64_t contextId, bool);	142	void isPictureInPictureSupportedChanged(PlaybackSessionContextIdentifier, bool);
142		143
143	// Messages from PlaybackSessionManagerProxy	144	// Messages from PlaybackSessionManagerProxy
144	void play(uint64_t contextId);	145	void play(PlaybackSessionContextIdentifier);
145	void pause(uint64_t contextId);	146	void pause(PlaybackSessionContextIdentifier);
146	void togglePlayState(uint64_t contextId);	147	void togglePlayState(PlaybackSessionContextIdentifier);
147	void beginScrubbing(uint64_t contextId);	148	void beginScrubbing(PlaybackSessionContextIdentifier);
148	void endScrubbing(uint64_t contextId);	149	void endScrubbing(PlaybackSessionContextIdentifier);
149	void seekToTime(uint64_t contextId, double time, double toleranceBefore, double toleranceAfter);	150	void seekToTime(PlaybackSessionContextIdentifier, double time, double toleranceBefore, double toleranceAfter);
150	void fastSeek(uint64_t contextId, double time);	151	void fastSeek(PlaybackSessionContextIdentifier, double time);
151	void beginScanningForward(uint64_t contextId);	152	void beginScanningForward(PlaybackSessionContextIdentifier);
152	void beginScanningBackward(uint64_t contextId);	153	void beginScanningBackward(PlaybackSessionContextIdentifier);
153	void endScanning(uint64_t contextId);	154	void endScanning(PlaybackSessionContextIdentifier);
154	void selectAudioMediaOption(uint64_t contextId, uint64_t index);	155	void selectAudioMediaOption(PlaybackSessionContextIdentifier, uint64_t index);
155	void selectLegibleMediaOption(uint64_t contextId, uint64_t index);	156	void selectLegibleMediaOption(PlaybackSessionContextIdentifier, uint64_t index);
156	void handleControlledElementIDRequest(uint64_t contextId);	157	void handleControlledElementIDRequest(PlaybackSessionContextIdentifier);
157	void togglePictureInPicture(uint64_t contextId);	158	void togglePictureInPicture(PlaybackSessionContextIdentifier);
158	void toggleMuted(uint64_t contextId);	159	void toggleMuted(PlaybackSessionContextIdentifier);
159	void setMuted(uint64_t contextId, bool muted);	160	void setMuted(PlaybackSessionContextIdentifier, bool muted);
160	void setVolume(uint64_t contextId, double volume);	161	void setVolume(PlaybackSessionContextIdentifier, double volume);
161	void setPlayingOnSecondScreen(uint64_t contextId, bool value);	162	void setPlayingOnSecondScreen(PlaybackSessionContextIdentifier, bool value);
162		163
163	WebPage* m_page;	164	WebPage* m_page;
164	HashMap<WebCore::HTMLMediaElement*, uint64_t> m_mediaElements;	165	HashMap<WebCore::HTMLMediaElement*, PlaybackSessionContextIdentifier> m_mediaElements;
165	HashMap<uint64_t, ModelInterfaceTuple> m_contextMap;	166	HashMap<PlaybackSessionContextIdentifier, ModelInterfaceTuple> m_contextMap;
166	uint64_t m_controlsManagerContextId { 0 };	167	PlaybackSessionContextIdentifier m_controlsManagerContextId;
167	HashCountedSet<uint64_t> m_clientCounts;	168	HashCountedSet<PlaybackSessionContextIdentifier> m_clientCounts;
168	};	169	};
169		170
170	} // namespace WebKit	171	} // namespace WebKit

Lines 1-5 a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.h_sec1
- a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.h -33 / +33 lines
1	/*	1	/*
2	* Copyright (C) 2014 Apple Inc. All rights reserved.	2	* Copyright (C) 2014-2020 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 29-34 a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.h_sec2
29		29
30	#include "Connection.h"	30	#include "Connection.h"
31	#include "MessageReceiver.h"	31	#include "MessageReceiver.h"
		32	#include "PlaybackSessionContextIdentifier.h"
32	#include "VideoFullscreenManagerMessagesReplies.h"	33	#include "VideoFullscreenManagerMessagesReplies.h"
33	#include <WebCore/EventListener.h>	34	#include <WebCore/EventListener.h>
34	#include <WebCore/HTMLMediaElementEnums.h>	35	#include <WebCore/HTMLMediaElementEnums.h>
Lines 62-68 class VideoFullscreenInterfaceContext a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.h_sec3
62	: public RefCounted<VideoFullscreenInterfaceContext>	63	: public RefCounted<VideoFullscreenInterfaceContext>
63	, public WebCore::VideoFullscreenModelClient {	64	, public WebCore::VideoFullscreenModelClient {
64	public:	65	public:
65	static Ref<VideoFullscreenInterfaceContext> create(VideoFullscreenManager& manager, uint64_t contextId)	66	static Ref<VideoFullscreenInterfaceContext> create(VideoFullscreenManager& manager, PlaybackSessionContextIdentifier contextId)
66	{	67	{
67	return adoptRef(*new VideoFullscreenInterfaceContext(manager, contextId));	68	return adoptRef(*new VideoFullscreenInterfaceContext(manager, contextId));
68	}	69	}
Lines 94-103 private: a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.h_sec4
94	void hasVideoChanged(bool) override;	95	void hasVideoChanged(bool) override;
95	void videoDimensionsChanged(const WebCore::FloatSize&) override;	96	void videoDimensionsChanged(const WebCore::FloatSize&) override;
96		97
97	VideoFullscreenInterfaceContext(VideoFullscreenManager&, uint64_t contextId);	98	VideoFullscreenInterfaceContext(VideoFullscreenManager&, PlaybackSessionContextIdentifier);
98		99
99	VideoFullscreenManager* m_manager;	100	VideoFullscreenManager* m_manager;
100	uint64_t m_contextId;	101	PlaybackSessionContextIdentifier m_contextId;
101	std::unique_ptr<LayerHostingContext> m_layerHostingContext;	102	std::unique_ptr<LayerHostingContext> m_layerHostingContext;
102	AnimationType m_animationType { false };	103	AnimationType m_animationType { false };
103	bool m_targetIsFullscreen { false };	104	bool m_targetIsFullscreen { false };
Lines 128-170 protected: a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.h_sec5
128	explicit VideoFullscreenManager(WebPage&, PlaybackSessionManager&);	129	explicit VideoFullscreenManager(WebPage&, PlaybackSessionManager&);
129		130
130	typedef std::tuple<RefPtr<WebCore::VideoFullscreenModelVideoElement>, RefPtr<VideoFullscreenInterfaceContext>> ModelInterfaceTuple;	131	typedef std::tuple<RefPtr<WebCore::VideoFullscreenModelVideoElement>, RefPtr<VideoFullscreenInterfaceContext>> ModelInterfaceTuple;
131	ModelInterfaceTuple createModelAndInterface(uint64_t contextId);	132	ModelInterfaceTuple createModelAndInterface(PlaybackSessionContextIdentifier);
132	ModelInterfaceTuple& ensureModelAndInterface(uint64_t contextId);	133	ModelInterfaceTuple& ensureModelAndInterface(PlaybackSessionContextIdentifier);
133	WebCore::VideoFullscreenModelVideoElement& ensureModel(uint64_t contextId);	134	WebCore::VideoFullscreenModelVideoElement& ensureModel(PlaybackSessionContextIdentifier);
134	VideoFullscreenInterfaceContext& ensureInterface(uint64_t contextId);	135	VideoFullscreenInterfaceContext& ensureInterface(PlaybackSessionContextIdentifier);
135	void removeContext(uint64_t contextId);	136	void removeContext(PlaybackSessionContextIdentifier);
136	void addClientForContext(uint64_t contextId);	137	void addClientForContext(PlaybackSessionContextIdentifier);
137	void removeClientForContext(uint64_t contextId);	138	void removeClientForContext(PlaybackSessionContextIdentifier);
138		139
139	// Interface to VideoFullscreenInterfaceContext	140	// Interface to VideoFullscreenInterfaceContext
140	void hasVideoChanged(uint64_t contextId, bool hasVideo);	141	void hasVideoChanged(PlaybackSessionContextIdentifier, bool hasVideo);
141	void videoDimensionsChanged(uint64_t contextId, const WebCore::FloatSize&);	142	void videoDimensionsChanged(PlaybackSessionContextIdentifier, const WebCore::FloatSize&);
142		143
143	// Messages from VideoFullscreenManagerProxy	144	// Messages from VideoFullscreenManagerProxy
144	void requestFullscreenMode(uint64_t contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode, bool finishedWithMedia);	145	void requestFullscreenMode(PlaybackSessionContextIdentifier, WebCore::HTMLMediaElementEnums::VideoFullscreenMode, bool finishedWithMedia);
145	void requestUpdateInlineRect(uint64_t contextId);	146	void requestUpdateInlineRect(PlaybackSessionContextIdentifier);
146	void requestVideoContentLayer(uint64_t contextId);	147	void requestVideoContentLayer(PlaybackSessionContextIdentifier);
147	void returnVideoContentLayer(uint64_t contextId);	148	void returnVideoContentLayer(PlaybackSessionContextIdentifier);
148	void didSetupFullscreen(uint64_t contextId);	149	void didSetupFullscreen(PlaybackSessionContextIdentifier);
149	void willExitFullscreen(uint64_t contextId);	150	void willExitFullscreen(PlaybackSessionContextIdentifier);
150	void didExitFullscreen(uint64_t contextId);	151	void didExitFullscreen(PlaybackSessionContextIdentifier);
151	void didEnterFullscreen(uint64_t contextId);	152	void didEnterFullscreen(PlaybackSessionContextIdentifier);
152	void didCleanupFullscreen(uint64_t contextId);	153	void didCleanupFullscreen(PlaybackSessionContextIdentifier);
153	void setVideoLayerFrameFenced(uint64_t contextId, WebCore::FloatRect bounds, IPC::Attachment fencePort);	154	void setVideoLayerFrameFenced(PlaybackSessionContextIdentifier, WebCore::FloatRect bounds, IPC::Attachment fencePort);
154	void setVideoLayerGravityEnum(uint64_t contextId, unsigned gravity);	155	void setVideoLayerGravityEnum(PlaybackSessionContextIdentifier, unsigned gravity);
155	void fullscreenModeChanged(uint64_t contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode);	156	void fullscreenModeChanged(PlaybackSessionContextIdentifier, WebCore::HTMLMediaElementEnums::VideoFullscreenMode);
156	void fullscreenMayReturnToInline(uint64_t contextId, bool isPageVisible);	157	void fullscreenMayReturnToInline(PlaybackSessionContextIdentifier, bool isPageVisible);
157	void requestRouteSharingPolicyAndContextUID(uint64_t contextId, Messages::VideoFullscreenManager::RequestRouteSharingPolicyAndContextUIDAsyncReply&&);	158	void requestRouteSharingPolicyAndContextUID(PlaybackSessionContextIdentifier, Messages::VideoFullscreenManager::RequestRouteSharingPolicyAndContextUIDAsyncReply&&);
158		159
159	WebPage* m_page;	160	WebPage* m_page;
160	Ref<PlaybackSessionManager> m_playbackSessionManager;	161	Ref<PlaybackSessionManager> m_playbackSessionManager;
161	HashMap<WebCore::HTMLVideoElement*, uint64_t> m_videoElements;	162	HashMap<WebCore::HTMLVideoElement*, PlaybackSessionContextIdentifier> m_videoElements;
162	HashMap<uint64_t, ModelInterfaceTuple> m_contextMap;	163	HashMap<PlaybackSessionContextIdentifier, ModelInterfaceTuple> m_contextMap;
163	uint64_t m_controlsManagerContextId { 0 };	164	PlaybackSessionContextIdentifier m_controlsManagerContextId;
164	HashMap<uint64_t, int> m_clientCounts;	165	HashMap<PlaybackSessionContextIdentifier, int> m_clientCounts;
165	};	166	};
166		167
167	} // namespace WebKit	168	} // namespace WebKit
168		169
169	#endif // ENABLE(VIDEO_PRESENTATION_MODE)	170	#endif // ENABLE(VIDEO_PRESENTATION_MODE)
170

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +183 lines
		1	2020-06-24 David Kilzer <ddkilzer@apple.com>
		2
		3	Use ObjectIdentifier<> instead of uint64_t for context IDs in VideoFullscreenManagerProxy
		4	<https://webkit.org/b/212392>
		5	<rdar://problem/61799040>
		6
		7	Reviewed by Youenn Fablet.
		8
		9	Switch from uint64_t to WebKit::PlaybackSessionContextIdentifier
		10	for contextId values.
		11
		12	* Scripts/webkit/messages.py:
		13	(types_that_cannot_be_forward_declared):
		14	- Add WebKit::PlaybackSessionContextIdentifier to list.
		15	* UIProcess/Cocoa/PlaybackSessionManagerProxy.h:
		16	(WebKit::PlaybackSessionManagerProxy::controlsManagerContextId const):
		17	* UIProcess/Cocoa/PlaybackSessionManagerProxy.messages.in:
		18	* UIProcess/Cocoa/PlaybackSessionManagerProxy.mm:
		19	(WebKit::PlaybackSessionManagerProxy::createModelAndInterface):
		20	(WebKit::PlaybackSessionManagerProxy::ensureModelAndInterface):
		21	(WebKit::PlaybackSessionManagerProxy::ensureModel):
		22	(WebKit::PlaybackSessionManagerProxy::ensureInterface):
		23	(WebKit::PlaybackSessionManagerProxy::addClientForContext):
		24	(WebKit::PlaybackSessionManagerProxy::removeClientForContext):
		25	(WebKit::PlaybackSessionManagerProxy::setUpPlaybackControlsManagerWithID):
		26	(WebKit::PlaybackSessionManagerProxy::clearPlaybackControlsManager):
		27	(WebKit::PlaybackSessionManagerProxy::currentTimeChanged):
		28	(WebKit::PlaybackSessionManagerProxy::bufferedTimeChanged):
		29	(WebKit::PlaybackSessionManagerProxy::seekableRangesVectorChanged):
		30	(WebKit::PlaybackSessionManagerProxy::canPlayFastReverseChanged):
		31	(WebKit::PlaybackSessionManagerProxy::audioMediaSelectionOptionsChanged):
		32	(WebKit::PlaybackSessionManagerProxy::legibleMediaSelectionOptionsChanged):
		33	(WebKit::PlaybackSessionManagerProxy::audioMediaSelectionIndexChanged):
		34	(WebKit::PlaybackSessionManagerProxy::legibleMediaSelectionIndexChanged):
		35	(WebKit::PlaybackSessionManagerProxy::externalPlaybackPropertiesChanged):
		36	(WebKit::PlaybackSessionManagerProxy::wirelessVideoPlaybackDisabledChanged):
		37	(WebKit::PlaybackSessionManagerProxy::mutedChanged):
		38	(WebKit::PlaybackSessionManagerProxy::volumeChanged):
		39	(WebKit::PlaybackSessionManagerProxy::durationChanged):
		40	(WebKit::PlaybackSessionManagerProxy::playbackStartedTimeChanged):
		41	(WebKit::PlaybackSessionManagerProxy::rateChanged):
		42	(WebKit::PlaybackSessionManagerProxy::pictureInPictureSupportedChanged):
		43	(WebKit::PlaybackSessionManagerProxy::handleControlledElementIDResponse const):
		44	(WebKit::PlaybackSessionManagerProxy::play):
		45	(WebKit::PlaybackSessionManagerProxy::pause):
		46	(WebKit::PlaybackSessionManagerProxy::togglePlayState):
		47	(WebKit::PlaybackSessionManagerProxy::beginScrubbing):
		48	(WebKit::PlaybackSessionManagerProxy::endScrubbing):
		49	(WebKit::PlaybackSessionManagerProxy::seekToTime):
		50	(WebKit::PlaybackSessionManagerProxy::fastSeek):
		51	(WebKit::PlaybackSessionManagerProxy::beginScanningForward):
		52	(WebKit::PlaybackSessionManagerProxy::beginScanningBackward):
		53	(WebKit::PlaybackSessionManagerProxy::endScanning):
		54	(WebKit::PlaybackSessionManagerProxy::selectAudioMediaOption):
		55	(WebKit::PlaybackSessionManagerProxy::selectLegibleMediaOption):
		56	(WebKit::PlaybackSessionManagerProxy::togglePictureInPicture):
		57	(WebKit::PlaybackSessionManagerProxy::toggleMuted):
		58	(WebKit::PlaybackSessionManagerProxy::setMuted):
		59	(WebKit::PlaybackSessionManagerProxy::setVolume):
		60	(WebKit::PlaybackSessionManagerProxy::setPlayingOnSecondScreen):
		61	- Remove MESSAGE_CHECK_CONTEXTID() since it is now redundant.
		62	* UIProcess/Cocoa/VideoFullscreenManagerProxy.h:
		63	* UIProcess/Cocoa/VideoFullscreenManagerProxy.messages.in:
		64	* UIProcess/Cocoa/VideoFullscreenManagerProxy.mm:
65	(WebKit::VideoFullscreenModelContext::VideoFullscreenModelContext):
66	(WebKit::VideoFullscreenManagerProxy::requestRouteSharingPolicyAndContextUID):
67	(WebKit::VideoFullscreenManagerProxy::createModelAndInterface):
68	(WebKit::VideoFullscreenManagerProxy::ensureModelAndInterface):
69	(WebKit::VideoFullscreenManagerProxy::ensureModel):
70	(WebKit::VideoFullscreenManagerProxy::ensureInterface):
71	(WebKit::VideoFullscreenManagerProxy::findInterface):
72	(WebKit::VideoFullscreenManagerProxy::addClientForContext):
73	(WebKit::VideoFullscreenManagerProxy::removeClientForContext):
74	(WebKit::VideoFullscreenManagerProxy::setupFullscreenWithID):
75	(WebKit::VideoFullscreenManagerProxy::setHasVideo):
76	(WebKit::VideoFullscreenManagerProxy::setVideoDimensions):
77	(WebKit::VideoFullscreenManagerProxy::enterFullscreen):
78	(WebKit::VideoFullscreenManagerProxy::exitFullscreen):
79	(WebKit::VideoFullscreenManagerProxy::exitFullscreenWithoutAnimationToMode):
80	(WebKit::VideoFullscreenManagerProxy::setInlineRect):
81	(WebKit::VideoFullscreenManagerProxy::setHasVideoContentLayer):
82	(WebKit::VideoFullscreenManagerProxy::cleanupFullscreen):
83	(WebKit::VideoFullscreenManagerProxy::preparedToReturnToInline):
84	(WebKit::VideoFullscreenManagerProxy::preparedToExitFullscreen):
85	(WebKit::VideoFullscreenManagerProxy::requestFullscreenMode):
86	(WebKit::VideoFullscreenManagerProxy::requestUpdateInlineRect):
87	(WebKit::VideoFullscreenManagerProxy::requestVideoContentLayer):
88	(WebKit::VideoFullscreenManagerProxy::returnVideoContentLayer):
89	(WebKit::VideoFullscreenManagerProxy::didSetupFullscreen):
90	(WebKit::VideoFullscreenManagerProxy::willExitFullscreen):
91	(WebKit::VideoFullscreenManagerProxy::didExitFullscreen):
92	(WebKit::VideoFullscreenManagerProxy::didEnterFullscreen):
93	(WebKit::VideoFullscreenManagerProxy::didCleanupFullscreen):
94	(WebKit::VideoFullscreenManagerProxy::setVideoLayerFrame):
95	(WebKit::VideoFullscreenManagerProxy::setVideoLayerGravity):
96	(WebKit::VideoFullscreenManagerProxy::fullscreenModeChanged):
97	(WebKit::VideoFullscreenManagerProxy::fullscreenMayReturnToInline):
98	- Remove MESSAGE_CHECK_CONTEXTID() since it is now redundant.
99	* WebKit.xcodeproj/project.pbxproj:
100	- Add PlaybackSessionContextIdentifier.h to the project.
101	* WebProcess/cocoa/PlaybackSessionContextIdentifier.h: Add.
102	* WebProcess/cocoa/PlaybackSessionManager.h:
103	* WebProcess/cocoa/PlaybackSessionManager.messages.in:
104	* WebProcess/cocoa/PlaybackSessionManager.mm:
105	(WebKit::PlaybackSessionInterfaceContext::PlaybackSessionInterfaceContext):
106	(WebKit::PlaybackSessionManager::createModelAndInterface):
107	(WebKit::PlaybackSessionManager::ensureModelAndInterface):
108	(WebKit::PlaybackSessionManager::ensureModel):
109	(WebKit::PlaybackSessionManager::ensureInterface):
110	(WebKit::PlaybackSessionManager::removeContext):
111	(WebKit::PlaybackSessionManager::addClientForContext):
112	(WebKit::PlaybackSessionManager::removeClientForContext):
113	(WebKit::PlaybackSessionManager::setUpPlaybackControlsManager):
114	(WebKit::PlaybackSessionManager::clearPlaybackControlsManager):
115	(WebKit::PlaybackSessionManager::contextIdForMediaElement):
116	(WebKit::PlaybackSessionManager::durationChanged):
117	(WebKit::PlaybackSessionManager::currentTimeChanged):
118	(WebKit::PlaybackSessionManager::bufferedTimeChanged):
119	(WebKit::PlaybackSessionManager::playbackStartedTimeChanged):
120	(WebKit::PlaybackSessionManager::rateChanged):
121	(WebKit::PlaybackSessionManager::seekableRangesChanged):
122	(WebKit::PlaybackSessionManager::canPlayFastReverseChanged):
123	(WebKit::PlaybackSessionManager::audioMediaSelectionOptionsChanged):
124	(WebKit::PlaybackSessionManager::legibleMediaSelectionOptionsChanged):
125	(WebKit::PlaybackSessionManager::externalPlaybackChanged):
126	(WebKit::PlaybackSessionManager::audioMediaSelectionIndexChanged):
127	(WebKit::PlaybackSessionManager::legibleMediaSelectionIndexChanged):
128	(WebKit::PlaybackSessionManager::wirelessVideoPlaybackDisabledChanged):
129	(WebKit::PlaybackSessionManager::mutedChanged):
130	(WebKit::PlaybackSessionManager::volumeChanged):
131	(WebKit::PlaybackSessionManager::isPictureInPictureSupportedChanged):
132	(WebKit::PlaybackSessionManager::play):
133	(WebKit::PlaybackSessionManager::pause):
134	(WebKit::PlaybackSessionManager::togglePlayState):
135	(WebKit::PlaybackSessionManager::beginScrubbing):
136	(WebKit::PlaybackSessionManager::endScrubbing):
137	(WebKit::PlaybackSessionManager::seekToTime):
138	(WebKit::PlaybackSessionManager::fastSeek):
139	(WebKit::PlaybackSessionManager::beginScanningForward):
140	(WebKit::PlaybackSessionManager::beginScanningBackward):
141	(WebKit::PlaybackSessionManager::endScanning):
142	(WebKit::PlaybackSessionManager::selectAudioMediaOption):
143	(WebKit::PlaybackSessionManager::selectLegibleMediaOption):
144	(WebKit::PlaybackSessionManager::handleControlledElementIDRequest):
145	(WebKit::PlaybackSessionManager::togglePictureInPicture):
146	(WebKit::PlaybackSessionManager::toggleMuted):
147	(WebKit::PlaybackSessionManager::setMuted):
148	(WebKit::PlaybackSessionManager::setVolume):
149	(WebKit::PlaybackSessionManager::setPlayingOnSecondScreen):
150	(WebKit::nextContextId): Delete.
151	- Replace with PlaybackSessionContextIdentifier::generate().
152	* WebProcess/cocoa/VideoFullscreenManager.h:
153	(WebKit::VideoFullscreenInterfaceContext::create):
154	* WebProcess/cocoa/VideoFullscreenManager.messages.in:
155	* WebProcess/cocoa/VideoFullscreenManager.mm:
156	(WebKit::VideoFullscreenInterfaceContext::VideoFullscreenInterfaceContext):
157	(WebKit::VideoFullscreenManager::createModelAndInterface):
158	(WebKit::VideoFullscreenManager::ensureModelAndInterface):
159	(WebKit::VideoFullscreenManager::ensureModel):
160	(WebKit::VideoFullscreenManager::ensureInterface):
161	(WebKit::VideoFullscreenManager::removeContext):
162	(WebKit::VideoFullscreenManager::addClientForContext):
163	(WebKit::VideoFullscreenManager::removeClientForContext):
164	(WebKit::VideoFullscreenManager::enterVideoFullscreenForVideoElement):
165	(WebKit::VideoFullscreenManager::exitVideoFullscreenForVideoElement):
166	(WebKit::VideoFullscreenManager::exitVideoFullscreenToModeWithoutAnimation):
167	(WebKit::VideoFullscreenManager::hasVideoChanged):
168	(WebKit::VideoFullscreenManager::videoDimensionsChanged):
169	(WebKit::VideoFullscreenManager::requestFullscreenMode):
170	(WebKit::VideoFullscreenManager::fullscreenModeChanged):
171	(WebKit::VideoFullscreenManager::requestUpdateInlineRect):
172	(WebKit::VideoFullscreenManager::requestVideoContentLayer):
173	(WebKit::VideoFullscreenManager::returnVideoContentLayer):
174	(WebKit::VideoFullscreenManager::didSetupFullscreen):
175	(WebKit::VideoFullscreenManager::willExitFullscreen):
176	(WebKit::VideoFullscreenManager::didEnterFullscreen):
177	(WebKit::VideoFullscreenManager::didExitFullscreen):
178	(WebKit::VideoFullscreenManager::didCleanupFullscreen):
179	(WebKit::VideoFullscreenManager::setVideoLayerGravityEnum):
180	(WebKit::VideoFullscreenManager::fullscreenMayReturnToInline):
181	(WebKit::VideoFullscreenManager::requestRouteSharingPolicyAndContextUID):
182	(WebKit::VideoFullscreenManager::setVideoLayerFrameFenced):
183
1	2020-06-23 Wenson Hsieh <wenson_hsieh@apple.com>	184	2020-06-23 Wenson Hsieh <wenson_hsieh@apple.com>
2		185
3	REGRESSION (r244633): Mail flashes when copying text in an email	186	REGRESSION (r244633): Mail flashes when copying text in an email

Lines 28-33 a/Source/WebKit/UIProcess/Cocoa/PlaybackSessionManagerProxy.h_sec1
- a/Source/WebKit/UIProcess/Cocoa/PlaybackSessionManagerProxy.h -48 / +49 lines
28	#if PLATFORM(IOS_FAMILY) \|\| (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))	28	#if PLATFORM(IOS_FAMILY) \|\| (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
29		29
30	#include "MessageReceiver.h"	30	#include "MessageReceiver.h"
		31	#include "PlaybackSessionContextIdentifier.h"
31	#include <WebCore/GraphicsLayer.h>	32	#include <WebCore/GraphicsLayer.h>
32	#include <WebCore/MediaSelectionOption.h>	33	#include <WebCore/MediaSelectionOption.h>
33	#include <WebCore/PlatformView.h>	34	#include <WebCore/PlatformView.h>
Lines 58-64 class PlaybackSessionManagerProxy; a/Source/WebKit/UIProcess/Cocoa/PlaybackSessionManagerProxy.h_sec2
58		59
59	class PlaybackSessionModelContext final: public RefCounted<PlaybackSessionModelContext>, public WebCore::PlaybackSessionModel {	60	class PlaybackSessionModelContext final: public RefCounted<PlaybackSessionModelContext>, public WebCore::PlaybackSessionModel {
60	public:	61	public:
61	static Ref<PlaybackSessionModelContext> create(PlaybackSessionManagerProxy& manager, uint64_t contextId)	62	static Ref<PlaybackSessionModelContext> create(PlaybackSessionManagerProxy& manager, PlaybackSessionContextIdentifier contextId)
62	{	63	{
63	return adoptRef(*new PlaybackSessionModelContext(manager, contextId));	64	return adoptRef(*new PlaybackSessionModelContext(manager, contextId));
64	}	65	}
Lines 91-97 public: a/Source/WebKit/UIProcess/Cocoa/PlaybackSessionManagerProxy.h_sec3
91	private:	92	private:
92	friend class VideoFullscreenModelContext;	93	friend class VideoFullscreenModelContext;
93		94
94	PlaybackSessionModelContext(PlaybackSessionManagerProxy& manager, uint64_t contextId)	95	PlaybackSessionModelContext(PlaybackSessionManagerProxy& manager, PlaybackSessionContextIdentifier contextId)
95	: m_manager(&manager)	96	: m_manager(&manager)
96	, m_contextId(contextId)	97	, m_contextId(contextId)
97	{	98	{
Lines 141-147 private: a/Source/WebKit/UIProcess/Cocoa/PlaybackSessionManagerProxy.h_sec4
141	bool isPictureInPictureActive() const final { return m_pictureInPictureActive; }	142	bool isPictureInPictureActive() const final { return m_pictureInPictureActive; }
142		143
143	PlaybackSessionManagerProxy* m_manager;	144	PlaybackSessionManagerProxy* m_manager;
144	uint64_t m_contextId;	145	PlaybackSessionContextIdentifier m_contextId;
145	HashSet<WebCore::PlaybackSessionModelClient*> m_clients;	146	HashSet<WebCore::PlaybackSessionModelClient*> m_clients;
146	double m_playbackStartedTime { 0 };	147	double m_playbackStartedTime { 0 };
147	bool m_playbackStartedTimeNeedsUpdate { false };	148	bool m_playbackStartedTimeNeedsUpdate { false };
Lines 187-245 private: a/Source/WebKit/UIProcess/Cocoa/PlaybackSessionManagerProxy.h_sec5
187	void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;	188	void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;
188		189
189	typedef std::tuple<RefPtr<PlaybackSessionModelContext>, RefPtr<PlatformPlaybackSessionInterface>> ModelInterfaceTuple;	190	typedef std::tuple<RefPtr<PlaybackSessionModelContext>, RefPtr<PlatformPlaybackSessionInterface>> ModelInterfaceTuple;
190	ModelInterfaceTuple createModelAndInterface(uint64_t contextId);	191	ModelInterfaceTuple createModelAndInterface(PlaybackSessionContextIdentifier);
191	ModelInterfaceTuple& ensureModelAndInterface(uint64_t contextId);	192	ModelInterfaceTuple& ensureModelAndInterface(PlaybackSessionContextIdentifier);
192	PlaybackSessionModelContext& ensureModel(uint64_t contextId);	193	PlaybackSessionModelContext& ensureModel(PlaybackSessionContextIdentifier);
193	PlatformPlaybackSessionInterface& ensureInterface(uint64_t contextId);	194	PlatformPlaybackSessionInterface& ensureInterface(PlaybackSessionContextIdentifier);
194	void addClientForContext(uint64_t contextId);	195	void addClientForContext(PlaybackSessionContextIdentifier);
195	void removeClientForContext(uint64_t contextId);	196	void removeClientForContext(PlaybackSessionContextIdentifier);
196		197
197	uint64_t controlsManagerContextId() const { return m_controlsManagerContextId; }	198	PlaybackSessionContextIdentifier controlsManagerContextId() const { return m_controlsManagerContextId; }
198		199
199	// Messages from PlaybackSessionManager	200	// Messages from PlaybackSessionManager
200	void setUpPlaybackControlsManagerWithID(uint64_t contextId);	201	void setUpPlaybackControlsManagerWithID(PlaybackSessionContextIdentifier);
201	void clearPlaybackControlsManager();	202	void clearPlaybackControlsManager();
202	void currentTimeChanged(uint64_t contextId, double currentTime, double hostTime);	203	void currentTimeChanged(PlaybackSessionContextIdentifier, double currentTime, double hostTime);
203	void bufferedTimeChanged(uint64_t contextId, double bufferedTime);	204	void bufferedTimeChanged(PlaybackSessionContextIdentifier, double bufferedTime);
204	void seekableRangesVectorChanged(uint64_t contextId, Vector<std::pair<double, double>> ranges, double lastModifiedTime, double liveUpdateInterval);	205	void seekableRangesVectorChanged(PlaybackSessionContextIdentifier, Vector<std::pair<double, double>> ranges, double lastModifiedTime, double liveUpdateInterval);
205	void canPlayFastReverseChanged(uint64_t contextId, bool value);	206	void canPlayFastReverseChanged(PlaybackSessionContextIdentifier, bool value);
206	void audioMediaSelectionOptionsChanged(uint64_t contextId, Vector<WebCore::MediaSelectionOption> options, uint64_t selectedIndex);	207	void audioMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier, Vector<WebCore::MediaSelectionOption> options, uint64_t selectedIndex);
207	void legibleMediaSelectionOptionsChanged(uint64_t contextId, Vector<WebCore::MediaSelectionOption> options, uint64_t selectedIndex);	208	void legibleMediaSelectionOptionsChanged(PlaybackSessionContextIdentifier, Vector<WebCore::MediaSelectionOption> options, uint64_t selectedIndex);
208	void audioMediaSelectionIndexChanged(uint64_t contextId, uint64_t selectedIndex);	209	void audioMediaSelectionIndexChanged(PlaybackSessionContextIdentifier, uint64_t selectedIndex);
209	void legibleMediaSelectionIndexChanged(uint64_t contextId, uint64_t selectedIndex);	210	void legibleMediaSelectionIndexChanged(PlaybackSessionContextIdentifier, uint64_t selectedIndex);
210	void externalPlaybackPropertiesChanged(uint64_t contextId, bool enabled, uint32_t targetType, String localizedDeviceName);	211	void externalPlaybackPropertiesChanged(PlaybackSessionContextIdentifier, bool enabled, uint32_t targetType, String localizedDeviceName);
211	void wirelessVideoPlaybackDisabledChanged(uint64_t contextId, bool);	212	void wirelessVideoPlaybackDisabledChanged(PlaybackSessionContextIdentifier, bool);
212	void durationChanged(uint64_t contextId, double duration);	213	void durationChanged(PlaybackSessionContextIdentifier, double duration);
213	void playbackStartedTimeChanged(uint64_t contextId, double playbackStartedTime);	214	void playbackStartedTimeChanged(PlaybackSessionContextIdentifier, double playbackStartedTime);
214	void rateChanged(uint64_t contextId, bool isPlaying, double rate);	215	void rateChanged(PlaybackSessionContextIdentifier, bool isPlaying, double rate);
215	void handleControlledElementIDResponse(uint64_t, String) const;	216	void handleControlledElementIDResponse(PlaybackSessionContextIdentifier, String) const;
216	void mutedChanged(uint64_t contextId, bool muted);	217	void mutedChanged(PlaybackSessionContextIdentifier, bool muted);
217	void volumeChanged(uint64_t contextId, double volume);	218	void volumeChanged(PlaybackSessionContextIdentifier, double volume);
218	void pictureInPictureSupportedChanged(uint64_t contextId, bool pictureInPictureSupported);	219	void pictureInPictureSupportedChanged(PlaybackSessionContextIdentifier, bool pictureInPictureSupported);
219		220
220	// Messages to PlaybackSessionManager	221	// Messages to PlaybackSessionManager
221	void play(uint64_t contextId);	222	void play(PlaybackSessionContextIdentifier);
222	void pause(uint64_t contextId);	223	void pause(PlaybackSessionContextIdentifier);
223	void togglePlayState(uint64_t contextId);	224	void togglePlayState(PlaybackSessionContextIdentifier);
224	void beginScrubbing(uint64_t contextId);	225	void beginScrubbing(PlaybackSessionContextIdentifier);
225	void endScrubbing(uint64_t contextId);	226	void endScrubbing(PlaybackSessionContextIdentifier);
226	void seekToTime(uint64_t contextId, double time, double before, double after);	227	void seekToTime(PlaybackSessionContextIdentifier, double time, double before, double after);
227	void fastSeek(uint64_t contextId, double time);	228	void fastSeek(PlaybackSessionContextIdentifier, double time);
228	void beginScanningForward(uint64_t contextId);	229	void beginScanningForward(PlaybackSessionContextIdentifier);
229	void beginScanningBackward(uint64_t contextId);	230	void beginScanningBackward(PlaybackSessionContextIdentifier);
230	void endScanning(uint64_t contextId);	231	void endScanning(PlaybackSessionContextIdentifier);
231	void selectAudioMediaOption(uint64_t contextId, uint64_t index);	232	void selectAudioMediaOption(PlaybackSessionContextIdentifier, uint64_t index);
232	void selectLegibleMediaOption(uint64_t contextId, uint64_t index);	233	void selectLegibleMediaOption(PlaybackSessionContextIdentifier, uint64_t index);
233	void togglePictureInPicture(uint64_t contextId);	234	void togglePictureInPicture(PlaybackSessionContextIdentifier);
234	void toggleMuted(uint64_t contextId);	235	void toggleMuted(PlaybackSessionContextIdentifier);
235	void setMuted(uint64_t contextId, bool);	236	void setMuted(PlaybackSessionContextIdentifier, bool);
236	void setVolume(uint64_t contextId, double);	237	void setVolume(PlaybackSessionContextIdentifier, double);
237	void setPlayingOnSecondScreen(uint64_t contextId, bool);	238	void setPlayingOnSecondScreen(PlaybackSessionContextIdentifier, bool);
238		239
239	WebPageProxy* m_page;	240	WebPageProxy* m_page;
240	HashMap<uint64_t, ModelInterfaceTuple> m_contextMap;	241	HashMap<PlaybackSessionContextIdentifier, ModelInterfaceTuple> m_contextMap;
241	uint64_t m_controlsManagerContextId { 0 };	242	PlaybackSessionContextIdentifier m_controlsManagerContextId;
242	HashCountedSet<uint64_t> m_clientCounts;	243	HashCountedSet<PlaybackSessionContextIdentifier> m_clientCounts;
243	};	244	};
244		245
245	} // namespace WebKit	246	} // namespace WebKit

Lines 934-939 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec1
- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj +4 lines
934	41FAF5F51E3C0649001AE678 /* WebRTCResolver.h in Headers / = {isa = PBXBuildFile; fileRef = 41FAF5F41E3C0641001AE678 / WebRTCResolver.h */; };	934	41FAF5F51E3C0649001AE678 /* WebRTCResolver.h in Headers / = {isa = PBXBuildFile; fileRef = 41FAF5F41E3C0641001AE678 / WebRTCResolver.h */; };
935	41FAF5F81E3C1021001AE678 /* LibWebRTCResolver.h in Headers / = {isa = PBXBuildFile; fileRef = 41FAF5F61E3C0B47001AE678 / LibWebRTCResolver.h */; };	935	41FAF5F81E3C1021001AE678 /* LibWebRTCResolver.h in Headers / = {isa = PBXBuildFile; fileRef = 41FAF5F61E3C0B47001AE678 / LibWebRTCResolver.h */; };
936	4459984222833E8700E61373 /* SyntheticEditingCommandType.h in Headers / = {isa = PBXBuildFile; fileRef = 4459984122833E6000E61373 / SyntheticEditingCommandType.h */; };	936	4459984222833E8700E61373 /* SyntheticEditingCommandType.h in Headers / = {isa = PBXBuildFile; fileRef = 4459984122833E6000E61373 / SyntheticEditingCommandType.h */; };
		937	446DC64C24A2D8E50061F390 /* PlaybackSessionContextIdentifier.h in Headers / = {isa = PBXBuildFile; fileRef = 446DC64B24A2D8AD0061F390 / PlaybackSessionContextIdentifier.h */; };
937	4482734724528F6000A95493 /* CocoaImage.h in Headers / = {isa = PBXBuildFile; fileRef = 4482734624528F6000A95493 / CocoaImage.h */; };	938	4482734724528F6000A95493 /* CocoaImage.h in Headers / = {isa = PBXBuildFile; fileRef = 4482734624528F6000A95493 / CocoaImage.h */; };
938	449D90DA21FDC30B00F677C0 /* LocalAuthenticationSoftLink.mm in Sources / = {isa = PBXBuildFile; fileRef = 449D90D821FD63FE00F677C0 / LocalAuthenticationSoftLink.mm */; };	939	449D90DA21FDC30B00F677C0 /* LocalAuthenticationSoftLink.mm in Sources / = {isa = PBXBuildFile; fileRef = 449D90D821FD63FE00F677C0 / LocalAuthenticationSoftLink.mm */; };
939	44E936FD2447C2D8009FA3E3 /* LegacyCustomProtocolID.h in Headers / = {isa = PBXBuildFile; fileRef = 44E936FC2447C256009FA3E3 / LegacyCustomProtocolID.h */; };	940	44E936FD2447C2D8009FA3E3 /* LegacyCustomProtocolID.h in Headers / = {isa = PBXBuildFile; fileRef = 44E936FC2447C256009FA3E3 / LegacyCustomProtocolID.h */; };
Lines 3536-3541 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec2
3536	41FCD6BF23CE044000C62567 /* RemoteSampleBufferDisplayLayerManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RemoteSampleBufferDisplayLayerManager.h; sourceTree = "<group>"; };	3537	41FCD6BF23CE044000C62567 /* RemoteSampleBufferDisplayLayerManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RemoteSampleBufferDisplayLayerManager.h; sourceTree = "<group>"; };
3537	4450AEBF1DC3FAE5009943F2 /* SharedMemoryCocoa.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SharedMemoryCocoa.cpp; sourceTree = "<group>"; };	3538	4450AEBF1DC3FAE5009943F2 /* SharedMemoryCocoa.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SharedMemoryCocoa.cpp; sourceTree = "<group>"; };
3538	4459984122833E6000E61373 /* SyntheticEditingCommandType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SyntheticEditingCommandType.h; sourceTree = "<group>"; };	3539	4459984122833E6000E61373 /* SyntheticEditingCommandType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SyntheticEditingCommandType.h; sourceTree = "<group>"; };
		3540	446DC64B24A2D8AD0061F390 /* PlaybackSessionContextIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlaybackSessionContextIdentifier.h; sourceTree = "<group>"; };
3539	4482734624528F6000A95493 /* CocoaImage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CocoaImage.h; sourceTree = "<group>"; };	3541	4482734624528F6000A95493 /* CocoaImage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CocoaImage.h; sourceTree = "<group>"; };
3540	449D90D821FD63FE00F677C0 /* LocalAuthenticationSoftLink.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LocalAuthenticationSoftLink.mm; sourceTree = "<group>"; };	3542	449D90D821FD63FE00F677C0 /* LocalAuthenticationSoftLink.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LocalAuthenticationSoftLink.mm; sourceTree = "<group>"; };
3541	44A481C621F2D27B00F2F919 /* ClientCertificateAuthenticationXPCConstants.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ClientCertificateAuthenticationXPCConstants.cpp; sourceTree = "<group>"; };	3543	44A481C621F2D27B00F2F919 /* ClientCertificateAuthenticationXPCConstants.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ClientCertificateAuthenticationXPCConstants.cpp; sourceTree = "<group>"; };
Lines 8381-8386 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec3
8381	children = (	8383	children = (
8382	CD4570CB2440FB2A00A3DCEB /* AudioSessionRoutingArbitrator.cpp */,	8384	CD4570CB2440FB2A00A3DCEB /* AudioSessionRoutingArbitrator.cpp */,
8383	CD4570CA2440FB2A00A3DCEB /* AudioSessionRoutingArbitrator.h */,	8385	CD4570CA2440FB2A00A3DCEB /* AudioSessionRoutingArbitrator.h */,
		8386	446DC64B24A2D8AD0061F390 /* PlaybackSessionContextIdentifier.h */,
8384	CDA29A191CBDBF4100901CCF /* PlaybackSessionManager.h */,	8387	CDA29A191CBDBF4100901CCF /* PlaybackSessionManager.h */,
8385	CDA29A1C1CBDBF5B00901CCF /* PlaybackSessionManager.messages.in */,	8388	CDA29A1C1CBDBF5B00901CCF /* PlaybackSessionManager.messages.in */,
8386	CDA29A181CBDBF4100901CCF /* PlaybackSessionManager.mm */,	8389	CDA29A181CBDBF4100901CCF /* PlaybackSessionManager.mm */,
Lines 11002-11007 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec4
11002	2D8710171828415D0018FA01 /* PlatformCALayerRemoteCustom.h in Headers */,	11005	2D8710171828415D0018FA01 /* PlatformCALayerRemoteCustom.h in Headers */,
11003	2D8949F1182044F600E898AA /* PlatformCALayerRemoteTiledBacking.h in Headers */,	11006	2D8949F1182044F600E898AA /* PlatformCALayerRemoteTiledBacking.h in Headers */,
11004	BCC43ABB127B95DC00317F16 /* PlatformPopupMenuData.h in Headers */,	11007	BCC43ABB127B95DC00317F16 /* PlatformPopupMenuData.h in Headers */,
		11008	446DC64C24A2D8E50061F390 /* PlaybackSessionContextIdentifier.h in Headers */,
11005	CDA29A1B1CBDBF4100901CCF /* PlaybackSessionManager.h in Headers */,	11009	CDA29A1B1CBDBF4100901CCF /* PlaybackSessionManager.h in Headers */,
11006	CDA29A291CBEB67A00901CCF /* PlaybackSessionManagerMessages.h in Headers */,	11010	CDA29A291CBEB67A00901CCF /* PlaybackSessionManagerMessages.h in Headers */,
11007	CDA29A201CBEB5FB00901CCF /* PlaybackSessionManagerProxy.h in Headers */,	11011	CDA29A201CBEB5FB00901CCF /* PlaybackSessionManagerProxy.h in Headers */,

Line 0 a/Source/WebKit/WebProcess/cocoa/PlaybackSessionContextIdentifier.h_sec1
- a/Source/WebKit/WebProcess/cocoa/PlaybackSessionContextIdentifier.h +35 lines
	1	/*
	2	* Copyright (C) 2020 Apple Inc. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
	14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
	17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	23	* THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26	#pragma once
	27
	28	#include <wtf/ObjectIdentifier.h>
	29
	30	namespace WebKit {
	31
	32	enum PlaybackSessionContextIdentifierType { };
	33	using PlaybackSessionContextIdentifier = ObjectIdentifier<PlaybackSessionContextIdentifierType>;
	34
	35	}

Lines 1-4 a/Source/WebKit/WebProcess/cocoa/PlaybackSessionManager.messages.in_sec1
- a/Source/WebKit/WebProcess/cocoa/PlaybackSessionManager.messages.in -19 / +19 lines
1	# Copyright (C) 2016 Apple Inc. All rights reserved.	1	# Copyright (C) 2016-2020 Apple Inc. All rights reserved.
2	#	2	#
3	# Redistribution and use in source and binary forms, with or without	3	# Redistribution and use in source and binary forms, with or without
4	# modification, are permitted provided that the following conditions	4	# modification, are permitted provided that the following conditions
Lines 23-45 a/Source/WebKit/WebProcess/cocoa/PlaybackSessionManager.messages.in_sec2
23		23
24	#if PLATFORM(IOS_FAMILY) \|\| (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))	24	#if PLATFORM(IOS_FAMILY) \|\| (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
25	messages -> PlaybackSessionManager {	25	messages -> PlaybackSessionManager {
26	Play(uint64_t contextId)	26	Play(WebKit::PlaybackSessionContextIdentifier contextId)
27	Pause(uint64_t contextId)	27	Pause(WebKit::PlaybackSessionContextIdentifier contextId)
28	TogglePlayState(uint64_t contextId)	28	TogglePlayState(WebKit::PlaybackSessionContextIdentifier contextId)
29	BeginScrubbing(uint64_t contextId)	29	BeginScrubbing(WebKit::PlaybackSessionContextIdentifier contextId)
30	EndScrubbing(uint64_t contextId)	30	EndScrubbing(WebKit::PlaybackSessionContextIdentifier contextId)
31	SeekToTime(uint64_t contextId, double time, double toleranceBefore, double toleranceAfter)	31	SeekToTime(WebKit::PlaybackSessionContextIdentifier contextId, double time, double toleranceBefore, double toleranceAfter)
32	FastSeek(uint64_t contextId, double time)	32	FastSeek(WebKit::PlaybackSessionContextIdentifier contextId, double time)
33	BeginScanningForward(uint64_t contextId)	33	BeginScanningForward(WebKit::PlaybackSessionContextIdentifier contextId)
34	BeginScanningBackward(uint64_t contextId)	34	BeginScanningBackward(WebKit::PlaybackSessionContextIdentifier contextId)
35	EndScanning(uint64_t contextId)	35	EndScanning(WebKit::PlaybackSessionContextIdentifier contextId)
36	SelectAudioMediaOption(uint64_t contextId, uint64_t index)	36	SelectAudioMediaOption(WebKit::PlaybackSessionContextIdentifier contextId, uint64_t index)
37	SelectLegibleMediaOption(uint64_t contextId, uint64_t index)	37	SelectLegibleMediaOption(WebKit::PlaybackSessionContextIdentifier contextId, uint64_t index)
38	HandleControlledElementIDRequest(uint64_t contextId)	38	HandleControlledElementIDRequest(WebKit::PlaybackSessionContextIdentifier contextId)
39	TogglePictureInPicture(uint64_t contextId)	39	TogglePictureInPicture(WebKit::PlaybackSessionContextIdentifier contextId)
40	ToggleMuted(uint64_t contextId)	40	ToggleMuted(WebKit::PlaybackSessionContextIdentifier contextId)
41	SetMuted(uint64_t contextId, bool muted)	41	SetMuted(WebKit::PlaybackSessionContextIdentifier contextId, bool muted)
42	SetVolume(uint64_t contextId, double volume)	42	SetVolume(WebKit::PlaybackSessionContextIdentifier contextId, double volume)
43	SetPlayingOnSecondScreen(uint64_t contextId, bool value)	43	SetPlayingOnSecondScreen(WebKit::PlaybackSessionContextIdentifier contextId, bool value)
44	}	44	}
45	#endif	45	#endif

Lines 82-88 static IntRect inlineVideoFrame(HTMLVideoElement& element) a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec1
- a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm -27 / +27 lines
82		82
83	#pragma mark - VideoFullscreenInterfaceContext	83	#pragma mark - VideoFullscreenInterfaceContext
84		84
85	VideoFullscreenInterfaceContext::VideoFullscreenInterfaceContext(VideoFullscreenManager& manager, uint64_t contextId)	85	VideoFullscreenInterfaceContext::VideoFullscreenInterfaceContext(VideoFullscreenManager& manager, PlaybackSessionContextIdentifier contextId)
86	: m_manager(&manager)	86	: m_manager(&manager)
87	, m_contextId(contextId)	87	, m_contextId(contextId)
88	{	88	{
Lines 147-153 void VideoFullscreenManager::invalidate() a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec2
147	m_page = nullptr;	147	m_page = nullptr;
148	}	148	}
149		149
150	VideoFullscreenManager::ModelInterfaceTuple VideoFullscreenManager::createModelAndInterface(uint64_t contextId)	150	VideoFullscreenManager::ModelInterfaceTuple VideoFullscreenManager::createModelAndInterface(PlaybackSessionContextIdentifier contextId)
151	{	151	{
152	auto model = VideoFullscreenModelVideoElement::create();	152	auto model = VideoFullscreenModelVideoElement::create();
153	auto interface = VideoFullscreenInterfaceContext::create(*this, contextId);	153	auto interface = VideoFullscreenInterfaceContext::create(*this, contextId);
Lines 159-165 VideoFullscreenManager::ModelInterfaceTuple VideoFullscreenManager::createModelA a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec3
159	return std::make_tuple(WTFMove(model), WTFMove(interface));	159	return std::make_tuple(WTFMove(model), WTFMove(interface));
160	}	160	}
161		161
162	VideoFullscreenManager::ModelInterfaceTuple& VideoFullscreenManager::ensureModelAndInterface(uint64_t contextId)	162	VideoFullscreenManager::ModelInterfaceTuple& VideoFullscreenManager::ensureModelAndInterface(PlaybackSessionContextIdentifier contextId)
163	{	163	{
164	auto addResult = m_contextMap.add(contextId, ModelInterfaceTuple());	164	auto addResult = m_contextMap.add(contextId, ModelInterfaceTuple());
165	if (addResult.isNewEntry)	165	if (addResult.isNewEntry)
Lines 167-183 VideoFullscreenManager::ModelInterfaceTuple& VideoFullscreenManager::ensureModel a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec4
167	return addResult.iterator->value;	167	return addResult.iterator->value;
168	}	168	}
169		169
170	WebCore::VideoFullscreenModelVideoElement& VideoFullscreenManager::ensureModel(uint64_t contextId)	170	WebCore::VideoFullscreenModelVideoElement& VideoFullscreenManager::ensureModel(PlaybackSessionContextIdentifier contextId)
171	{	171	{
172	return *std::get<0>(ensureModelAndInterface(contextId));	172	return *std::get<0>(ensureModelAndInterface(contextId));
173	}	173	}
174		174
175	VideoFullscreenInterfaceContext& VideoFullscreenManager::ensureInterface(uint64_t contextId)	175	VideoFullscreenInterfaceContext& VideoFullscreenManager::ensureInterface(PlaybackSessionContextIdentifier contextId)
176	{	176	{
177	return *std::get<1>(ensureModelAndInterface(contextId));	177	return *std::get<1>(ensureModelAndInterface(contextId));
178	}	178	}
179		179
180	void VideoFullscreenManager::removeContext(uint64_t contextId)	180	void VideoFullscreenManager::removeContext(PlaybackSessionContextIdentifier contextId)
181	{	181	{
182	auto [model, interface] = ensureModelAndInterface(contextId);	182	auto [model, interface] = ensureModelAndInterface(contextId);
183		183
Lines 191-204 void VideoFullscreenManager::removeContext(uint64_t contextId) a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec5
191	m_contextMap.remove(contextId);	191	m_contextMap.remove(contextId);
192	}	192	}
193		193
194	void VideoFullscreenManager::addClientForContext(uint64_t contextId)	194	void VideoFullscreenManager::addClientForContext(PlaybackSessionContextIdentifier contextId)
195	{	195	{
196	auto addResult = m_clientCounts.add(contextId, 1);	196	auto addResult = m_clientCounts.add(contextId, 1);
197	if (!addResult.isNewEntry)	197	if (!addResult.isNewEntry)
198	addResult.iterator->value++;	198	addResult.iterator->value++;
199	}	199	}
200		200
201	void VideoFullscreenManager::removeClientForContext(uint64_t contextId)	201	void VideoFullscreenManager::removeClientForContext(PlaybackSessionContextIdentifier contextId)
202	{	202	{
203	ASSERT(m_clientCounts.contains(contextId));	203	ASSERT(m_clientCounts.contains(contextId));
204		204
Lines 242-248 void VideoFullscreenManager::enterVideoFullscreenForVideoElement(HTMLVideoElemen a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec6
242	ASSERT(standby \|\| mode != HTMLMediaElementEnums::VideoFullscreenModeNone);	242	ASSERT(standby \|\| mode != HTMLMediaElementEnums::VideoFullscreenModeNone);
243	LOG(Fullscreen, "VideoFullscreenManager::enterVideoFullscreenForVideoElement(%p)", this);	243	LOG(Fullscreen, "VideoFullscreenManager::enterVideoFullscreenForVideoElement(%p)", this);
244		244
245	uint64_t contextId = m_playbackSessionManager->contextIdForMediaElement(videoElement);	245	auto contextId = m_playbackSessionManager->contextIdForMediaElement(videoElement);
246	auto addResult = m_videoElements.add(&videoElement, contextId);	246	auto addResult = m_videoElements.add(&videoElement, contextId);
247	UNUSED_PARAM(addResult);	247	UNUSED_PARAM(addResult);
248	ASSERT(addResult.iterator->value == contextId);	248	ASSERT(addResult.iterator->value == contextId);
Lines 294-300 void VideoFullscreenManager::exitVideoFullscreenForVideoElement(WebCore::HTMLVid a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec7
294	ASSERT(m_page);	294	ASSERT(m_page);
295	ASSERT(m_videoElements.contains(&videoElement));	295	ASSERT(m_videoElements.contains(&videoElement));
296		296
297	uint64_t contextId = m_videoElements.get(&videoElement);	297	auto contextId = m_videoElements.get(&videoElement);
298	auto& interface = ensureInterface(contextId);	298	auto& interface = ensureInterface(contextId);
299	interface.setTargetIsFullscreen(false);	299	interface.setTargetIsFullscreen(false);
300	if (interface.animationState() != VideoFullscreenInterfaceContext::AnimationType::None)	300	if (interface.animationState() != VideoFullscreenInterfaceContext::AnimationType::None)
Lines 311-317 void VideoFullscreenManager::exitVideoFullscreenToModeWithoutAnimation(WebCore:: a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec8
311	ASSERT(m_page);	311	ASSERT(m_page);
312	ASSERT(m_videoElements.contains(&videoElement));	312	ASSERT(m_videoElements.contains(&videoElement));
313		313
314	uint64_t contextId = m_videoElements.get(&videoElement);	314	auto contextId = m_videoElements.get(&videoElement);
315	auto& interface = ensureInterface(contextId);	315	auto& interface = ensureInterface(contextId);
316		316
317	interface.setTargetIsFullscreen(false);	317	interface.setTargetIsFullscreen(false);
Lines 321-333 void VideoFullscreenManager::exitVideoFullscreenToModeWithoutAnimation(WebCore:: a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec9
321		321
322	#pragma mark Interface to VideoFullscreenInterfaceContext:	322	#pragma mark Interface to VideoFullscreenInterfaceContext:
323		323
324	void VideoFullscreenManager::hasVideoChanged(uint64_t contextId, bool hasVideo)	324	void VideoFullscreenManager::hasVideoChanged(PlaybackSessionContextIdentifier contextId, bool hasVideo)
325	{	325	{
326	if (m_page)	326	if (m_page)
327	m_page->send(Messages::VideoFullscreenManagerProxy::SetHasVideo(contextId, hasVideo));	327	m_page->send(Messages::VideoFullscreenManagerProxy::SetHasVideo(contextId, hasVideo));
328	}	328	}
329		329
330	void VideoFullscreenManager::videoDimensionsChanged(uint64_t contextId, const FloatSize& videoDimensions)	330	void VideoFullscreenManager::videoDimensionsChanged(PlaybackSessionContextIdentifier contextId, const FloatSize& videoDimensions)
331	{	331	{
332	if (m_page)	332	if (m_page)
333	m_page->send(Messages::VideoFullscreenManagerProxy::SetVideoDimensions(contextId, videoDimensions));	333	m_page->send(Messages::VideoFullscreenManagerProxy::SetVideoDimensions(contextId, videoDimensions));
Lines 335-351 void VideoFullscreenManager::videoDimensionsChanged(uint64_t contextId, const Fl a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec10
335		335
336	#pragma mark Messages from VideoFullscreenManagerProxy:	336	#pragma mark Messages from VideoFullscreenManagerProxy:
337		337
338	void VideoFullscreenManager::requestFullscreenMode(uint64_t contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode mode, bool finishedWithMedia)	338	void VideoFullscreenManager::requestFullscreenMode(PlaybackSessionContextIdentifier contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode mode, bool finishedWithMedia)
339	{	339	{
340	ensureModel(contextId).requestFullscreenMode(mode, finishedWithMedia);	340	ensureModel(contextId).requestFullscreenMode(mode, finishedWithMedia);
341	}	341	}
342		342
343	void VideoFullscreenManager::fullscreenModeChanged(uint64_t contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode videoFullscreenMode)	343	void VideoFullscreenManager::fullscreenModeChanged(PlaybackSessionContextIdentifier contextId, WebCore::HTMLMediaElementEnums::VideoFullscreenMode videoFullscreenMode)
344	{	344	{
345	ensureModel(contextId).fullscreenModeChanged(videoFullscreenMode);	345	ensureModel(contextId).fullscreenModeChanged(videoFullscreenMode);
346	}	346	}
347		347
348	void VideoFullscreenManager::requestUpdateInlineRect(uint64_t contextId)	348	void VideoFullscreenManager::requestUpdateInlineRect(PlaybackSessionContextIdentifier contextId)
349	{	349	{
350	if (!m_page)	350	if (!m_page)
351	return;	351	return;
Lines 355-361 void VideoFullscreenManager::requestUpdateInlineRect(uint64_t contextId) a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec11
355	m_page->send(Messages::VideoFullscreenManagerProxy::SetInlineRect(contextId, inlineRect, inlineRect != IntRect(0, 0, 0, 0)));	355	m_page->send(Messages::VideoFullscreenManagerProxy::SetInlineRect(contextId, inlineRect, inlineRect != IntRect(0, 0, 0, 0)));
356	}	356	}
357		357
358	void VideoFullscreenManager::requestVideoContentLayer(uint64_t contextId)	358	void VideoFullscreenManager::requestVideoContentLayer(PlaybackSessionContextIdentifier contextId)
359	{	359	{
360	auto [model, interface] = ensureModelAndInterface(contextId);	360	auto [model, interface] = ensureModelAndInterface(contextId);
361		361
Lines 369-375 void VideoFullscreenManager::requestVideoContentLayer(uint64_t contextId) a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec12
369	});	369	});
370	}	370	}
371		371
372	void VideoFullscreenManager::returnVideoContentLayer(uint64_t contextId)	372	void VideoFullscreenManager::returnVideoContentLayer(PlaybackSessionContextIdentifier contextId)
373	{	373	{
374	RefPtr<VideoFullscreenModelVideoElement> model;	374	RefPtr<VideoFullscreenModelVideoElement> model;
375	RefPtr<VideoFullscreenInterfaceContext> interface;	375	RefPtr<VideoFullscreenInterfaceContext> interface;
Lines 387-393 void VideoFullscreenManager::returnVideoContentLayer(uint64_t contextId) a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec13
387	});	387	});
388	}	388	}
389		389
390	void VideoFullscreenManager::didSetupFullscreen(uint64_t contextId)	390	void VideoFullscreenManager::didSetupFullscreen(PlaybackSessionContextIdentifier contextId)
391	{	391	{
392	LOG(Fullscreen, "VideoFullscreenManager::didSetupFullscreen(%p, %x)", this, contextId);	392	LOG(Fullscreen, "VideoFullscreenManager::didSetupFullscreen(%p, %x)", this, contextId);
393		393
Lines 411-417 void VideoFullscreenManager::didSetupFullscreen(uint64_t contextId) a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec14
411	#endif	411	#endif
412	}	412	}
413		413
414	void VideoFullscreenManager::willExitFullscreen(uint64_t contextId)	414	void VideoFullscreenManager::willExitFullscreen(PlaybackSessionContextIdentifier contextId)
415	{	415	{
416	LOG(Fullscreen, "VideoFullscreenManager::willExitFullscreen(%p, %x)", this, contextId);	416	LOG(Fullscreen, "VideoFullscreenManager::willExitFullscreen(%p, %x)", this, contextId);
417		417
Lines 428-434 void VideoFullscreenManager::willExitFullscreen(uint64_t contextId) a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec15
428	});	428	});
429	}	429	}
430		430
431	void VideoFullscreenManager::didEnterFullscreen(uint64_t contextId)	431	void VideoFullscreenManager::didEnterFullscreen(PlaybackSessionContextIdentifier contextId)
432	{	432	{
433	LOG(Fullscreen, "VideoFullscreenManager::didEnterFullscreen(%p, %x)", this, contextId);	433	LOG(Fullscreen, "VideoFullscreenManager::didEnterFullscreen(%p, %x)", this, contextId);
434		434
Lines 453-459 void VideoFullscreenManager::didEnterFullscreen(uint64_t contextId) a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec16
453	});	453	});
454	}	454	}
455		455
456	void VideoFullscreenManager::didExitFullscreen(uint64_t contextId)	456	void VideoFullscreenManager::didExitFullscreen(PlaybackSessionContextIdentifier contextId)
457	{	457	{
458	LOG(Fullscreen, "VideoFullscreenManager::didExitFullscreen(%p, %x)", this, contextId);	458	LOG(Fullscreen, "VideoFullscreenManager::didExitFullscreen(%p, %x)", this, contextId);
459		459
Lines 484-490 void VideoFullscreenManager::didExitFullscreen(uint64_t contextId) a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec17
484	#endif	484	#endif
485	}	485	}
486		486
487	void VideoFullscreenManager::didCleanupFullscreen(uint64_t contextId)	487	void VideoFullscreenManager::didCleanupFullscreen(PlaybackSessionContextIdentifier contextId)
488	{	488	{
489	LOG(Fullscreen, "VideoFullscreenManager::didCleanupFullscreen(%p, %x)", this, contextId);	489	LOG(Fullscreen, "VideoFullscreenManager::didCleanupFullscreen(%p, %x)", this, contextId);
490		490
Lines 519-530 void VideoFullscreenManager::didCleanupFullscreen(uint64_t contextId) a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec18
519	});	519	});
520	}	520	}
521		521
522	void VideoFullscreenManager::setVideoLayerGravityEnum(uint64_t contextId, unsigned gravity)	522	void VideoFullscreenManager::setVideoLayerGravityEnum(PlaybackSessionContextIdentifier contextId, unsigned gravity)
523	{	523	{
524	ensureModel(contextId).setVideoLayerGravity((MediaPlayerEnums::VideoGravity)gravity);	524	ensureModel(contextId).setVideoLayerGravity((MediaPlayerEnums::VideoGravity)gravity);
525	}	525	}
526		526
527	void VideoFullscreenManager::fullscreenMayReturnToInline(uint64_t contextId, bool isPageVisible)	527	void VideoFullscreenManager::fullscreenMayReturnToInline(PlaybackSessionContextIdentifier contextId, bool isPageVisible)
528	{	528	{
529	if (!m_page)	529	if (!m_page)
530	return;	530	return;
Lines 536-547 void VideoFullscreenManager::fullscreenMayReturnToInline(uint64_t contextId, boo a/Source/WebKit/WebProcess/cocoa/VideoFullscreenManager.mm_sec19
536	m_page->send(Messages::VideoFullscreenManagerProxy::PreparedToReturnToInline(contextId, true, inlineVideoFrame(*model.videoElement())));	536	m_page->send(Messages::VideoFullscreenManagerProxy::PreparedToReturnToInline(contextId, true, inlineVideoFrame(*model.videoElement())));
537	}	537	}
538		538
539	void VideoFullscreenManager::requestRouteSharingPolicyAndContextUID(uint64_t contextId, Messages::VideoFullscreenManager::RequestRouteSharingPolicyAndContextUID::AsyncReply&& reply)	539	void VideoFullscreenManager::requestRouteSharingPolicyAndContextUID(PlaybackSessionContextIdentifier contextId, Messages::VideoFullscreenManager::RequestRouteSharingPolicyAndContextUID::AsyncReply&& reply)
540	{	540	{
541	ensureModel(contextId).requestRouteSharingPolicyAndContextUID(WTFMove(reply));	541	ensureModel(contextId).requestRouteSharingPolicyAndContextUID(WTFMove(reply));
542	}	542	}
543		543
544	void VideoFullscreenManager::setVideoLayerFrameFenced(uint64_t contextId, WebCore::FloatRect bounds, IPC::Attachment fencePort)	544	void VideoFullscreenManager::setVideoLayerFrameFenced(PlaybackSessionContextIdentifier contextId, WebCore::FloatRect bounds, IPC::Attachment fencePort)
545	{	545	{
546	LOG(Fullscreen, "VideoFullscreenManager::setVideoLayerFrameFenced(%p, %x)", this, contextId);	546	LOG(Fullscreen, "VideoFullscreenManager::setVideoLayerFrameFenced(%p, %x)", this, contextId);
547		547