ChangeLog

2019-12-19  Peng Liu  <peng.liu6@apple.com>

        Add remote media resource loader for the GPU process

        https://bugs.webkit.org/show_bug.cgi?id=205379

        Reviewed by NOBODY (OOPS!).

        Add RemoteMediaResourceLoader, RemoteMediaResource, and RemoteMediaResourceManager in the GPU process for media,

        and RemoteMediaResourceProxy in the Web process.

        Disable unified build of all the cpp files for media in GPU because of a strange issue related to duplicated "Fixed" keyword definition.

        This patch uses XPC messages to transfer media data, which is not efficient.

        Covered by existing tests.

        * DerivedSources-input.xcfilelist:

        * DerivedSources-output.xcfilelist:

        * DerivedSources.make:

        * GPUProcess/GPUConnectionToWebProcess.cpp:

        (WebKit::GPUConnectionToWebProcess::remoteMediaResourceManager):

        (WebKit::GPUConnectionToWebProcess::remoteMediaPlayerManagerProxy):

        (WebKit::GPUConnectionToWebProcess::didReceiveMessage):

        * GPUProcess/GPUConnectionToWebProcess.h:

        * GPUProcess/media/RemoteMediaPlayerManagerProxy.cpp:

        (WebKit::RemoteMediaPlayerManagerProxy::RemoteMediaPlayerManagerProxy):

        (WebKit::RemoteMediaPlayerManagerProxy::createMediaPlayer):

        (WebKit::RemoteMediaPlayerManagerProxy::logChannel const):

        * GPUProcess/media/RemoteMediaPlayerManagerProxy.h:

        * GPUProcess/media/RemoteMediaPlayerProxy.cpp:

        (WebKit::RemoteMediaPlayerProxy::RemoteMediaPlayerProxy):

        (WebKit::RemoteMediaPlayerProxy::mediaPlayerCreateResourceLoader):

        * GPUProcess/media/RemoteMediaPlayerProxy.h:

        (WebKit::RemoteMediaPlayerProxy::WebProcessConnection):

        * GPUProcess/media/RemoteMediaResource.cpp: Added.

        (WebKit::RemoteMediaResource::create):

        (WebKit::RemoteMediaResource::RemoteMediaResource):

        (WebKit::RemoteMediaResource::~RemoteMediaResource):

        (WebKit::RemoteMediaResource::stop):

        (WebKit::RemoteMediaResource::didPassAccessControlCheck const):

        (WebKit::RemoteMediaResource::responseReceived):

        (WebKit::RemoteMediaResource::redirectReceived):

        (WebKit::RemoteMediaResource::shouldCacheResponse):

        (WebKit::RemoteMediaResource::dataSent):

        (WebKit::RemoteMediaResource::dataReceived):

        (WebKit::RemoteMediaResource::accessControlCheckFailed):

        (WebKit::RemoteMediaResource::loadFailed):

        (WebKit::RemoteMediaResource::loadFinished):

        * GPUProcess/media/RemoteMediaResource.h: Added.

        (WebKit::RemoteMediaResource::ready):

        (WebKit::RemoteMediaResource::setReady):

        * GPUProcess/media/RemoteMediaResourceIdentifier.h: Added.

        * GPUProcess/media/RemoteMediaResourceLoader.cpp: Added.

        (WebKit::RemoteMediaResourceLoader::RemoteMediaResourceLoader):

        (WebKit::RemoteMediaResourceLoader::~RemoteMediaResourceLoader):

        (WebKit::RemoteMediaResourceLoader::requestResource):

        * GPUProcess/media/RemoteMediaResourceLoader.h: Added.

        * GPUProcess/media/RemoteMediaResourceManager.cpp: Added.

        (WebKit::RemoteMediaResourceManager::RemoteMediaResourceManager):

        (WebKit::RemoteMediaResourceManager::~RemoteMediaResourceManager):

        (WebKit::RemoteMediaResourceManager::addMediaResource):

        (WebKit::RemoteMediaResourceManager::removeMediaResource):

        (WebKit::RemoteMediaResourceManager::responseReceived):

        (WebKit::RemoteMediaResourceManager::redirectReceived):

        (WebKit::RemoteMediaResourceManager::dataSent):

        (WebKit::RemoteMediaResourceManager::dataReceived):

        (WebKit::RemoteMediaResourceManager::accessControlCheckFailed):

        (WebKit::RemoteMediaResourceManager::loadFailed):

        (WebKit::RemoteMediaResourceManager::loadFinished):

        * GPUProcess/media/RemoteMediaResourceManager.h: Added.

        * GPUProcess/media/RemoteMediaResourceManager.messages.in: Added.

        * Platform/Logging.h:

        * Scripts/webkit/messages.py:

        * Sources.txt:

        * SourcesCocoa.txt:

        * WebKit.xcodeproj/project.pbxproj:

        * WebProcess/GPU/GPUProcessConnection.cpp:

        (WebKit::GPUProcessConnection::didReceiveMessage):

        * WebProcess/GPU/GPUProcessConnection.h:

        * WebProcess/GPU/media/MediaPlayerPrivateRemote.cpp:

        (WebKit::MediaPlayerPrivateRemote::MediaPlayerPrivateRemote):

        (WebKit::MediaPlayerPrivateRemote::requestResource):

        * WebProcess/GPU/media/MediaPlayerPrivateRemote.h:

        * WebProcess/GPU/media/MediaPlayerPrivateRemoteIdentifier.h:

        * WebProcess/GPU/media/RemoteMediaPlayerManager.cpp:

        (WebKit::RemoteMediaPlayerManager::volumeChanged):

        (WebKit::RemoteMediaPlayerManager::muteChanged):

        (WebKit::RemoteMediaPlayerManager::timeChanged):

        (WebKit::RemoteMediaPlayerManager::durationChanged):

        (WebKit::RemoteMediaPlayerManager::rateChanged):

        (WebKit::RemoteMediaPlayerManager::playbackStateChanged):

        (WebKit::RemoteMediaPlayerManager::requestResource):

        * WebProcess/GPU/media/RemoteMediaPlayerManager.h:

        (WebKit::RemoteMediaPlayerManager::didReceiveMessageFromGPUProcess):

        (WebKit::RemoteMediaPlayerManager::didReceiveMessageFromWebProcess): Deleted.

        * WebProcess/GPU/media/RemoteMediaPlayerManager.messages.in:

        * WebProcess/GPU/media/RemoteMediaResourceProxy.cpp: Added.

        (WebKit::RemoteMediaResourceProxy::RemoteMediaResourceProxy):

        (WebKit::RemoteMediaResourceProxy::~RemoteMediaResourceProxy):

        (WebKit::RemoteMediaResourceProxy::responseReceived):

        (WebKit::RemoteMediaResourceProxy::redirectReceived):

        (WebKit::RemoteMediaResourceProxy::shouldCacheResponse):

        (WebKit::RemoteMediaResourceProxy::dataSent):

        (WebKit::RemoteMediaResourceProxy::dataReceived):

        (WebKit::RemoteMediaResourceProxy::accessControlCheckFailed):

        (WebKit::RemoteMediaResourceProxy::loadFailed):

        (WebKit::RemoteMediaResourceProxy::loadFinished):

        * WebProcess/GPU/media/RemoteMediaResourceProxy.h: Added.

2019-12-19  Brent Fulgham  <bfulgham@apple.com>

        Log telemetry for IOUserClient lookups

Source/WebKit/DerivedSources-input.xcfilelist

@@$(PROJECT_DIR)/GPUProcess/GPUConnectionToWebProcess.messages.in

$(PROJECT_DIR)/GPUProcess/GPUProcess.messages.in

$(PROJECT_DIR)/GPUProcess/mac/com.apple.WebKit.GPUProcess.sb.in

$(PROJECT_DIR)/GPUProcess/media/RemoteMediaPlayerManagerProxy.messages.in

20$(PROJECT_DIR)/GPUProcess/media/RemoteMediaResourceManager.messages.in

$(PROJECT_DIR)/NetworkProcess/Cookies/WebCookieManager.messages.in

$(PROJECT_DIR)/NetworkProcess/CustomProtocols/LegacyCustomProtocolManager.messages.in

$(PROJECT_DIR)/NetworkProcess/IndexedDB/WebIDBServer.messages.in

Source/WebKit/DerivedSources-output.xcfilelist

@@$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/RemoteMediaPlayerManagerMessagesRep

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/RemoteMediaPlayerManagerProxyMessageReceiver.cpp

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/RemoteMediaPlayerManagerProxyMessages.h

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/RemoteMediaPlayerManagerProxyMessagesReplies.h

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/RemoteMediaResourceManagerMessageReceiver.cpp

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/RemoteMediaResourceManagerMessages.h

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/RemoteMediaResourceManagerMessagesReplies.h

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/RemoteObjectRegistryMessageReceiver.cpp

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/RemoteObjectRegistryMessages.h

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/RemoteObjectRegistryMessagesReplies.h

Source/WebKit/DerivedSources.make

@@MESSAGE_RECEIVERS = \

    RemoteLayerTreeDrawingAreaProxy \

    RemoteMediaPlayerManager \

    RemoteMediaPlayerManagerProxy \

142 RemoteMediaResourceManager \

    RemoteObjectRegistry \

    RemoteScrollingCoordinator \

    RemoteWebInspectorProxy \

Source/WebKit/GPUProcess/GPUConnectionToWebProcess.cpp

#include "RemoteLayerTreeDrawingAreaProxyMessages.h"

#include "RemoteMediaPlayerManagerProxy.h"

#include "RemoteMediaPlayerManagerProxyMessages.h"

40#include "RemoteMediaResourceManagerMessages.h"

#include "RemoteScrollingCoordinatorTransaction.h"

#include "UserMediaCaptureManagerProxy.h"

#include "UserMediaCaptureManagerProxyMessages.h"

@@void GPUConnectionToWebProcess::didReceiveInvalidMessage(IPC::Connection& connec

    CRASH();

}

RemoteMediaResourceManager& GPUConnectionToWebProcess::remoteMediaResourceManager()

{

    if (!m_remoteMediaResourceManager)

        m_remoteMediaResourceManager = makeUnique<RemoteMediaResourceManager>();

    return *m_remoteMediaResourceManager;

}

RemoteMediaPlayerManagerProxy& GPUConnectionToWebProcess::remoteMediaPlayerManagerProxy()

{

    if (!m_remoteMediaPlayerManagerProxy)

104 m_remoteMediaPlayerManagerProxy = makeUnique<RemoteMediaPlayerManagerProxy>(*this);

113 m_remoteMediaPlayerManagerProxy = makeUnique<RemoteMediaPlayerManagerProxy>(*this, remoteMediaResourceManager());

    return *m_remoteMediaPlayerManagerProxy;

}

