Changeset 255346 in webkit


Ignore:
Timestamp:
Jan 29, 2020 2:14:06 AM (4 years ago)
Author:
youenn@apple.com
Message:

Send WebsiteDataStore media parameters to GPUProcess when needed
​https://bugs.webkit.org/show_bug.cgi?id=206870

Reviewed by Eric Carlson.

Whenever opening a new WebProcess/GPUProcess connection, make sure GPUProcess knows WebProcess session parameters.
Make sure to remove session parameters when data store is destroyed.
Update media code to no longer send the corresponding parameters for each media load.

Covered by existing tests no longer triggering sandbox violations.

  • GPUProcess/GPUConnectionToWebProcess.cpp:

(WebKit::GPUConnectionToWebProcess::mediaCacheDirectory const):
(WebKit::GPUConnectionToWebProcess::mediaKeysStorageDirectory const):

  • GPUProcess/GPUConnectionToWebProcess.h:
  • GPUProcess/GPUProcess.cpp:

(WebKit::GPUProcess::addSession):
(WebKit::GPUProcess::removeSession):
(WebKit::GPUProcess::mediaCacheDirectory const):
(WebKit::GPUProcess::mediaKeysStorageDirectory const):

  • GPUProcess/GPUProcess.h:
  • GPUProcess/GPUProcess.messages.in:
  • GPUProcess/media/RemoteMediaPlayerProxy.cpp:

(WebKit::RemoteMediaPlayerProxy::load):
(WebKit::RemoteMediaPlayerProxy::mediaPlayerMediaKeysStorageDirectory const):
(WebKit::RemoteMediaPlayerProxy::mediaPlayerMediaCacheDirectory const):

  • GPUProcess/media/RemoteMediaPlayerProxy.h:
  • GPUProcess/media/RemoteMediaPlayerProxyConfiguration.h:

(WebKit::RemoteMediaPlayerProxyConfiguration::encode const):
(WebKit::RemoteMediaPlayerProxyConfiguration::decode):

  • UIProcess/GPU/GPUProcessProxy.cpp:

(WebKit::GPUProcessProxy::singleton):
(WebKit::GPUProcessProxy::openGPUProcessConnection):
(WebKit::gpuProcessSessionParameters):
(WebKit::GPUProcessProxy::addSession):
(WebKit::GPUProcessProxy::removeSession):

  • UIProcess/GPU/GPUProcessProxy.h:
  • UIProcess/WebsiteData/WebsiteDataStore.cpp:

(WebKit::WebsiteDataStore::~WebsiteDataStore):

  • WebKit.xcodeproj/project.pbxproj:
  • WebProcess/GPU/media/RemoteMediaPlayerManager.cpp:

(WebKit::RemoteMediaPlayerManager::createRemoteMediaPlayer):