@@void GPUConnectionToWebProcess::didReceiveMessage(IPC::Connection& connection, I

    if (decoder.messageReceiverName() == Messages::RemoteMediaPlayerManagerProxy::messageReceiverName()) {

        remoteMediaPlayerManagerProxy().didReceiveMessageFromWebProcess(connection, decoder);

        return;

    } else if (decoder.messageReceiverName() == Messages::RemoteMediaResourceManager::messageReceiverName()) {

        remoteMediaResourceManager().didReceiveMessage(connection, decoder);

        return;

    }

#if ENABLE(MEDIA_STREAM)

    if (decoder.messageReceiverName() == Messages::UserMediaCaptureManagerProxy::messageReceiverName()) {

Source/WebKit/GPUProcess/GPUConnectionToWebProcess.h

@@namespace WebKit {

class GPUProcess;

class RemoteMediaPlayerManagerProxy;

class UserMediaCaptureManagerProxy;

42class RemoteMediaResourceManager;

class GPUConnectionToWebProcess

    : public RefCounted<GPUConnectionToWebProcess>

@@public:

private:

    GPUConnectionToWebProcess(GPUProcess&, WebCore::ProcessIdentifier, IPC::Connection::Identifier);

62 RemoteMediaResourceManager& remoteMediaResourceManager();

    RemoteMediaPlayerManagerProxy& remoteMediaPlayerManagerProxy();

#if PLATFORM(COCOA) && ENABLE(MEDIA_STREAM)

    UserMediaCaptureManagerProxy& userMediaCaptureManagerProxy();

@@private:

    Ref<IPC::Connection> m_connection;

    Ref<GPUProcess> m_gpuProcess;

    const WebCore::ProcessIdentifier m_webProcessIdentifier;

77 std::unique_ptr<RemoteMediaResourceManager> m_remoteMediaResourceManager;

    std::unique_ptr<RemoteMediaPlayerManagerProxy> m_remoteMediaPlayerManagerProxy;

#if PLATFORM(COCOA) && ENABLE(MEDIA_STREAM)

    std::unique_ptr<UserMediaCaptureManagerProxy> m_userMediaCaptureManagerProxy;

Source/WebKit/GPUProcess/media/RemoteMediaPlayerManagerProxy.cpp

#if ENABLE(GPU_PROCESS)

#include "GPUConnectionToWebProcess.h"

32#include "Logging.h"

#include "RemoteMediaPlayerManagerMessages.h"

#include "RemoteMediaPlayerManagerProxyMessages.h"

#include "RemoteMediaPlayerProxy.h"

36#include "RemoteMediaResourceManager.h"

#include "WebCoreArgumentCoders.h"

#include <WebCore/MediaPlayer.h>

#include <WebCore/MediaPlayerPrivate.h>

#define MESSAGE_CHECK_CONTEXTID(identifier) MESSAGE_CHECK_BASE(m_proxies.isValidKey(identifier), &m_gpuConnectionToWebProcess.connection())

namespace WebKit {

45

using namespace WebCore;

#if !RELEASE_LOG_DISABLED

@@static RefPtr<Logger>& nullLogger()

}

#endif

53 RemoteMediaPlayerManagerProxy::RemoteMediaPlayerManagerProxy(GPUConnectionToWebProcess& connection)

56RemoteMediaPlayerManagerProxy::RemoteMediaPlayerManagerProxy(GPUConnectionToWebProcess& connection, RemoteMediaResourceManager& remoteMediaResourceManager)

5457 : m_gpuConnectionToWebProcess(connection)

58 , m_remoteMediaResourceManager(remoteMediaResourceManager)

#if !RELEASE_LOG_DISABLED

    , m_logIdentifier(WTF::LoggerHelper::uniqueLogIdentifier())

#endif

@@void RemoteMediaPlayerManagerProxy::createMediaPlayer(MediaPlayerPrivateRemoteId

    MESSAGE_CHECK_CONTEXTID(id);

    ASSERT(!m_proxies.contains(id));

70 m_proxies.add(id, makeUnique<RemoteMediaPlayerProxy>(*this, id, m_gpuConnectionToWebProcess.connection(), engineIdentifier));

74 m_proxies.add(id, makeUnique<RemoteMediaPlayerProxy>(*this, m_remoteMediaResourceManager, id, m_gpuConnectionToWebProcess.connection(), engineIdentifier));

    completionHandler(true);

}

@@const Logger& RemoteMediaPlayerManagerProxy::logger() const

WTFLogChannel& RemoteMediaPlayerManagerProxy::logChannel() const

{

249 return WebKit2LogW~~ebRTC~~;

253 return WebKit2LogMedia;

}

#endif

253 }

257} // namespace WebKit

#undef MESSAGE_CHECK_CONTEXTID

Source/WebKit/GPUProcess/media/RemoteMediaPlayerManagerProxy.h

#include "Connection.h"

#include "MediaPlayerPrivateRemoteIdentifier.h"

#include "MessageReceiver.h"

33#include "RemoteMediaResourceManager.h"

#include <WebCore/MediaPlayer.h>

#include <wtf/LoggerHelper.h>

namespace WebKit {

class GPUConnectionToWebProcess;

40class RemoteMediaResourceManager;

class RemoteMediaPlayerProxy;

class RemoteMediaPlayerManagerProxy

@@class RemoteMediaPlayerManagerProxy

{

    WTF_MAKE_FAST_ALLOCATED;

public:

49 explicit RemoteMediaPlayerManagerProxy(GPUConnectionToWebProcess&);

51 explicit RemoteMediaPlayerManagerProxy(GPUConnectionToWebProcess&, RemoteMediaResourceManager&);

    ~RemoteMediaPlayerManagerProxy();

    GPUConnectionToWebProcess& gpuConnectionToWebProcess() const { return m_gpuConnectionToWebProcess; }

@@private:

    HashMap<MediaPlayerPrivateRemoteIdentifier, std::unique_ptr<RemoteMediaPlayerProxy>> m_proxies;

    GPUConnectionToWebProcess& m_gpuConnectionToWebProcess;

100 RemoteMediaResourceManager& m_remoteMediaResourceManager;

#if !RELEASE_LOG_DISABLED

    const void* m_logIdentifier;

#endif

};

104 }

107} // namespace WebKit

105108

106109#endif

Source/WebKit/GPUProcess/media/RemoteMediaPlayerProxy.cpp

#if ENABLE(GPU_PROCESS)

31#include "RemoteMediaPlayerManagerMessages.h"

3132#include "RemoteMediaPlayerManagerProxy.h"

33#include "RemoteMediaResourceLoader.h"

#include <WebCore/MediaPlayer.h>

#include <WebCore/MediaPlayerPrivate.h>

#include <WebCore/NotImplemented.h>

@@namespace WebKit {

using namespace WebCore;

40 RemoteMediaPlayerProxy::RemoteMediaPlayerProxy(RemoteMediaPlayerManagerProxy& manager, MediaPlayerPrivateRemoteIdentifier id, Ref<IPC::Connection>&& connection, MediaPlayerEnums::MediaEngineIdentifier engineIdentifier)

42RemoteMediaPlayerProxy::RemoteMediaPlayerProxy(RemoteMediaPlayerManagerProxy& manager, RemoteMediaResourceManager& mediaResourceManager, MediaPlayerPrivateRemoteIdentifier id, Ref<IPC::Connection>&& connection, MediaPlayerEnums::MediaEngineIdentifier engineIdentifier)

    : m_id(id)

    , m_webProcessConnection(WTFMove(connection))

    , m_manager(manager)

46 , m_mediaResourceManager(mediaResourceManager)

    , m_engineIdentifier(engineIdentifier)

#if !RELEASE_LOG_DISABLED

    , m_logger(m_manager.logger())

@@CachedResourceLoader* RemoteMediaPlayerProxy::mediaPlayerCachedResourceLoader()

RefPtr<PlatformMediaResourceLoader> RemoteMediaPlayerProxy::mediaPlayerCreateResourceLoader()

{

316 notImplemented();

317 return nullptr;

319 return adoptRef(*new RemoteMediaResourceLoader(m_id, *this, m_mediaResourceManager));

}

bool RemoteMediaPlayerProxy::doesHaveAttribute(const AtomString&, AtomString*) const

Source/WebKit/GPUProcess/media/RemoteMediaPlayerProxy.h

#if ENABLE(GPU_PROCESS)

30#include "Connection.h"

3031#include "MediaPlayerPrivateRemoteIdentifier.h"

32#include "RemoteMediaResourceManager.h"

33#include "WebCore/Cookie.h"

#include <wtf/LoggerHelper.h>

#include <wtf/RefPtr.h>

#include <wtf/Vector.h>

namespace IPC {

class Connection;

}

namespace WebCore {

class MediaPlayer;

}

namespace WebKit {

class RemoteMediaPlayerManagerProxy;

class RemoteMediaPlayerProxy

48 : public MediaPlayerClient {

43 : public WebCore::MediaPlayerClient {

4944 WTF_MAKE_FAST_ALLOCATED;

5045public:

51 RemoteMediaPlayerProxy(RemoteMediaPlayerManagerProxy&, MediaPlayerPrivateRemoteIdentifier, Ref<IPC::Connection>&&, MediaPlayerEnums::MediaEngineIdentifier);

46 RemoteMediaPlayerProxy(RemoteMediaPlayerManagerProxy&, RemoteMediaResourceManager&, MediaPlayerPrivateRemoteIdentifier, Ref<IPC::Connection>&&, WebCore::MediaPlayerEnums::MediaEngineIdentifier);

    virtual ~RemoteMediaPlayerProxy()

    {

    }

51 IPC::Connection& WebProcessConnection() { return m_webProcessConnection; }

52

    void invalidate();

    void prepareForPlayback(bool privateMode, WebCore::MediaPlayerEnums::Preload, bool preservesPitch, bool prepareForRendering);

60 void load(const URL&, const ContentType&, const String&);

57 void load(const URL&, const WebCore::ContentType&, const String&);

    void cancelLoad();

    void prepareToPlay();

@@private:

    bool mediaPlayerIsFullscreen() const final;

    bool mediaPlayerIsFullscreenPermitted() const final;

    bool mediaPlayerIsVideo() const final;

116 LayoutRect mediaPlayerContentBoxRect() const final;

113 WebCore::LayoutRect mediaPlayerContentBoxRect() const final;

    float mediaPlayerContentsScale() const final;

    void mediaPlayerPause() final;

    void mediaPlayerPlay() final;

    bool mediaPlayerPlatformVolumeConfigurationRequired() const final;

121 CachedResourceLoader* mediaPlayerCachedResourceLoader() final;

122 RefPtr<PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader() final;

118 WebCore::CachedResourceLoader* mediaPlayerCachedResourceLoader() final;

119 RefPtr<WebCore::PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader() final;

    bool doesHaveAttribute(const AtomString&, AtomString* = nullptr) const final;

    bool mediaPlayerShouldUsePersistentCache() const final;

    const String& mediaPlayerMediaCacheDirectory() const final;

    void mediaPlayerDidAddAudioTrack(AudioTrackPrivate&) final;

    void mediaPlayerDidAddTextTrack(InbandTextTrackPrivate&) final;

    void mediaPlayerDidAddVideoTrack(VideoTrackPrivate&) final;

    void mediaPlayerDidRemoveAudioTrack(AudioTrackPrivate&) final;

    void mediaPlayerDidRemoveTextTrack(InbandTextTrackPrivate&) final;

    void mediaPlayerDidRemoveVideoTrack(VideoTrackPrivate&) final;

    void mediaPlayerDidAddAudioTrack(WebCore::AudioTrackPrivate&) final;

    void mediaPlayerDidAddTextTrack(WebCore::InbandTextTrackPrivate&) final;

    void mediaPlayerDidAddVideoTrack(WebCore::VideoTrackPrivate&) final;

    void mediaPlayerDidRemoveAudioTrack(WebCore::AudioTrackPrivate&) final;

    void mediaPlayerDidRemoveTextTrack(WebCore::InbandTextTrackPrivate&) final;

    void mediaPlayerDidRemoveVideoTrack(WebCore::VideoTrackPrivate&) final;

133130

134 void textTrackRepresentationBoundsChanged(const IntRect&) final;

131 void textTrackRepresentationBoundsChanged(const WebCore::IntRect&) final;

135132

136133#if ENABLE(VIDEO_TRACK) && ENABLE(AVF_CAPTIONS)

137 Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources() final;

134 Vector<RefPtr<WebCore::PlatformTextTrack>> outOfBandTrackSources() final;

#endif

#if PLATFORM(IOS_FAMILY)

    String mediaPlayerNetworkInterfaceName() const final;

142 bool mediaPlayerGetRawCookies(const URL&, Vector<Cookie>&) const final;

139 bool mediaPlayerGetRawCookies(const URL&, Vector<WebCore::Cookie>&) const final;

#endif

    String mediaPlayerSourceApplicationIdentifier() const final;

@@private:

    void mediaPlayerEngineFailedToLoad() const final;

    double mediaPlayerRequestedPlaybackRate() const final;

150 MediaPlayerEnums::VideoFullscreenMode mediaPlayerFullscreenMode() const final;

147 WebCore::MediaPlayerEnums::VideoFullscreenMode mediaPlayerFullscreenMode() const final;

    bool mediaPlayerIsVideoFullscreenStandby() const final;

    Vector<String> mediaPlayerPreferredAudioCharacteristics() const final;

@@private:

    MediaPlayerPrivateRemoteIdentifier m_id;

    Ref<IPC::Connection> m_webProcessConnection;

164 RefPtr<MediaPlayer> m_player;

161 RefPtr<WebCore::MediaPlayer> m_player;

165162 RemoteMediaPlayerManagerProxy& m_manager;

166 MediaPlayerEnums::MediaEngineIdentifier m_engineIdentifier;

163 RemoteMediaResourceManager& m_mediaResourceManager;

164 WebCore::MediaPlayerEnums::MediaEngineIdentifier m_engineIdentifier;

    Vector<WebCore::ContentType> m_typesRequiringHardwareSupport;

#if !RELEASE_LOG_DISABLED

@@private:

#endif

};

174 }

172} // namespace WebKit

175173

176174#endif

Source/WebKit/GPUProcess/media/RemoteMediaResource.cpp

/*

 * Copyright (C) 2019 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.

 */

#include "config.h"

#include "RemoteMediaResource.h"

#if ENABLE(GPU_PROCESS)

#include "RemoteMediaResourceManager.h"

#include <WebCore/ResourceResponse.h>

namespace WebKit {

using namespace WebCore;

Ref<RemoteMediaResource> RemoteMediaResource::create(RemoteMediaResourceManager& remoteMediaResourceManager, RemoteMediaResourceIdentifier id)

{

    return adoptRef(*new RemoteMediaResource(remoteMediaResourceManager, id));

}

RemoteMediaResource::RemoteMediaResource(RemoteMediaResourceManager& remoteMediaResourceManager, RemoteMediaResourceIdentifier id)

    : m_remoteMediaResourceManager(remoteMediaResourceManager)

    , m_id(id)

    , m_ready(false)

{

}

RemoteMediaResource::~RemoteMediaResource()

{

    // TODO: do we need to send message to the web process here?

    m_remoteMediaResourceManager.removeMediaResource(m_id);

}

void RemoteMediaResource::stop()

{

    // TODO: notify the web process that the job is done?

}

bool RemoteMediaResource::didPassAccessControlCheck() const

{

    return false;

}

void RemoteMediaResource::responseReceived(const ResourceResponse& response)

{

    if (m_client) {

        m_client->responseReceived(*this, response, [weakThis = makeWeakPtr(*this)](ShouldContinue shouldContinue) mutable {

            if (shouldContinue == ShouldContinue::No && weakThis)

                weakThis->stop();

        });

    }

}

void RemoteMediaResource::redirectReceived(ResourceRequest&& request, const ResourceResponse& response)

{

    if (m_client)

        m_client->redirectReceived(*this, WTFMove(request), response, [](ResourceRequest&&) mutable { });

}

bool RemoteMediaResource::shouldCacheResponse(const ResourceResponse&)

{

    return true;

}

void RemoteMediaResource::dataSent(uint64_t bytesSent, uint64_t totalBytesToBeSent)

{

    if (m_client)

        m_client->dataSent(*this, bytesSent, totalBytesToBeSent);

}

void RemoteMediaResource::dataReceived(const char* data, int64_t length)

{

    if (m_client)

        m_client->dataReceived(*this, data, length);

}

void RemoteMediaResource::accessControlCheckFailed(const ResourceError& error)

{

    if (m_client)

        m_client->accessControlCheckFailed(*this, error);

}

void RemoteMediaResource::loadFailed(const ResourceError& error)

{

    if (m_client)

        m_client->loadFailed(*this, error);

}

void RemoteMediaResource::loadFinished()

{

    if (m_client)

        m_client->loadFinished(*this);

}

} // namespace WebKit

#endif

Source/WebKit/GPUProcess/media/RemoteMediaResource.h

/*

 * Copyright (C) 2019 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

#if ENABLE(GPU_PROCESS)

#include "RemoteMediaResourceIdentifier.h"

#include "WebCore/PlatformMediaResourceLoader.h"

#include <wtf/WeakPtr.h>

namespace WebKit {

class RemoteMediaResourceManager;

class RemoteMediaResource : public CanMakeWeakPtr<RemoteMediaResource>, public WebCore::PlatformMediaResource {

public:

    static Ref<RemoteMediaResource> create(RemoteMediaResourceManager&, RemoteMediaResourceIdentifier);

    explicit RemoteMediaResource(RemoteMediaResourceManager&, RemoteMediaResourceIdentifier);

    ~RemoteMediaResource();

    bool ready() { return m_ready; }

    void setReady(bool ready) { m_ready = ready; }

    // PlatformMediaResource

    void stop() override;

    bool didPassAccessControlCheck() const override;

    void responseReceived(const WebCore::ResourceResponse&);

    void redirectReceived(WebCore::ResourceRequest&&, const WebCore::ResourceResponse&);

    bool shouldCacheResponse(const WebCore::ResourceResponse&);

    void dataSent(uint64_t, uint64_t);

    void dataReceived(const char*, int64_t);

    void accessControlCheckFailed(const WebCore::ResourceError&);

    void loadFailed(const WebCore::ResourceError&);

    void loadFinished();

private:

    RemoteMediaResourceManager& m_remoteMediaResourceManager;

    RemoteMediaResourceIdentifier m_id;

    bool m_ready;

};

} // namespace WebKit

#endif

Source/WebKit/GPUProcess/media/RemoteMediaResourceIdentifier.h

/*

 * Copyright (C) 2019 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

#if ENABLE(GPU_PROCESS)

#include <wtf/ObjectIdentifier.h>

namespace WebKit {

enum RemoteMediaResourceIdentifierType { };

using RemoteMediaResourceIdentifier = ObjectIdentifier<RemoteMediaResourceIdentifierType>;

} // namespace WebKit

#endif

Source/WebKit/GPUProcess/media/RemoteMediaResourceLoader.cpp

/*

 * Copyright (C) 2019 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.

 */

#include "config.h"

#include "RemoteMediaResourceLoader.h"

#if ENABLE(GPU_PROCESS)

#include "RemoteMediaPlayerManagerMessages.h"

#include "WebCoreArgumentCoders.h"

namespace WebKit {

using namespace WebCore;

RemoteMediaResourceLoader::RemoteMediaResourceLoader(MediaPlayerPrivateRemoteIdentifier mediaPlayerPrivateRemoteIdentifier, RemoteMediaPlayerProxy& remoteMediaPlayerProxy, RemoteMediaResourceManager& remoteMediaResourceManager)

    : m_mediaPlayerPrivateRemoteIdentifier(mediaPlayerPrivateRemoteIdentifier)

    , m_remoteMediaPlayerProxy(remoteMediaPlayerProxy)

    , m_remoteMediaResourceManager(remoteMediaResourceManager)

{

}

RemoteMediaResourceLoader::~RemoteMediaResourceLoader()

{

}

RefPtr<PlatformMediaResource> RemoteMediaResourceLoader::requestResource(ResourceRequest&& request, LoadOptions options)

{

    auto remoteMediaResourceIdentifier = RemoteMediaResourceIdentifier::generate();

    RefPtr<RemoteMediaResource> remoteMediaResource = adoptRef(*new RemoteMediaResource(m_remoteMediaResourceManager, remoteMediaResourceIdentifier));

    m_remoteMediaResourceManager.addMediaResource(remoteMediaResourceIdentifier, remoteMediaResource);

    m_remoteMediaPlayerProxy.WebProcessConnection().sendWithAsyncReply(Messages::RemoteMediaPlayerManager::RequestResource(m_mediaPlayerPrivateRemoteIdentifier, remoteMediaResourceIdentifier, request, options), [remoteMediaResource]() {

        if (remoteMediaResource)

            remoteMediaResource->setReady(true);

    });

    return remoteMediaResource;

}

} // namespace WebKit

#endif

Source/WebKit/GPUProcess/media/RemoteMediaResourceLoader.h

/*

 * Copyright (C) 2019 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

#if ENABLE(GPU_PROCESS)

#include "RemoteMediaPlayerProxy.h"

#include "RemoteMediaResourceManager.h"

#include <WebCore/PlatformMediaResourceLoader.h>

#include <WebCore/ResourceRequest.h>

namespace WebKit {

class RemoteMediaResource;

class RemoteMediaResourceLoader

    : public WebCore::PlatformMediaResourceLoader {

public:

    explicit RemoteMediaResourceLoader(MediaPlayerPrivateRemoteIdentifier, RemoteMediaPlayerProxy&, RemoteMediaResourceManager&);

    virtual ~RemoteMediaResourceLoader();

    RefPtr<WebCore::PlatformMediaResource> requestResource(WebCore::ResourceRequest&&, LoadOptions) final;

private:

    MediaPlayerPrivateRemoteIdentifier m_mediaPlayerPrivateRemoteIdentifier;

    RemoteMediaPlayerProxy& m_remoteMediaPlayerProxy;

    RemoteMediaResourceManager& m_remoteMediaResourceManager;

};

} // namespace WebKit

#endif

Source/WebKit/GPUProcess/media/RemoteMediaResourceManager.cpp

/*

 * Copyright (C) 2019 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.

 */

#include "config.h"

#include "RemoteMediaResourceManager.h"

#if ENABLE(GPU_PROCESS)

#include "RemoteMediaPlayerManagerMessages.h"

#include "RemoteMediaResource.h"

#include "RemoteMediaResourceIdentifier.h"

#include "WebCoreArgumentCoders.h"

#include <WebCore/ResourceRequest.h>

namespace WebKit {

using namespace WebCore;

RemoteMediaResourceManager::RemoteMediaResourceManager()

{

}

RemoteMediaResourceManager::~RemoteMediaResourceManager()

{

}

void RemoteMediaResourceManager::addMediaResource(RemoteMediaResourceIdentifier remoteMediaResourceIdentifier, RefPtr<RemoteMediaResource> remoteMediaResource)

{

    m_remoteMediaResources.add(remoteMediaResourceIdentifier, remoteMediaResource);

}

void RemoteMediaResourceManager::removeMediaResource(RemoteMediaResourceIdentifier remoteMediaResourceIdentifier)

{

    m_remoteMediaResources.remove(remoteMediaResourceIdentifier);

}

void RemoteMediaResourceManager::responseReceived(RemoteMediaResourceIdentifier id, const ResourceResponse& response, CompletionHandler<void()>&& completionHandler)

{

    ASSERT(m_remoteMediaResources.contains(id) && m_remoteMediaResources.get(id)->ready());

    m_remoteMediaResources.get(id)->responseReceived(response);

    completionHandler();

}

void RemoteMediaResourceManager::redirectReceived(RemoteMediaResourceIdentifier id, ResourceRequest&& request, const ResourceResponse& response, CompletionHandler<void()>&& completionHandler)

{

    ASSERT(m_remoteMediaResources.contains(id) && m_remoteMediaResources.get(id)->ready());

    m_remoteMediaResources.get(id)->redirectReceived(WTFMove(request), response);

    completionHandler();

}

void RemoteMediaResourceManager::dataSent(RemoteMediaResourceIdentifier id, uint64_t bytesSent, uint64_t totalBytesToBeSent)

{

    ASSERT(m_remoteMediaResources.contains(id) && m_remoteMediaResources.get(id)->ready());

    m_remoteMediaResources.get(id)->dataSent(bytesSent, totalBytesToBeSent);

}

void RemoteMediaResourceManager::dataReceived(RemoteMediaResourceIdentifier id, const String&& data, int32_t length)

{

    ASSERT(m_remoteMediaResources.contains(id) && m_remoteMediaResources.get(id)->ready());

    m_remoteMediaResources.get(id)->dataReceived((const char*)data.characters8(), length);

}

void RemoteMediaResourceManager::accessControlCheckFailed(RemoteMediaResourceIdentifier id, const ResourceError& error)

{

    ASSERT(m_remoteMediaResources.contains(id) && m_remoteMediaResources.get(id)->ready());

    m_remoteMediaResources.get(id)->accessControlCheckFailed(error);

}

void RemoteMediaResourceManager::loadFailed(RemoteMediaResourceIdentifier id, const ResourceError& error)

{

    ASSERT(m_remoteMediaResources.contains(id) && m_remoteMediaResources.get(id)->ready());

    m_remoteMediaResources.get(id)->loadFailed(error);

}

void RemoteMediaResourceManager::loadFinished(RemoteMediaResourceIdentifier id)

{

    ASSERT(m_remoteMediaResources.contains(id) && m_remoteMediaResources.get(id)->ready());

    m_remoteMediaResources.get(id)->loadFinished();

}

} // namespace WebKit

#endif

Source/WebKit/GPUProcess/media/RemoteMediaResourceManager.h

/*

 * Copyright (C) 2019 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

#if ENABLE(GPU_PROCESS)

#include "Connection.h"

#include "MediaPlayerPrivateRemoteIdentifier.h"

#include "MessageReceiver.h"

#include "MessageSender.h"

#include "RemoteMediaResource.h"

#include "RemoteMediaResourceIdentifier.h"

#include <WebCore/MediaPlayer.h>

#include <WebCore/PlatformMediaResourceLoader.h>

#include <WebCore/ResourceRequest.h>

#include <wtf/WeakPtr.h>

namespace WebKit {

class RemoteMediaResource;

class RemoteMediaResourceManager

    : public IPC::MessageReceiver {

    WTF_MAKE_FAST_ALLOCATED;

public:

    explicit RemoteMediaResourceManager();

    virtual ~RemoteMediaResourceManager();

    void addMediaResource(RemoteMediaResourceIdentifier, RefPtr<RemoteMediaResource>);

    void removeMediaResource(RemoteMediaResourceIdentifier);

    // IPC::MessageReceiver

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

private:

    void responseReceived(RemoteMediaResourceIdentifier, const WebCore::ResourceResponse&, CompletionHandler<void()>&&);

    void redirectReceived(RemoteMediaResourceIdentifier, WebCore::ResourceRequest&&, const WebCore::ResourceResponse&, CompletionHandler<void()>&&);

    void dataSent(RemoteMediaResourceIdentifier, uint64_t, uint64_t);

    void dataReceived(RemoteMediaResourceIdentifier, const String&&, int32_t);

    void accessControlCheckFailed(RemoteMediaResourceIdentifier, const WebCore::ResourceError&);

    void loadFailed(RemoteMediaResourceIdentifier, const WebCore::ResourceError&);

    void loadFinished(RemoteMediaResourceIdentifier);

    HashMap<RemoteMediaResourceIdentifier, RefPtr<RemoteMediaResource>> m_remoteMediaResources;

};

} // namespace WebKit

#endif

Source/WebKit/GPUProcess/media/RemoteMediaResourceManager.messages.in

/*

 * Copyright (C) 2019 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.

 */

#if ENABLE(GPU_PROCESS)

messages -> RemoteMediaResourceManager NotRefCounted {

    ResponseReceived(WebKit::RemoteMediaResourceIdentifier id, WebCore::ResourceResponse response) -> () Async

    RedirectReceived(WebKit::RemoteMediaResourceIdentifier id, WebCore::ResourceRequest request, WebCore::ResourceResponse response) -> () Async

    DataSent(WebKit::RemoteMediaResourceIdentifier id, uint64_t bytesSent, uint64_t totalBytesToBeSent)

    DataReceived(WebKit::RemoteMediaResourceIdentifier id, String data, int32_t length)

    AccessControlCheckFailed(WebKit::RemoteMediaResourceIdentifier id, WebCore::ResourceError error)

    LoadFailed(WebKit::RemoteMediaResourceIdentifier id, WebCore::ResourceError error)

    LoadFinished(WebKit::RemoteMediaResourceIdentifier id)

}

#endif

Source/WebKit/Platform/Logging.h

@@extern "C" {

    M(Layout) \

    M(Loading) \

    M(LocalStorageDatabaseTracker) \

65 M(Media) \

    M(MouseHandling) \

    M(Network) \

    M(NetworkCache) \

Source/WebKit/Scripts/webkit/messages.py

@@def types_that_cannot_be_forward_declared():

        'WebKit::ActivityStateChangeID',

        'WebKit::LayerHostingContextID',

        'WebKit::MediaPlayerPrivateRemoteIdentifier',

223 'WebKit::RemoteMediaResourceIdentifier',

        'WebKit::StorageAreaIdentifier',

        'WebKit::StorageAreaImplIdentifier',

        'WebKit::StorageNamespaceIdentifier',

Source/WebKit/Sources.txt

GPUProcess/GPUProcess.cpp

GPUProcess/GPUConnectionToWebProcess.cpp

GPUProcess/GPUProcessCreationParameters.cpp

//GPUProcess/media/RemoteMediaPlayerManagerProxy.cpp

//GPUProcess/media/RemoteMediaPlayerProxy.cpp

//GPUProcess/media/RemoteMediaResource.cpp

//GPUProcess/media/RemoteMediaResourceLoader.cpp

//GPUProcess/media/RemoteMediaResourceManager.cpp

NetworkProcess/AdClickAttributionManager.cpp

NetworkProcess/NetworkActivityTracker.cpp

@@WebProcess/MediaStream/MediaDeviceSandboxExtensions.cpp

WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp

WebProcess/GPU/GPUProcessConnection.cpp

503 WebProcess/GPU/media/MediaPlayerPrivateRemote.cpp

504 WebProcess/GPU/media/RemoteMediaPlayerManager.cpp

//WebProcess/GPU/media/MediaPlayerPrivateRemote.cpp

//WebProcess/GPU/media/RemoteMediaPlayerManager.cpp

//WebProcess/GPU/media/RemoteMediaResourceProxy.cpp

WebProcess/Network/NetworkProcessConnection.cpp

WebProcess/Network/WebLoaderStrategy.cpp

Source/WebKit/SourcesCocoa.txt

@@NetworkProcess/webrtc/NetworkRTCSocket.cpp

GPUProcess/ios/GPUProcessIOS.mm

GPUProcess/mac/GPUProcessMac.mm

62 GPUProcess/media/RemoteMediaPlayerProxy.cpp

63 GPUProcess/media/RemoteMediaPlayerManagerProxy.cpp

GPUProcess/EntryPoint/Cocoa/XPCService/GPUServiceEntryPoint.mm

Platform/cf/ModuleCF.cpp

Source/WebKit/WebKit.xcodeproj/project.pbxproj

		1CA8B946127C882A00576C2B /* WebInspectorProxyMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 1CA8B944127C882A00576C2B /* WebInspectorProxyMessages.h */; };

		1CBBE4A019B66C53006B7D81 /* WebInspectorUIMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1CBBE49E19B66C53006B7D81 /* WebInspectorUIMessageReceiver.cpp */; };

		1CBBE4A119B66C53006B7D81 /* WebInspectorUIMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 1CBBE49F19B66C53006B7D81 /* WebInspectorUIMessages.h */; };

		1D32F89C23A84BA600B1EA6A /* RemoteMediaResourceProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 1D32F89B23A84BA600B1EA6A /* RemoteMediaResourceProxy.h */; };

		1D32F89E23A84C5B00B1EA6A /* RemoteMediaResourceProxy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1D32F89D23A84C5B00B1EA6A /* RemoteMediaResourceProxy.cpp */; };

		1D3AB05023AC01A0005C1FF0 /* RemoteMediaPlayerManagerProxy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0725EFAD239B024500A538A9 /* RemoteMediaPlayerManagerProxy.cpp */; };

		1D3AB05123AC01AA005C1FF0 /* RemoteMediaPlayerProxy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07BAF35723A2CC190044257E /* RemoteMediaPlayerProxy.cpp */; };

		1D3AB05223AC01AE005C1FF0 /* RemoteMediaResource.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1D32F89923A8468000B1EA6A /* RemoteMediaResource.cpp */; };

		1D3AB05323AC01B3005C1FF0 /* RemoteMediaResourceLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1D3AB04E23AB009B005C1FF0 /* RemoteMediaResourceLoader.cpp */; };

		1D3AB05423AC01B7005C1FF0 /* RemoteMediaResourceManager.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1DA4089E23A827780058C950 /* RemoteMediaResourceManager.cpp */; };

		1D3AB05523AC01F3005C1FF0 /* MediaPlayerPrivateRemote.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07923131239B3B0C009598E2 /* MediaPlayerPrivateRemote.cpp */; };

		1D3AB05623AC01F6005C1FF0 /* RemoteMediaPlayerManager.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07923130239B3B0C009598E2 /* RemoteMediaPlayerManager.cpp */; };

		1D4D737023A9E54700717A25 /* RemoteMediaResourceManagerMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1D4D736B23A9DF5500717A25 /* RemoteMediaResourceManagerMessageReceiver.cpp */; };

		1D4D737123A9E56200717A25 /* RemoteMediaResourceManagerMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 1D4D736C23A9DF6000717A25 /* RemoteMediaResourceManagerMessages.h */; };

		1D4D737623A9ED1800717A25 /* RemoteMediaResourceManagerMessagesReplies.h in Headers */ = {isa = PBXBuildFile; fileRef = 1D4D737523A9EB6800717A25 /* RemoteMediaResourceManagerMessagesReplies.h */; };