Location:
trunk/Source/WebKit
Files:
1 added
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r255345 r255346  
     12020-01-29  youenn fablet  <youenn@apple.com>
     2
     3        Send WebsiteDataStore media parameters to GPUProcess when needed
     4        https://bugs.webkit.org/show_bug.cgi?id=206870
     5
     6        Reviewed by Eric Carlson.
     7
     8        Whenever opening a new WebProcess/GPUProcess connection, make sure GPUProcess knows WebProcess session parameters.
     9        Make sure to remove session parameters when data store is destroyed.
     10        Update media code to no longer send the corresponding parameters for each media load.
     11
     12        Covered by existing tests no longer triggering sandbox violations.
     13
     14        * GPUProcess/GPUConnectionToWebProcess.cpp:
     15        (WebKit::GPUConnectionToWebProcess::mediaCacheDirectory const):
     16        (WebKit::GPUConnectionToWebProcess::mediaKeysStorageDirectory const):
     17        * GPUProcess/GPUConnectionToWebProcess.h:
     18        * GPUProcess/GPUProcess.cpp:
     19        (WebKit::GPUProcess::addSession):
     20        (WebKit::GPUProcess::removeSession):
     21        (WebKit::GPUProcess::mediaCacheDirectory const):
     22        (WebKit::GPUProcess::mediaKeysStorageDirectory const):
     23        * GPUProcess/GPUProcess.h:
     24        * GPUProcess/GPUProcess.messages.in:
     25        * GPUProcess/media/RemoteMediaPlayerProxy.cpp:
     26        (WebKit::RemoteMediaPlayerProxy::load):
     27        (WebKit::RemoteMediaPlayerProxy::mediaPlayerMediaKeysStorageDirectory const):
     28        (WebKit::RemoteMediaPlayerProxy::mediaPlayerMediaCacheDirectory const):
     29        * GPUProcess/media/RemoteMediaPlayerProxy.h:
     30        * GPUProcess/media/RemoteMediaPlayerProxyConfiguration.h:
     31        (WebKit::RemoteMediaPlayerProxyConfiguration::encode const):
     32        (WebKit::RemoteMediaPlayerProxyConfiguration::decode):
     33        * UIProcess/GPU/GPUProcessProxy.cpp:
     34        (WebKit::GPUProcessProxy::singleton):
     35        (WebKit::GPUProcessProxy::openGPUProcessConnection):
     36        (WebKit::gpuProcessSessionParameters):
     37        (WebKit::GPUProcessProxy::addSession):
     38        (WebKit::GPUProcessProxy::removeSession):
     39        * UIProcess/GPU/GPUProcessProxy.h:
     40        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
     41        (WebKit::WebsiteDataStore::~WebsiteDataStore):
     42        * WebKit.xcodeproj/project.pbxproj:
     43        * WebProcess/GPU/media/RemoteMediaPlayerManager.cpp:
     44        (WebKit::RemoteMediaPlayerManager::createRemoteMediaPlayer):
     45
    1462020-01-29  youenn fablet  <youenn@apple.com>
    247

  • trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.cpp

    r254817 r255346  
    262262}
    263263
     264const String& GPUConnectionToWebProcess::mediaCacheDirectory() const
     265{
     266    return m_gpuProcess->mediaCacheDirectory(m_sessionID);
     267}
     268
     269#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
     270const String& GPUConnectionToWebProcess::mediaKeysStorageDirectory() const
     271{
     272    return m_gpuProcess->mediaKeysStorageDirectory(m_sessionID);
     273}
     274#endif
     275
    264276} // namespace WebKit
    265277

  • trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.h

    r254817 r255346  
    6666    Logger& logger();
    6767
     68    const String& mediaCacheDirectory() const;
     69#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
     70    const String& mediaKeysStorageDirectory() const;
     71#endif
     72
    6873private:
    6974    GPUConnectionToWebProcess(GPUProcess&, WebCore::ProcessIdentifier, IPC::Connection::Identifier, PAL::SessionID);

  • trunk/Source/WebKit/GPUProcess/GPUProcess.cpp

    r254867 r255346  
    3535#include "GPUConnectionToWebProcess.h"
    3636#include "GPUProcessCreationParameters.h"
     37#include "GPUProcessSessionParameters.h"
    3738#include "Logging.h"
    3839#include "SandboxExtension.h"
    … …  
    157158}
    158159
     160void GPUProcess::addSession(PAL::SessionID sessionID, GPUProcessSessionParameters&& parameters)
     161{
     162    ASSERT(!m_sessions.contains(sessionID));
     163    SandboxExtension::consumePermanently(parameters.mediaCacheDirectorySandboxExtensionHandle);
     164#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
     165    SandboxExtension::consumePermanently(parameters.mediaKeysStorageDirectorySandboxExtensionHandle);
     166#endif
     167
     168    m_sessions.add(sessionID, GPUSession {
     169        WTFMove(parameters.mediaCacheDirectory)
     170#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
     171        , WTFMove(parameters.mediaKeysStorageDirectory)
     172#endif
     173    });
     174}
     175
     176void GPUProcess::removeSession(PAL::SessionID sessionID)
     177{
     178    ASSERT(m_sessions.contains(sessionID));
     179    m_sessions.remove(sessionID);
     180}
     181
     182const String& GPUProcess::mediaCacheDirectory(PAL::SessionID sessionID) const
     183{
     184    ASSERT(m_sessions.contains(sessionID));
     185    return m_sessions.find(sessionID)->value.mediaCacheDirectory;
     186}
     187
     188#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
     189const String& GPUProcess::mediaKeysStorageDirectory(PAL::SessionID sessionID) const
     190{
     191    ASSERT(m_sessions.contains(sessionID));
     192    return m_sessions.find(sessionID)->value.mediaKeysStorageDirectory;
     193}
     194#endif
     195
    159196} // namespace WebKit
    160197

  • trunk/Source/WebKit/GPUProcess/GPUProcess.h

    r253900 r255346  
    3939class GPUConnectionToWebProcess;
    4040struct GPUProcessCreationParameters;
     41struct GPUProcessSessionParameters;
    4142
    4243class GPUProcess : public AuxiliaryProcess, public ThreadSafeRefCounted<GPUProcess>, public CanMakeWeakPtr<GPUProcess> {
    … …  
    5758    GPUConnectionToWebProcess* webProcessConnection(WebCore::ProcessIdentifier) const;
    5859
     60    const String& mediaCacheDirectory(PAL::SessionID) const;
     61#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
     62    const String& mediaKeysStorageDirectory(PAL::SessionID) const;
     63#endif
     64
    5965private:
    6066    void lowMemoryHandler(Critical);
    … …  
    7379    void initializeGPUProcess(GPUProcessCreationParameters&&);
    7480    void createGPUConnectionToWebProcess(WebCore::ProcessIdentifier, PAL::SessionID, CompletionHandler<void(Optional<IPC::Attachment>&&)>&&);
     81    void addSession(PAL::SessionID, GPUProcessSessionParameters&&);
     82    void removeSession(PAL::SessionID);
    7583
    7684    void processDidTransitionToForeground();
    … …  
    8088    // Connections to WebProcesses.
    8189    HashMap<WebCore::ProcessIdentifier, Ref<GPUConnectionToWebProcess>> m_webProcessConnections;
     90
     91    struct GPUSession {
     92        String mediaCacheDirectory;
     93#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
     94        String mediaKeysStorageDirectory;
     95#endif
     96    };
     97    HashMap<PAL::SessionID, GPUSession> m_sessions;
    8298};
    8399

  • trunk/Source/WebKit/GPUProcess/GPUProcess.messages.in

    r254392 r255346  
    3333    ProcessDidTransitionToBackground()
    3434
     35    AddSession(PAL::SessionID sessionID, struct WebKit::GPUProcessSessionParameters parameters)
     36    RemoveSession(PAL::SessionID sessionID)
     37
    3538#if ENABLE(MEDIA_STREAM)
    3639    SetMockCaptureDevicesEnabled(bool isEnabled)

  • trunk/Source/WebKit/GPUProcess/media/RemoteMediaPlayerProxy.cpp

    r255235 r255346  
    9090}
    9191
    92 void RemoteMediaPlayerProxy::load(const URL& url, Optional<SandboxExtension::Handle>&& sandboxExtensionHandle, const ContentType& contentType, const String& keySystem, CompletionHandler<void(RemoteMediaPlayerConfiguration&&)>&& completionHandler)
     92void RemoteMediaPlayerProxy::load(URL&& url, Optional<SandboxExtension::Handle>&& sandboxExtensionHandle, const ContentType& contentType, const String& keySystem, CompletionHandler<void(RemoteMediaPlayerConfiguration&&)>&& completionHandler)
    9393{
    9494    RemoteMediaPlayerConfiguration configuration;
    95 
    9695    if (sandboxExtensionHandle) {
    9796        m_sandboxExtension = SandboxExtension::create(WTFMove(sandboxExtensionHandle.value()));
    … …  
    290289String RemoteMediaPlayerProxy::mediaPlayerMediaKeysStorageDirectory() const
    291290{
    292     return m_configuration.mediaKeysStorageDirectory;
     291    return m_manager.gpuConnectionToWebProcess().mediaKeysStorageDirectory();
    293292}
    294293#endif
    … …  
    318317const String& RemoteMediaPlayerProxy::mediaPlayerMediaCacheDirectory() const
    319318{
    320     return m_configuration.mediaCacheDirectory;
     319    return m_manager.gpuConnectionToWebProcess().mediaCacheDirectory();
    321320}
    322321

  • trunk/Source/WebKit/GPUProcess/media/RemoteMediaPlayerProxy.h

    r254964 r255346  
    7878    void prepareForRendering();
    7979
    80     void load(const URL&, Optional<SandboxExtension::Handle>&&, const WebCore::ContentType&, const String&, CompletionHandler<void(RemoteMediaPlayerConfiguration&&)>&&);
     80    void load(URL&&, Optional<SandboxExtension::Handle>&&, const WebCore::ContentType&, const String&, CompletionHandler<void(RemoteMediaPlayerConfiguration&&)>&&);
    8181    void cancelLoad();
    8282

  • trunk/Source/WebKit/GPUProcess/media/RemoteMediaPlayerProxyConfiguration.h

    r253941 r255346  
    3434
    3535struct RemoteMediaPlayerProxyConfiguration {
    36     String mediaKeysStorageDirectory;
    3736    String referrer;
    3837    String userAgent;
    3938    String sourceApplicationIdentifier;
    4039    String networkInterfaceName;
    41     String mediaCacheDirectory;
    4240    Vector<WebCore::ContentType> mediaContentTypesRequiringHardwareSupport;
    4341    Vector<String> preferredAudioCharacteristics;
    … …  
    4947    void encode(Encoder& encoder) const
    5048    {
    51         encoder << mediaKeysStorageDirectory;
    5249        encoder << referrer;
    5350        encoder << userAgent;
    5451        encoder << sourceApplicationIdentifier;
    5552        encoder << networkInterfaceName;
    56         encoder << mediaCacheDirectory;
    5753        encoder << mediaContentTypesRequiringHardwareSupport;
    5854        encoder << preferredAudioCharacteristics;
    … …  
    6561    static Optional<RemoteMediaPlayerProxyConfiguration> decode(Decoder& decoder)
    6662    {
    67         Optional<String> mediaKeysStorageDirectory;
    68         decoder >> mediaKeysStorageDirectory;
    69         if (!mediaKeysStorageDirectory)
    70             return WTF::nullopt;
    71 
    7263        Optional<String> referrer;
    7364        decoder >> referrer;
    … …  
    8879        decoder >> networkInterfaceName;
    8980        if (!networkInterfaceName)
    90             return WTF::nullopt;
    91 
    92         Optional<String> mediaCacheDirectory;
    93         decoder >> mediaCacheDirectory;
    94         if (!mediaCacheDirectory)
    9581            return WTF::nullopt;
    9682
    … …  
    121107
    122108        return {{
    123             WTFMove(*mediaKeysStorageDirectory),
    124109            WTFMove(*referrer),
    125110            WTFMove(*userAgent),
    126111            WTFMove(*sourceApplicationIdentifier),
    127112            WTFMove(*networkInterfaceName),
    128             WTFMove(*mediaCacheDirectory),
    129113            WTFMove(*mediaContentTypesRequiringHardwareSupport),
    130114            WTFMove(*preferredAudioCharacteristics),

  • trunk/Source/WebKit/UIProcess/GPU/GPUProcessProxy.cpp

    r254867 r255346  
    3434#include "GPUProcessMessages.h"
    3535#include "GPUProcessProxyMessages.h"
     36#include "GPUProcessSessionParameters.h"
    3637#include "Logging.h"
    3738#include "WebPageMessages.h"
    … …  
    8384}
    8485
     86GPUProcessProxy* GPUProcessProxy::m_singleton = nullptr;
     87
    8588GPUProcessProxy& GPUProcessProxy::singleton()
    8689{
    … …  
    111114        gpuProcess->send(Messages::GPUProcess::InitializeGPUProcess(parameters), 0);
    112115        gpuProcess->updateProcessAssertion();
     116
     117        m_singleton = &gpuProcess.get();
    113118    });
    114119
    … …  
    167172void GPUProcessProxy::openGPUProcessConnection(ConnectionRequestIdentifier connectionRequestIdentifier, WebProcessProxy& webProcessProxy)
    168173{
     174    addSession(webProcessProxy.websiteDataStore());
     175
    169176    auto& connection = *this->connection();
    170177
    … …  
    269276}
    270277
     278static inline GPUProcessSessionParameters gpuProcessSessionParameters(const WebsiteDataStore& store)
     279{
     280    GPUProcessSessionParameters parameters;
     281
     282    parameters.mediaCacheDirectory = store.resolvedMediaCacheDirectory();
     283    SandboxExtension::Handle mediaCacheDirectoryExtensionHandle;
     284    if (!parameters.mediaCacheDirectory.isEmpty())
     285        SandboxExtension::createHandleWithoutResolvingPath(parameters.mediaCacheDirectory, SandboxExtension::Type::ReadWrite, parameters.mediaCacheDirectorySandboxExtensionHandle);
     286
     287#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
     288    parameters.mediaKeysStorageDirectory = store.resolvedMediaKeysDirectory();
     289    SandboxExtension::Handle mediaKeysStorageDirectorySandboxExtensionHandle;
     290    if (!parameters.mediaKeysStorageDirectory.isEmpty())
     291        SandboxExtension::createHandleWithoutResolvingPath(parameters.mediaKeysStorageDirectory, SandboxExtension::Type::ReadWrite, parameters.mediaKeysStorageDirectorySandboxExtensionHandle);
     292#endif
     293
     294    return parameters;
     295}
     296
     297void GPUProcessProxy::addSession(const WebsiteDataStore& store)
     298{
     299    if (!canSendMessage())
     300        return;
     301
     302    if (m_sessionIDs.contains(store.sessionID()))
     303        return;
     304
     305    send(Messages::GPUProcess::AddSession { store.sessionID(), gpuProcessSessionParameters(store) }, 0);
     306    m_sessionIDs.add(store.sessionID());
     307}
     308
     309void GPUProcessProxy::removeSession(PAL::SessionID sessionID)
     310{
     311    if (!canSendMessage())
     312        return;
     313
     314    if (m_sessionIDs.remove(sessionID))
     315        send(Messages::GPUProcess::RemoveSession { sessionID }, 0);
     316}
     317
    271318} // namespace WebKit
    272319

  • trunk/Source/WebKit/UIProcess/GPU/GPUProcessProxy.h

    r254569 r255346  
    3636#include "WebProcessProxyMessagesReplies.h"
    3737#include <memory>
     38#include <pal/SessionID.h>
    3839
    3940namespace WebKit {
    4041
    4142class WebProcessProxy;
     43class WebsiteDataStore;
    4244struct GPUProcessCreationParameters;
    4345
    … …  
    4850public:
    4951    static GPUProcessProxy& singleton();
     52    static GPUProcessProxy* singletonIfCreated() { return m_singleton; }
    5053
    5154    void getGPUProcessConnection(WebProcessProxy&, Messages::WebProcessProxy::GetGPUProcessConnectionDelayedReply&&);
    … …  
    6164#endif
    6265
     66    void removeSession(PAL::SessionID);
     67
    6368private:
    6469    explicit GPUProcessProxy();
    6570    ~GPUProcessProxy();
     71
     72    void addSession(const WebsiteDataStore&);
    6673
    6774    // AuxiliaryProcessProxy
    … …  
    8895    void didReceiveInvalidMessage(IPC::Connection&, IPC::StringReference messageReceiverName, IPC::StringReference messageName) override;
    8996
     97    static GPUProcessProxy* m_singleton;
     98
    9099    struct ConnectionRequest {
    91100        WeakPtr<WebProcessProxy> webProcess;
    … …  
    100109    bool m_useMockCaptureDevices { false };
    101110#endif
     111    HashSet<PAL::SessionID> m_sessionIDs;
    102112};
    103113

  • trunk/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp

    r254556 r255346  
    136136        }
    137137    }
     138#if ENABLE(GPU_PROCESS)
     139        if (auto* gpuProcessProxy = GPUProcessProxy::singletonIfCreated())
     140            gpuProcessProxy->removeSession(m_sessionID);
     141#endif
    138142}
    139143

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

    r255214 r255346  
    33503350                4143751B20EAEA1E00FAD06C /* cn.microdone.cmb.safari.sb */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = cn.microdone.cmb.safari.sb; sourceTree = "<group>"; };
    33513351                414DD37820BF43EA006959FB /* com.cisco.webex.plugin.gpc64.sb */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = com.cisco.webex.plugin.gpc64.sb; sourceTree = "<group>"; };
     3352                4150A5A023E06C910051264A /* GPUProcessSessionParameters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GPUProcessSessionParameters.h; sourceTree = "<group>"; };
    33523353                41518535222704F5005430C6 /* ServiceWorkerFetchTask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ServiceWorkerFetchTask.h; sourceTree = "<group>"; };
    33533354                41518536222704F6005430C6 /* ServiceWorkerFetchTask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ServiceWorkerFetchTask.cpp; sourceTree = "<group>"; };
    … …  
    65076508                                2D9FB2142375209D0049F936 /* GPUProcessCreationParameters.cpp */,
    65086509                                2D9FB2032375209D0049F936 /* GPUProcessCreationParameters.h */,
     6510                                4150A5A023E06C910051264A /* GPUProcessSessionParameters.h */,
    65096511                        );
    65106512                        path = GPUProcess;

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

    r254817 r255346  
    148148
    149149    RemoteMediaPlayerProxyConfiguration proxyConfiguration;
    150 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
    151     proxyConfiguration.mediaKeysStorageDirectory = player->mediaKeysStorageDirectory();
    152 #endif
    153150    proxyConfiguration.referrer = player->referrer();
    154151    proxyConfiguration.userAgent = player->userAgent();
    … …  
    157154    proxyConfiguration.networkInterfaceName = player->mediaPlayerNetworkInterfaceName();
    158155#endif
    159     proxyConfiguration.mediaCacheDirectory = player->mediaCacheDirectory();
    160156    proxyConfiguration.mediaContentTypesRequiringHardwareSupport = player->mediaContentTypesRequiringHardwareSupport();
    161157    proxyConfiguration.preferredAudioCharacteristics = player->preferredAudioCharacteristics();
Note: See TracChangeset for help on using the changeset viewer.