408420 1D67B339212E1F6100FAA786 /* ShareSheetCallbackID.h in Headers */ = {isa = PBXBuildFile; fileRef = 1D67B338212E1F6100FAA786 /* ShareSheetCallbackID.h */; };

421 1DA4089523A80A3E0058C950 /* RemoteMediaResourceManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 1DA4089423A80A3E0058C950 /* RemoteMediaResourceManager.h */; };

		1DB01943211CF002009FB3E8 /* WKShareSheet.h in Headers */ = {isa = PBXBuildFile; fileRef = 1DE0D095211CC21300439B5F /* WKShareSheet.h */; };

		1DB01944211CF005009FB3E8 /* WKShareSheet.mm in Sources */ = {isa = PBXBuildFile; fileRef = 1DBBB061211CC3CB00502ECC /* WKShareSheet.mm */; };

		1F335BC0185B84F0001A201A /* WKWebProcessPlugInLoadDelegate.h in Headers */ = {isa = PBXBuildFile; fileRef = 1F335BBF185B84D8001A201A /* WKWebProcessPlugInLoadDelegate.h */; settings = {ATTRIBUTES = (Private, ); }; };

		1CA8B944127C882A00576C2B /* WebInspectorProxyMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebInspectorProxyMessages.h; path = DerivedSources/WebKit2/WebInspectorProxyMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };

		1CBBE49E19B66C53006B7D81 /* WebInspectorUIMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WebInspectorUIMessageReceiver.cpp; path = DerivedSources/WebKit2/WebInspectorUIMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };

		1CBBE49F19B66C53006B7D81 /* WebInspectorUIMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebInspectorUIMessages.h; path = DerivedSources/WebKit2/WebInspectorUIMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };

		1D32F89823A8465A00B1EA6A /* RemoteMediaResource.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteMediaResource.h; sourceTree = "<group>"; };

		1D32F89923A8468000B1EA6A /* RemoteMediaResource.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteMediaResource.cpp; sourceTree = "<group>"; };

		1D32F89B23A84BA600B1EA6A /* RemoteMediaResourceProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteMediaResourceProxy.h; sourceTree = "<group>"; };

		1D32F89D23A84C5B00B1EA6A /* RemoteMediaResourceProxy.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteMediaResourceProxy.cpp; sourceTree = "<group>"; };

		1D32F8A623A8601900B1EA6A /* RemoteMediaResourceManager.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = RemoteMediaResourceManager.messages.in; sourceTree = "<group>"; };

		1D3AB04D23AB0072005C1FF0 /* RemoteMediaResourceLoader.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteMediaResourceLoader.h; sourceTree = "<group>"; };

		1D3AB04E23AB009B005C1FF0 /* RemoteMediaResourceLoader.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteMediaResourceLoader.cpp; sourceTree = "<group>"; };

		1D4D736B23A9DF5500717A25 /* RemoteMediaResourceManagerMessageReceiver.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; name = RemoteMediaResourceManagerMessageReceiver.cpp; path = DerivedSources/WebKit2/RemoteMediaResourceManagerMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };

		1D4D736C23A9DF6000717A25 /* RemoteMediaResourceManagerMessages.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; name = RemoteMediaResourceManagerMessages.h; path = DerivedSources/WebKit2/RemoteMediaResourceManagerMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };

		1D4D737523A9EB6800717A25 /* RemoteMediaResourceManagerMessagesReplies.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; name = RemoteMediaResourceManagerMessagesReplies.h; path = DerivedSources/WebKit2/RemoteMediaResourceManagerMessagesReplies.h; sourceTree = BUILT_PRODUCTS_DIR; };

26152638 1D67B338212E1F6100FAA786 /* ShareSheetCallbackID.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ShareSheetCallbackID.h; sourceTree = "<group>"; };

2639 1DA4089423A80A3E0058C950 /* RemoteMediaResourceManager.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteMediaResourceManager.h; sourceTree = "<group>"; };

2640 1DA4089E23A827780058C950 /* RemoteMediaResourceManager.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteMediaResourceManager.cpp; sourceTree = "<group>"; };

26162641 1DBBB061211CC3CB00502ECC /* WKShareSheet.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WKShareSheet.mm; sourceTree = "<group>"; };

26172642 1DE0D095211CC21300439B5F /* WKShareSheet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKShareSheet.h; sourceTree = "<group>"; };

2643 1DE2DFAC23A959F8003E013A /* RemoteMediaResourceIdentifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteMediaResourceIdentifier.h; sourceTree = "<group>"; };

		1F0181691858DC1500F92884 /* WKWebProcessPlugInFrame.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKWebProcessPlugInFrame.h; sourceTree = "<group>"; };

		1F01816A1858DC1500F92884 /* WKWebProcessPlugInFrame.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WKWebProcessPlugInFrame.mm; sourceTree = "<group>"; };

		1F01816B1858DC1500F92884 /* WKWebProcessPlugInFrameInternal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKWebProcessPlugInFrameInternal.h; sourceTree = "<group>"; };

		DF58C6311371AC5800F9A37C /* NativeWebWheelEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeWebWheelEvent.h; sourceTree = "<group>"; };

		DF58C6351371ACA000F9A37C /* NativeWebWheelEventMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = NativeWebWheelEventMac.mm; sourceTree = "<group>"; };

		E105FE5318D7B9DE008F57A8 /* EditingRange.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EditingRange.h; sourceTree = "<group>"; };

4852 E115C715190F8A2500ECC516 /* com.apple.WebKit.Storage.sb */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = ~~fil~~e; name = com.apple.WebKit.Storage.sb; path = DerivedSources/WebKit2/com.apple.WebKit.Storage.sb; sourceTree = BUILT_PRODUCTS_DIR; };

4878 E115C715190F8A2500ECC516 /* com.apple.WebKit.Storage.sb */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = com.apple.WebKit.Storage.sb; path = DerivedSources/WebKit2/com.apple.WebKit.Storage.sb; sourceTree = BUILT_PRODUCTS_DIR; };

		E133FD891423DD7F00FC7BFB /* WebKit.icns */ = {isa = PBXFileReference; lastKnownFileType = image.icns; name = WebKit.icns; path = Resources/WebKit.icns; sourceTree = "<group>"; };

		E14A954716E016A40068DE82 /* NetworkProcessPlatformStrategies.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkProcessPlatformStrategies.cpp; sourceTree = "<group>"; };

		E14A954816E016A40068DE82 /* NetworkProcessPlatformStrategies.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkProcessPlatformStrategies.h; sourceTree = "<group>"; };

				07923130239B3B0C009598E2 /* RemoteMediaPlayerManager.cpp */,

				07923134239B3B0C009598E2 /* RemoteMediaPlayerManager.h */,

				07923133239B3B0C009598E2 /* RemoteMediaPlayerManager.messages.in */,

5127 1D32F89D23A84C5B00B1EA6A /* RemoteMediaResourceProxy.cpp */,

5128 1D32F89B23A84BA600B1EA6A /* RemoteMediaResourceProxy.h */,

			);

			path = media;

			sourceTree = "<group>";

				0725EFAB239AE38400A538A9 /* RemoteMediaPlayerManagerProxy.messages.in */,

				07BAF35723A2CC190044257E /* RemoteMediaPlayerProxy.cpp */,

				07BAF35623A2CC170044257E /* RemoteMediaPlayerProxy.h */,

				1D32F89923A8468000B1EA6A /* RemoteMediaResource.cpp */,

				1D32F89823A8465A00B1EA6A /* RemoteMediaResource.h */,

				1DE2DFAC23A959F8003E013A /* RemoteMediaResourceIdentifier.h */,

				1D3AB04E23AB009B005C1FF0 /* RemoteMediaResourceLoader.cpp */,

				1D3AB04D23AB0072005C1FF0 /* RemoteMediaResourceLoader.h */,

				1DA4089E23A827780058C950 /* RemoteMediaResourceManager.cpp */,

				1DA4089423A80A3E0058C950 /* RemoteMediaResourceManager.h */,

				1D32F8A623A8601900B1EA6A /* RemoteMediaResourceManager.messages.in */,

			);

			path = media;

			sourceTree = "<group>";

				07923145239CBCB7009598E2 /* RemoteMediaPlayerManagerProxyMessageReceiver.cpp */,

				07923146239CBCB7009598E2 /* RemoteMediaPlayerManagerProxyMessages.h */,

				07923142239CBCB5009598E2 /* RemoteMediaPlayerManagerProxyMessagesReplies.h */,

				1D4D736B23A9DF5500717A25 /* RemoteMediaResourceManagerMessageReceiver.cpp */,

				1D4D736C23A9DF6000717A25 /* RemoteMediaResourceManagerMessages.h */,

				1D4D737523A9EB6800717A25 /* RemoteMediaResourceManagerMessagesReplies.h */,

				1AC1338318590C4600F3EC05 /* RemoteObjectRegistryMessageReceiver.cpp */,

				1AC1338418590C4600F3EC05 /* RemoteObjectRegistryMessages.h */,

				0F5947A5187B517600437857 /* RemoteScrollingCoordinatorMessageReceiver.cpp */,

				0792314A239CBCB8009598E2 /* RemoteMediaPlayerManagerMessagesReplies.h in Headers */,

				0792314C239CBCB8009598E2 /* RemoteMediaPlayerManagerProxyMessages.h in Headers */,

				07923148239CBCB8009598E2 /* RemoteMediaPlayerManagerProxyMessagesReplies.h in Headers */,

				1DA4089523A80A3E0058C950 /* RemoteMediaResourceManager.h in Headers */,

				1D4D737123A9E56200717A25 /* RemoteMediaResourceManagerMessages.h in Headers */,

				1D4D737623A9ED1800717A25 /* RemoteMediaResourceManagerMessagesReplies.h in Headers */,

				1D32F89C23A84BA600B1EA6A /* RemoteMediaResourceProxy.h in Headers */,

				E1B78471163F24690007B692 /* RemoteNetworkingContext.h in Headers */,

				1A5704FC1BE1751100874AF1 /* RemoteObjectInvocation.h in Headers */,

				1AC1338018590AE400F3EC05 /* RemoteObjectRegistry.h in Headers */,

				2984F57C164B915F004BC0C6 /* LegacyCustomProtocolManagerProxyMessageReceiver.cpp in Sources */,

				449D90DA21FDC30B00F677C0 /* LocalAuthenticationSoftLink.mm in Sources */,

				2D92A779212B6A6100F493FD /* Logging.cpp in Sources */,

11806 1D3AB05523AC01F3005C1FF0 /* MediaPlayerPrivateRemote.cpp in Sources */,

				2D92A781212B6A7100F493FD /* MessageReceiverMap.cpp in Sources */,

				2D92A782212B6A7100F493FD /* MessageSender.cpp in Sources */,

				2D92A77A212B6A6100F493FD /* Module.cpp in Sources */,

				2D72A1FA212BF46E00517A20 /* RemoteLayerTreeDrawingArea.mm in Sources */,

				0FF24A2D1879E4BC003ABF0C /* RemoteLayerTreeDrawingAreaProxyMessageReceiver.cpp in Sources */,

				2DC18FB4218A6E9E0025A88D /* RemoteLayerTreeViews.mm in Sources */,

11863 1D3AB05623AC01F6005C1FF0 /* RemoteMediaPlayerManager.cpp in Sources */,

1181911864 07923149239CBCB8009598E2 /* RemoteMediaPlayerManagerMessageReceiver.cpp in Sources */,

11865 1D3AB05023AC01A0005C1FF0 /* RemoteMediaPlayerManagerProxy.cpp in Sources */,

1182011866 0792314B239CBCB8009598E2 /* RemoteMediaPlayerManagerProxyMessageReceiver.cpp in Sources */,

				1D3AB05123AC01AA005C1FF0 /* RemoteMediaPlayerProxy.cpp in Sources */,

				1D3AB05223AC01AE005C1FF0 /* RemoteMediaResource.cpp in Sources */,

				1D3AB05323AC01B3005C1FF0 /* RemoteMediaResourceLoader.cpp in Sources */,

				1D3AB05423AC01B7005C1FF0 /* RemoteMediaResourceManager.cpp in Sources */,

				1D4D737023A9E54700717A25 /* RemoteMediaResourceManagerMessageReceiver.cpp in Sources */,

				1D32F89E23A84C5B00B1EA6A /* RemoteMediaResourceProxy.cpp in Sources */,

				1AC1338518590C4600F3EC05 /* RemoteObjectRegistryMessageReceiver.cpp in Sources */,

				0F5947A7187B517600437857 /* RemoteScrollingCoordinatorMessageReceiver.cpp in Sources */,

				A55BA8261BA25CFD007CD33D /* RemoteWebInspectorProxyMessageReceiver.cpp in Sources */,

Source/WebKit/WebProcess/GPU/GPUProcessConnection.cpp

@@void GPUProcessConnection::didReceiveInvalidMessage(IPC::Connection&, IPC::Strin

void GPUProcessConnection::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)

{

    if (decoder.messageReceiverName() == Messages::RemoteMediaPlayerManager::messageReceiverName()) {

68 WebProcess::singleton().supplement<RemoteMediaPlayerManager>()->didReceiveMessageFrom~~Web~~Process(connection, decoder);

68 WebProcess::singleton().supplement<RemoteMediaPlayerManager>()->didReceiveMessageFromGPUProcess(connection, decoder);

        return;

    }

#if ENABLE(MEDIA_STREAM)

Source/WebKit/WebProcess/GPU/GPUProcessConnection.h

@@private:

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

    void didReceiveInvalidMessage(IPC::Connection&, IPC::StringReference messageReceiverName, IPC::StringReference messageName) override;

58 // The connection from a web process to this GPU process.

58 // The connection from the web process to the GPU process.

    Ref<IPC::Connection> m_connection;

};

Source/WebKit/WebProcess/GPU/media/MediaPlayerPrivateRemote.cpp

#include <wtf/text/CString.h>

namespace WebKit {

44 ~~using namespace PAL;~~

44

using namespace WebCore;

MediaPlayerPrivateRemote::MediaPlayerPrivateRemote(MediaPlayer* player, MediaPlayerEnums::MediaEngineIdentifier engineIdentifier, MediaPlayerPrivateRemoteIdentifier playerIdentifier, RemoteMediaPlayerManager& manager)

    : m_player(player)

49 , m_mediaResourceLoader(player->createResourceLoader())

    , m_manager(manager)

    , m_remoteEngineIdentifier(engineIdentifier)

    , m_id(playerIdentifier)

@@void MediaPlayerPrivateRemote::engineFailedToLoad(long platformErrorCode)

    m_player->remoteEngineFailedToLoad();

}

void MediaPlayerPrivateRemote::requestResource(RemoteMediaResourceIdentifier remoteMediaResourceIdentifier, WebCore::ResourceRequest&& request, WebCore::PlatformMediaResourceLoader::LoadOptions options)

{

    auto resource = m_mediaResourceLoader->requestResource(WTFMove(request), options);

    resource->setClient(makeUnique<RemoteMediaResourceProxy>(m_manager.gpuProcessConnection(), remoteMediaResourceIdentifier));

    m_mediaResources.add(remoteMediaResourceIdentifier, WTFMove(resource));

}

#if !RELEASE_LOG_DISABLED

WTFLogChannel& MediaPlayerPrivateRemote::logChannel() const

{

Source/WebKit/WebProcess/GPU/media/MediaPlayerPrivateRemote.h

#if ENABLE(GPU_PROCESS)

#include "RemoteMediaPlayerManager.h"

31#include "RemoteMediaResourceIdentifier.h"

32#include "RemoteMediaResourceProxy.h"

#include <WebCore/MediaPlayerPrivate.h>

#include <wtf/LoggerHelper.h>

#include <wtf/MediaTime.h>

@@namespace WebKit {

class MediaPlayerPrivateRemote final

    : public CanMakeWeakPtr<MediaPlayerPrivateRemote>

40 , public MediaPlayerPrivateInterface

42 , public WebCore::MediaPlayerPrivateInterface

#if !RELEASE_LOG_DISABLED

    , private LoggerHelper

#endif

{

public:

46 static std::unique_ptr<MediaPlayerPrivateRemote> create(MediaPlayer* player, MediaPlayerEnums::MediaEngineIdentifier remoteEngineIdentifier, MediaPlayerPrivateRemoteIdentifier identifier, RemoteMediaPlayerManager& manager)

48 static std::unique_ptr<MediaPlayerPrivateRemote> create(WebCore::MediaPlayer* player, WebCore::MediaPlayerEnums::MediaEngineIdentifier remoteEngineIdentifier, MediaPlayerPrivateRemoteIdentifier identifier, RemoteMediaPlayerManager& manager)

    {

        return makeUnique<MediaPlayerPrivateRemote>(player, remoteEngineIdentifier, identifier, manager);

    }

51 explicit MediaPlayerPrivateRemote(MediaPlayer*, MediaPlayerEnums::MediaEngineIdentifier, MediaPlayerPrivateRemoteIdentifier, RemoteMediaPlayerManager&);

53 explicit MediaPlayerPrivateRemote(WebCore::MediaPlayer*, WebCore::MediaPlayerEnums::MediaEngineIdentifier, MediaPlayerPrivateRemoteIdentifier, RemoteMediaPlayerManager&);

    virtual ~MediaPlayerPrivateRemote();

    void invalidate() { m_invalid = true; }

55 MediaPlayerEnums::MediaEngineIdentifier remoteEngineIdentifier() const { return m_remoteEngineIdentifier; }

57 WebCore::MediaPlayerEnums::MediaEngineIdentifier remoteEngineIdentifier() const { return m_remoteEngineIdentifier; }

    MediaPlayerPrivateRemoteIdentifier playerItentifier() const { return m_id; }

    void networkStateChanged(WebCore::MediaPlayerEnums::NetworkState);

@@public:

    void playbackStateChanged(bool);

    void engineFailedToLoad(long);

70 void requestResource(RemoteMediaResourceIdentifier, WebCore::ResourceRequest&&, WebCore::PlatformMediaResourceLoader::LoadOptions);

71

#if !RELEASE_LOG_DISABLED

    const Logger& logger() const final { return *m_logger; }

    const char* logClassName() const override { return "MediaPlayerPrivateRemote"; }

@@public:

#endif

private:

76 void load(const URL&, const ContentType&, const String&) final;

77 void prepareForPlayback(bool privateMode, MediaPlayer::Preload, bool preservesPitch, bool prepare) final;

80 void load(const URL&, const WebCore::ContentType&, const String&) final;

81 void prepareForPlayback(bool privateMode, WebCore::MediaPlayer::Preload, bool preservesPitch, bool prepare) final;

7882

7983#if ENABLE(MEDIA_SOURCE)

80 void load(const String&, MediaSourcePrivateClient*) final;

84 void load(const String&, WebCore::MediaSourcePrivateClient*) final;

8185#endif

8286#if ENABLE(MEDIA_STREAM)

83 void load(MediaStreamPrivate&) final;

87 void load(WebCore::MediaStreamPrivate&) final;

#endif

    void cancelLoad() final;

@@private:

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

    void setVideoFullscreenLayer(PlatformLayer*, WTF::Function<void()>&& completionHandler) final;

    void updateVideoFullscreenInlineImage() final;

    void setVideoFullscreenFrame(FloatRect) final;

    void setVideoFullscreenGravity(MediaPlayer::VideoGravity) final;

    void setVideoFullscreenMode(MediaPlayer::VideoFullscreenMode) final;

    void setVideoFullscreenFrame(WebCore::FloatRect) final;

    void setVideoFullscreenGravity(WebCore::MediaPlayer::VideoGravity) final;

    void setVideoFullscreenMode(WebCore::MediaPlayer::VideoFullscreenMode) final;

    void videoFullscreenStandbyChanged() final;

#endif

@@private:

    String errorLog() const final;

#endif

117 void setBufferingPolicy(MediaPlayer::BufferingPolicy) final;

121 void setBufferingPolicy(WebCore::MediaPlayer::BufferingPolicy) final;

    bool supportsPictureInPicture() const final;

    bool supportsFullscreen() const final;

@@private:

    bool canSaveMediaData() const final;

125 FloatSize naturalSize() const final;

129 WebCore::FloatSize naturalSize() const final;

    bool hasVideo() const final;

    bool hasAudio() const final;

@@private:

    double maxFastForwardRate() const final;

    double minFastReverseRate() const final;

158 MediaPlayer::NetworkState networkState() const final { return m_networkState; }

159 MediaPlayer::ReadyState readyState() const final { return m_readyState; }

162 WebCore::MediaPlayer::NetworkState networkState() const final { return m_networkState; }

163 WebCore::MediaPlayer::ReadyState readyState() const final { return m_readyState; }

160164

161 std::unique_ptr<PlatformTimeRanges> seekable() const final;

165 std::unique_ptr<WebCore::PlatformTimeRanges> seekable() const final;

    MediaTime maxMediaTimeSeekable() const final;

    MediaTime minMediaTimeSeekable() const final;

165 std::unique_ptr<PlatformTimeRanges> buffered() const final;

169 std::unique_ptr<WebCore::PlatformTimeRanges> buffered() const final;

    double seekableTimeRangesLastModifiedTime() const final;

    double liveUpdateInterval() const final;

    unsigned long long totalBytes() const final;

    bool didLoadingProgress() const final;

172 void setSize(const IntSize&) final;

176 void setSize(const WebCore::IntSize&) final;

173177

174 void paint(GraphicsContext&, const FloatRect&) final;

178 void paint(WebCore::GraphicsContext&, const WebCore::FloatRect&) final;

175179

    void paintCurrentFrameInContext(GraphicsContext&, const FloatRect&) final;

    bool copyVideoTextureToPlatformTexture(GraphicsContext3D*, Platform3DObject, GC3Denum, GC3Dint, GC3Denum, GC3Denum, GC3Denum, bool, bool) final;

    NativeImagePtr nativeImageForCurrentTime() final;

    void paintCurrentFrameInContext(WebCore::GraphicsContext&, const WebCore::FloatRect&) final;

    bool copyVideoTextureToPlatformTexture(WebCore::GraphicsContext3D*, Platform3DObject, GC3Denum, GC3Dint, GC3Denum, GC3Denum, GC3Denum, bool, bool) final;

    WebCore::NativeImagePtr nativeImageForCurrentTime() final;

179183

180 void setPreload(MediaPlayer::Preload) final;

184 void setPreload(WebCore::MediaPlayer::Preload) final;

    bool hasAvailableVideoFrame() const final;

@@private:

#if ENABLE(WIRELESS_PLAYBACK_TARGET)

    String wirelessPlaybackTargetName() const final;

191 MediaPlayer::WirelessPlaybackTargetType wirelessPlaybackTargetType() const final;

195 WebCore::MediaPlayer::WirelessPlaybackTargetType wirelessPlaybackTargetType() const final;

    bool wirelessVideoPlaybackDisabled() const final;

    void setWirelessVideoPlaybackDisabled(bool) final;

    bool canPlayToWirelessPlaybackTarget() const final;

    bool isCurrentPlaybackTargetWireless() const final;

198 void setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&&) final;

202 void setWirelessPlaybackTarget(Ref<WebCore::MediaPlaybackTarget>&&) final;

    void setShouldPlayToPlaybackTarget(bool) final;

#endif

@@private:

    bool hasSingleSecurityOrigin() const final;

    bool didPassCORSAccessCheck() const final;

215 Optional<bool> wouldTaintOrigin(const SecurityOrigin&) const final;

219 Optional<bool> wouldTaintOrigin(const WebCore::SecurityOrigin&) const final;

216220

217 MediaPlayer::MovieLoadType movieLoadType() const final;

221 WebCore::MediaPlayer::MovieLoadType movieLoadType() const final;

    void prepareForRendering() final;

@@private:

    String engineDescription() const final;

#if ENABLE(WEB_AUDIO)

233 AudioSourceProvider* audioSourceProvider() final;

237 WebCore::AudioSourceProvider* audioSourceProvider() final;

#endif

#if ENABLE(LEGACY_ENCRYPTED_MEDIA)

237 std::unique_ptr<LegacyCDMSession> createSession(const String&, LegacyCDMSessionClient*) final;

238 void setCDMSession(LegacyCDMSession*) final;

241 std::unique_ptr<WebCore::LegacyCDMSession> createSession(const String&, WebCore::LegacyCDMSessionClient*) final;

242 void setCDMSession(WebCore::LegacyCDMSession*) final;

    void keyAdded() final;

#endif

#if ENABLE(ENCRYPTED_MEDIA)

    void cdmInstanceAttached(CDMInstance&) final;

    void cdmInstanceDetached(CDMInstance&) final;

    void attemptToDecryptWithInstance(CDMInstance&) final;

    void cdmInstanceAttached(WebCore::CDMInstance&) final;

    void cdmInstanceDetached(WebCore::CDMInstance&) final;

    void attemptToDecryptWithInstance(WebCore::CDMInstance&) final;

    bool waitingForKey() const final;

#endif

#if ENABLE(VIDEO_TRACK)

    bool requiresTextTrackRepresentation() const final;

251 void setTextTrackRepresentation(TextTrackRepresentation*) final;

255 void setTextTrackRepresentation(WebCore::TextTrackRepresentation*) final;

    void syncTextTrackBounds() final;

    void tracksChanged() final;

#endif

@@private:

    bool ended() const final;

271 Optional<VideoPlaybackQualityMetrics> videoPlaybackQualityMetrics() final;

275 Optional<WebCore::VideoPlaybackQualityMetrics> videoPlaybackQualityMetrics() final;

#if ENABLE(AVF_CAPTIONS)

    void notifyTrackModeChanged() final;

@@private:

    bool shouldIgnoreIntrinsicSize() final;

    MediaPlayer* m_player { nullptr };

    RemoteMediaPlayerManager m_manager;

    MediaPlayerEnums::MediaEngineIdentifier m_remoteEngineIdentifier;

    WebCore::MediaPlayer* m_player { nullptr };

    RefPtr<WebCore::PlatformMediaResourceLoader> m_mediaResourceLoader;

    RemoteMediaPlayerManager& m_manager;

    WebCore::MediaPlayerEnums::MediaEngineIdentifier m_remoteEngineIdentifier;

295300 MediaPlayerPrivateRemoteIdentifier m_id;

296301

297 MediaPlayer::NetworkState m_networkState { MediaPlayer::NetworkState::Empty };

298 MediaPlayer::ReadyState m_readyState { MediaPlayer::ReadyState::HaveNothing };

    HashMap<RemoteMediaResourceIdentifier, RefPtr<WebCore::PlatformMediaResource>> m_mediaResources;

    WebCore::MediaPlayer::NetworkState m_networkState { WebCore::MediaPlayer::NetworkState::Empty };

    WebCore::MediaPlayer::ReadyState m_readyState { WebCore::MediaPlayer::ReadyState::HaveNothing };

    double m_volume { 1 };

    bool m_muted { false };

    MediaTime m_duration;

Source/WebKit/WebProcess/GPU/media/MediaPlayerPrivateRemoteIdentifier.h

#pragma once

28#if ENABLE(GPU_PROCESS)

29

#include <wtf/ObjectIdentifier.h>

namespace WebKit {

@@namespace WebKit {

enum MediaPlayerPrivateRemoteIdentifierType { };

using MediaPlayerPrivateRemoteIdentifier = ObjectIdentifier<MediaPlayerPrivateRemoteIdentifierType>;

35 } // namespace WebCore

} // namespace WebKit

#endif

Source/WebKit/WebProcess/GPU/media/RemoteMediaPlayerManager.cpp

#if ENABLE(GPU_PROCESS)

31#include "GPUProcessConnection.h"

32#include "MediaPlayerPrivateRemote.h"

#include "RemoteMediaPlayerManagerMessages.h"

#include "RemoteMediaPlayerManagerProxyMessages.h"

#include "WebCoreArgumentCoders.h"

#include <wtf/Assertions.h>

namespace WebKit {

44

using namespace PAL;

using namespace WebCore;

@@void RemoteMediaPlayerManager::readyStateChanged(MediaPlayerPrivateRemoteIdentif

        player->readyStateChanged(state);

}

204 void RemoteMediaPlayerManager::volumeChanged(~~WebKit::~~MediaPlayerPrivateRemoteIdentifier id, double volume)

207void RemoteMediaPlayerManager::volumeChanged(MediaPlayerPrivateRemoteIdentifier id, double volume)

{

    if (auto player = m_players.get(id))

        player->volumeChanged(volume);

}

210 void RemoteMediaPlayerManager::muteChanged(~~WebKit::~~MediaPlayerPrivateRemoteIdentifier id, bool mute)

213void RemoteMediaPlayerManager::muteChanged(MediaPlayerPrivateRemoteIdentifier id, bool mute)

{

    if (auto player = m_players.get(id))

        player->muteChanged(mute);

}

216 void RemoteMediaPlayerManager::timeChanged(~~WebKit::~~MediaPlayerPrivateRemoteIdentifier id, MediaTime&& time)

219void RemoteMediaPlayerManager::timeChanged(MediaPlayerPrivateRemoteIdentifier id, MediaTime&& time)

{

    if (auto player = m_players.get(id))

        player->timeChanged(WTFMove(time));

}

222 void RemoteMediaPlayerManager::durationChanged(~~WebKit::~~MediaPlayerPrivateRemoteIdentifier id, MediaTime&& time)

225void RemoteMediaPlayerManager::durationChanged(MediaPlayerPrivateRemoteIdentifier id, MediaTime&& time)

{

    if (auto player = m_players.get(id))

        player->durationChanged(WTFMove(time));

}

228 void RemoteMediaPlayerManager::rateChanged(~~WebKit::~~MediaPlayerPrivateRemoteIdentifier id, double rate)

231void RemoteMediaPlayerManager::rateChanged(MediaPlayerPrivateRemoteIdentifier id, double rate)

{

    if (auto player = m_players.get(id))

        player->rateChanged(rate);

}

234 void RemoteMediaPlayerManager::playbackStateChanged(~~WebKit::~~MediaPlayerPrivateRemoteIdentifier id, bool paused)

237void RemoteMediaPlayerManager::playbackStateChanged(MediaPlayerPrivateRemoteIdentifier id, bool paused)

{

    if (auto player = m_players.get(id))

        player->playbackStateChanged(paused);

@@void RemoteMediaPlayerManager::engineFailedToLoad(WebKit::MediaPlayerPrivateRemo

        player->engineFailedToLoad(platformErrorCode);

}

void RemoteMediaPlayerManager::requestResource(MediaPlayerPrivateRemoteIdentifier id, RemoteMediaResourceIdentifier remoteMediaResourceIdentifier, WebCore::ResourceRequest&& request, WebCore::PlatformMediaResourceLoader::LoadOptions options, CompletionHandler<void()>&& completionHandler)

{

    if (auto player = m_players.get(id))

        player->requestResource(remoteMediaResourceIdentifier, WTFMove(request), options);

    completionHandler();

}

void RemoteMediaPlayerManager::updatePreferences(const Settings& settings)

{

    auto registerEngine = [this](MediaEngineRegistrar registrar, MediaPlayerEnums::MediaEngineIdentifier remoteEngineIdentifier) {

Source/WebKit/WebProcess/GPU/media/RemoteMediaPlayerManager.h

#include "MediaPlayerPrivateRemoteIdentifier.h"

#include "MessageReceiver.h"

32#include "RemoteMediaResourceIdentifier.h"

#include "SharedMemory.h"

#include "WebProcessSupplement.h"

#include <WebCore/MediaPlayer.h>

@@public:

    IPC::Connection& gpuProcessConnection() const;

59 void didReceiveMessageFrom~~Web~~Process(IPC::Connection& connection, IPC::Decoder& decoder) { didReceiveMessage(connection, decoder); }

60 void didReceiveMessageFromGPUProcess(IPC::Connection& connection, IPC::Decoder& decoder) { didReceiveMessage(connection, decoder); }

    void deleteRemoteMediaPlayer(MediaPlayerPrivateRemoteIdentifier);

@@private:

    void rateChanged(WebKit::MediaPlayerPrivateRemoteIdentifier, double);

    void playbackStateChanged(WebKit::MediaPlayerPrivateRemoteIdentifier, bool);

    void engineFailedToLoad(WebKit::MediaPlayerPrivateRemoteIdentifier, long);

83 void requestResource(MediaPlayerPrivateRemoteIdentifier, RemoteMediaResourceIdentifier, WebCore::ResourceRequest&&, WebCore::PlatformMediaResourceLoader::LoadOptions, CompletionHandler<void()>&&);

    friend class MediaPlayerRemoteFactory;

    void getSupportedTypes(WebCore::MediaPlayerEnums::MediaEngineIdentifier, HashSet<String, ASCIICaseInsensitiveHash>&);

Source/WebKit/WebProcess/GPU/media/RemoteMediaPlayerManager.messages.in

# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

# THE POSSIBILITY OF SUCH DAMAGE.

24 #if ENABLE(~~VID~~EO)

24#if ENABLE(GPU_PROCESS)

2525

2626messages -> RemoteMediaPlayerManager NotRefCounted {

27

    NetworkStateChanged(WebKit::MediaPlayerPrivateRemoteIdentifier id, enum:uint8_t WebCore::MediaPlayerEnums::NetworkState state)

    ReadyStateChanged(WebKit::MediaPlayerPrivateRemoteIdentifier id, enum:uint8_t WebCore::MediaPlayerEnums::ReadyState state)

    VolumeChanged(WebKit::MediaPlayerPrivateRemoteIdentifier id, double volume)

@@messages -> RemoteMediaPlayerManager NotRefCounted {

    RateChanged(WebKit::MediaPlayerPrivateRemoteIdentifier id, double rate)

    PlaybackStateChanged(WebKit::MediaPlayerPrivateRemoteIdentifier id, bool paused)

    EngineFailedToLoad(WebKit::MediaPlayerPrivateRemoteIdentifier id, int platformErrorCode)

36

37 RequestResource(WebKit::MediaPlayerPrivateRemoteIdentifier mediaPlayerPrivateRemoteIdentifier, WebKit::RemoteMediaResourceIdentifier remoteMediaResourceIdentifier, WebCore::ResourceRequest request, enum:uint8_t WebCore::PlatformMediaResourceLoader::LoadOptions options) -> () Async

}

#endif

Source/WebKit/WebProcess/GPU/media/RemoteMediaResourceProxy.cpp

/*

 * Copyright (C) 2019 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.

 */

#include "config.h"

#include "RemoteMediaResourceProxy.h"

#if ENABLE(GPU_PROCESS)

#include "RemoteMediaResourceManagerMessages.h"

#include "WebCoreArgumentCoders.h"

#include <WebCore/PolicyChecker.h>

#include <wtf/CompletionHandler.h>

namespace WebKit {

RemoteMediaResourceProxy::RemoteMediaResourceProxy(Ref<IPC::Connection>&& connection, RemoteMediaResourceIdentifier id)

    : m_gpuProcessConnection(WTFMove(connection))

    , m_id(id)

{

}

RemoteMediaResourceProxy::~RemoteMediaResourceProxy()

{

}

void RemoteMediaResourceProxy::responseReceived(WebCore::PlatformMediaResource&, const WebCore::ResourceResponse& response, CompletionHandler<void(WebCore::ShouldContinue)>&& completionHandler)

{

    m_gpuProcessConnection->sendWithAsyncReply(Messages::RemoteMediaResourceManager::ResponseReceived(m_id, response), [completionHandler = WTFMove(completionHandler)]() mutable {

        completionHandler(WebCore::ShouldContinue::Yes);

    });

}

void RemoteMediaResourceProxy::redirectReceived(WebCore::PlatformMediaResource&, WebCore::ResourceRequest&& request, const WebCore::ResourceResponse& response, CompletionHandler<void(WebCore::ResourceRequest&&)>&& completionHandler)

{

    m_gpuProcessConnection->sendWithAsyncReply(Messages::RemoteMediaResourceManager::RedirectReceived(m_id, request, response), [completionHandler = WTFMove(completionHandler), request = WTFMove(request)]() mutable {

        completionHandler(WTFMove(request));

    });

}

bool RemoteMediaResourceProxy::shouldCacheResponse(WebCore::PlatformMediaResource&, const WebCore::ResourceResponse&)

{

    return true;

}

void RemoteMediaResourceProxy::dataSent(WebCore::PlatformMediaResource&, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)

{

    m_gpuProcessConnection->send(Messages::RemoteMediaResourceManager::DataSent(m_id, bytesSent, totalBytesToBeSent), 0);

}

void RemoteMediaResourceProxy::dataReceived(WebCore::PlatformMediaResource&, const char* data, int length)

{

    m_gpuProcessConnection->send(Messages::RemoteMediaResourceManager::DataReceived(m_id, data, length), 0);

}

void RemoteMediaResourceProxy::accessControlCheckFailed(WebCore::PlatformMediaResource&, const WebCore::ResourceError& error)

{

    m_gpuProcessConnection->send(Messages::RemoteMediaResourceManager::AccessControlCheckFailed(m_id, error), 0);

}

void RemoteMediaResourceProxy::loadFailed(WebCore::PlatformMediaResource&, const WebCore::ResourceError& error)

{

    m_gpuProcessConnection->send(Messages::RemoteMediaResourceManager::LoadFailed(m_id, error), 0);

}

void RemoteMediaResourceProxy::loadFinished(WebCore::PlatformMediaResource&)

{

    m_gpuProcessConnection->send(Messages::RemoteMediaResourceManager::LoadFinished(m_id), 0);

}

}

#endif

Source/WebKit/WebProcess/GPU/media/RemoteMediaResourceProxy.h

/*

 * Copyright (C) 2019 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

#if ENABLE(GPU_PROCESS)

#include "Connection.h"

#include "RemoteMediaResourceIdentifier.h"

#include <WebCore/PlatformMediaResourceLoader.h>

#include <WebCore/ResourceResponse.h>

namespace WebKit {

class RemoteMediaResourceProxy : public WebCore::PlatformMediaResourceClient {

    WTF_MAKE_FAST_ALLOCATED;

public:

    RemoteMediaResourceProxy(Ref<IPC::Connection>&&, RemoteMediaResourceIdentifier);

    ~RemoteMediaResourceProxy();

    // PlatformMediaResourceClient

    void responseReceived(WebCore::PlatformMediaResource&, const WebCore::ResourceResponse&, CompletionHandler<void(WebCore::ShouldContinue)>&&);

    void redirectReceived(WebCore::PlatformMediaResource&, WebCore::ResourceRequest&&, const WebCore::ResourceResponse&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&);

    bool shouldCacheResponse(WebCore::PlatformMediaResource&, const WebCore::ResourceResponse&);

    void dataSent(WebCore::PlatformMediaResource&, unsigned long long, unsigned long long);

    void dataReceived(WebCore::PlatformMediaResource&, const char*, int);

    void accessControlCheckFailed(WebCore::PlatformMediaResource&, const WebCore::ResourceError&);

    void loadFailed(WebCore::PlatformMediaResource&, const WebCore::ResourceError&);

    void loadFinished(WebCore::PlatformMediaResource&);

private:

    Ref<IPC::Connection> m_gpuProcessConnection;

    RemoteMediaResourceIdentifier m_id;

};

} // namespace WebKit

#endif