Changeset 267021 in webkit


Ignore:
Timestamp:
Sep 14, 2020 10:23:04 AM (4 years ago)
Author:
youenn@apple.com
Message:

RemoteAudioMediaStreamTrackRenderer should process its IPC messages from a background thread
https://bugs.webkit.org/show_bug.cgi?id=216474

Reviewed by Eric Carlson.

Register RemoteAudioMediaStreamTrackRendererManager as a thread message receiver
for both RemoteAudioMediaStreamTrackRenderer and RemoteAudioMediaStreamTrackRendererManager messages.
All processing is sent to a high priority work queue.
Given AudioMediaStreamTrackRendererUnit is not fully thread safe, we use a single WorkQueue for the whole GPUProcess.
All operations will happen in this thread, while in WebProcess, create/start/stop/release are main thread.

We no longer compile the generated RemoteAudioMediaStreamTrackRendererManager::didReceiveMessage
and instead implement our own version to handle manager and renderer messages.

Covered by WebRTC audio tests run with GPU process enabled.

  • GPUProcess/GPUConnectionToWebProcess.cpp:

(WebKit::GPUConnectionToWebProcess::GPUConnectionToWebProcess):
(WebKit::GPUConnectionToWebProcess::~GPUConnectionToWebProcess):
(WebKit::GPUConnectionToWebProcess::dispatchMessage):

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

(WebKit::GPUProcess::audioMediaStreamTrackRendererQueue):

  • GPUProcess/GPUProcess.h:
  • GPUProcess/webrtc/RemoteAudioMediaStreamTrackRenderer.h:
  • GPUProcess/webrtc/RemoteAudioMediaStreamTrackRendererManager.cpp:

(WebKit::RemoteAudioMediaStreamTrackRendererManager::RemoteAudioMediaStreamTrackRendererManager):
(WebKit::RemoteAudioMediaStreamTrackRendererManager::~RemoteAudioMediaStreamTrackRendererManager):
(WebKit::RemoteAudioMediaStreamTrackRendererManager::close):
(WebKit::RemoteAudioMediaStreamTrackRendererManager::dispatchToThread):
(WebKit::RemoteAudioMediaStreamTrackRendererManager::didReceiveMessage):

  • GPUProcess/webrtc/RemoteAudioMediaStreamTrackRendererManager.h:
  • SourcesCocoa.txt:
Location:
trunk/Source/WebKit
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebKit/ChangeLog

    r267002 r267021  
     12020-09-14  Youenn Fablet  <youenn@apple.com>
     2
     3        RemoteAudioMediaStreamTrackRenderer should process its IPC messages from a background thread
     4        https://bugs.webkit.org/show_bug.cgi?id=216474
     5
     6        Reviewed by Eric Carlson.
     7
     8        Register RemoteAudioMediaStreamTrackRendererManager as a thread message receiver
     9        for both RemoteAudioMediaStreamTrackRenderer and RemoteAudioMediaStreamTrackRendererManager messages.
     10        All processing is sent to a high priority work queue.
     11        Given AudioMediaStreamTrackRendererUnit is not fully thread safe, we use a single WorkQueue for the whole GPUProcess.
     12        All operations will happen in this thread, while in WebProcess, create/start/stop/release are main thread.
     13
     14        We no longer compile the generated RemoteAudioMediaStreamTrackRendererManager::didReceiveMessage
     15        and instead implement our own version to handle manager and renderer messages.
     16
     17        Covered by WebRTC audio tests run with GPU process enabled.
     18
     19        * GPUProcess/GPUConnectionToWebProcess.cpp:
     20        (WebKit::GPUConnectionToWebProcess::GPUConnectionToWebProcess):
     21        (WebKit::GPUConnectionToWebProcess::~GPUConnectionToWebProcess):
     22        (WebKit::GPUConnectionToWebProcess::dispatchMessage):
     23        * GPUProcess/GPUConnectionToWebProcess.h:
     24        * GPUProcess/GPUProcess.cpp:
     25        (WebKit::GPUProcess::audioMediaStreamTrackRendererQueue):
     26        * GPUProcess/GPUProcess.h:
     27        * GPUProcess/webrtc/RemoteAudioMediaStreamTrackRenderer.h:
     28        * GPUProcess/webrtc/RemoteAudioMediaStreamTrackRendererManager.cpp:
     29        (WebKit::RemoteAudioMediaStreamTrackRendererManager::RemoteAudioMediaStreamTrackRendererManager):
     30        (WebKit::RemoteAudioMediaStreamTrackRendererManager::~RemoteAudioMediaStreamTrackRendererManager):
     31        (WebKit::RemoteAudioMediaStreamTrackRendererManager::close):
     32        (WebKit::RemoteAudioMediaStreamTrackRendererManager::dispatchToThread):
     33        (WebKit::RemoteAudioMediaStreamTrackRendererManager::didReceiveMessage):
     34        * GPUProcess/webrtc/RemoteAudioMediaStreamTrackRendererManager.h:
     35        * SourcesCocoa.txt:
     36
    1372020-09-13  Simon Fraser  <simon.fraser@apple.com>
    238
  • trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.cpp

    r266745 r267021  
    3939#include "Logging.h"
    4040#include "RemoteAudioMediaStreamTrackRendererManager.h"
    41 #include "RemoteAudioMediaStreamTrackRendererManagerMessages.h"
    42 #include "RemoteAudioMediaStreamTrackRendererMessages.h"
    4341#include "RemoteMediaPlayerManagerProxy.h"
    4442#include "RemoteMediaPlayerManagerProxyMessages.h"
     
    157155    , m_webProcessIdentifier(webProcessIdentifier)
    158156    , m_sessionID(sessionID)
     157#if PLATFORM(COCOA) && ENABLE(MEDIA_STREAM)
     158    , m_audioTrackRendererManager(RemoteAudioMediaStreamTrackRendererManager::create(*this))
     159#endif
    159160{
    160161    RELEASE_ASSERT(RunLoop::isMain());
     
    167168
    168169    m_connection->invalidate();
     170
     171#if PLATFORM(COCOA) && ENABLE(MEDIA_STREAM)
     172    m_audioTrackRendererManager->close();
     173#endif
    169174}
    170175
     
    240245#endif
    241246
    242 RemoteAudioMediaStreamTrackRendererManager& GPUConnectionToWebProcess::audioTrackRendererManager()
    243 {
    244     if (!m_audioTrackRendererManager)
    245         m_audioTrackRendererManager = makeUnique<RemoteAudioMediaStreamTrackRendererManager>(*this);
    246 
    247     return *m_audioTrackRendererManager;
    248 }
    249 
    250247RemoteSampleBufferDisplayLayerManager& GPUConnectionToWebProcess::sampleBufferDisplayLayerManager()
    251248{
     
    383380    }
    384381#endif // HAVE(AVASSETWRITERDELEGATE)
    385     if (decoder.messageReceiverName() == Messages::RemoteAudioMediaStreamTrackRendererManager::messageReceiverName()) {
    386         audioTrackRendererManager().didReceiveMessageFromWebProcess(connection, decoder);
    387         return true;
    388     }
    389     if (decoder.messageReceiverName() == Messages::RemoteAudioMediaStreamTrackRenderer::messageReceiverName()) {
    390         audioTrackRendererManager().didReceiveRendererMessage(connection, decoder);
    391         return true;
    392     }
    393382    if (decoder.messageReceiverName() == Messages::RemoteSampleBufferDisplayLayerManager::messageReceiverName()) {
    394383        sampleBufferDisplayLayerManager().didReceiveMessageFromWebProcess(connection, decoder);
  • trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.h

    r262933 r267021  
    121121    RemoteMediaRecorderManager& mediaRecorderManager();
    122122#endif
    123     RemoteAudioMediaStreamTrackRendererManager& audioTrackRendererManager();
    124123    RemoteSampleBufferDisplayLayerManager& sampleBufferDisplayLayerManager();
    125124#endif
     
    170169#if PLATFORM(COCOA) && ENABLE(MEDIA_STREAM)
    171170    std::unique_ptr<UserMediaCaptureManagerProxy> m_userMediaCaptureManagerProxy;
     171    Ref<RemoteAudioMediaStreamTrackRendererManager> m_audioTrackRendererManager;
    172172#if HAVE(AVASSETWRITERDELEGATE)
    173173    std::unique_ptr<RemoteMediaRecorderManager> m_remoteMediaRecorderManager;
    174174#endif
    175     std::unique_ptr<RemoteAudioMediaStreamTrackRendererManager> m_audioTrackRendererManager;
    176175    std::unique_ptr<RemoteSampleBufferDisplayLayerManager> m_sampleBufferDisplayLayerManager;
    177176#endif
  • trunk/Source/WebKit/GPUProcess/GPUProcess.cpp

    r260899 r267021  
    258258#endif
    259259
     260#if ENABLE(MEDIA_STREAM) && PLATFORM(COCOA)
     261WorkQueue& GPUProcess::audioMediaStreamTrackRendererQueue()
     262{
     263    if (!m_audioMediaStreamTrackRendererQueue)
     264        m_audioMediaStreamTrackRendererQueue = WorkQueue::create("RemoteAudioMediaStreamTrackRenderer", WorkQueue::Type::Serial, WorkQueue::QOS::UserInteractive);
     265    return *m_audioMediaStreamTrackRendererQueue;
     266}
     267#endif
     268
    260269} // namespace WebKit
    261270
  • trunk/Source/WebKit/GPUProcess/GPUProcess.h

    r262933 r267021  
    7676    WebCore::NowPlayingManager& nowPlayingManager();
    7777
     78#if ENABLE(MEDIA_STREAM) && PLATFORM(COCOA)
     79    WorkQueue& audioMediaStreamTrackRendererQueue();
     80#endif
     81
    7882private:
    7983    void lowMemoryHandler(Critical);
     
    113117    };
    114118    HashMap<WebCore::ProcessIdentifier, MediaCaptureAccess> m_mediaCaptureAccessMap;
     119#if PLATFORM(COCOA)
     120    RefPtr<WorkQueue> m_audioMediaStreamTrackRendererQueue;
     121#endif
    115122#endif
    116123
  • trunk/Source/WebKit/GPUProcess/webrtc/RemoteAudioMediaStreamTrackRenderer.h

    r266745 r267021  
    4545class SharedRingBufferStorage;
    4646
    47 class RemoteAudioMediaStreamTrackRenderer final : private IPC::MessageReceiver {
     47class RemoteAudioMediaStreamTrackRenderer {
    4848    WTF_MAKE_FAST_ALLOCATED;
    4949public:
     
    5151    ~RemoteAudioMediaStreamTrackRenderer();
    5252
    53     void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;
     53    void didReceiveMessage(IPC::Connection&, IPC::Decoder&);
    5454
    5555private:
  • trunk/Source/WebKit/GPUProcess/webrtc/RemoteAudioMediaStreamTrackRendererManager.cpp

    r266745 r267021  
    3030
    3131#include "Decoder.h"
     32#include "GPUProcess.h"
    3233#include "RemoteAudioMediaStreamTrackRenderer.h"
     34#include "RemoteAudioMediaStreamTrackRendererManagerMessages.h"
     35#include "RemoteAudioMediaStreamTrackRendererMessages.h"
    3336
    3437namespace WebKit {
     
    3740RemoteAudioMediaStreamTrackRendererManager::RemoteAudioMediaStreamTrackRendererManager(GPUConnectionToWebProcess& connectionToWebProcess)
    3841    : m_connectionToWebProcess(connectionToWebProcess)
     42    , m_queue(connectionToWebProcess.gpuProcess().audioMediaStreamTrackRendererQueue())
    3943{
     44    m_connectionToWebProcess.connection().addThreadMessageReceiver(Messages::RemoteAudioMediaStreamTrackRenderer::messageReceiverName(), this);
     45    m_connectionToWebProcess.connection().addThreadMessageReceiver(Messages::RemoteAudioMediaStreamTrackRendererManager::messageReceiverName(), this);
    4046}
    4147
    42 RemoteAudioMediaStreamTrackRendererManager::~RemoteAudioMediaStreamTrackRendererManager() = default;
     48RemoteAudioMediaStreamTrackRendererManager::~RemoteAudioMediaStreamTrackRendererManager()
     49{
     50    m_connectionToWebProcess.connection().removeThreadMessageReceiver(Messages::RemoteAudioMediaStreamTrackRenderer::messageReceiverName());
     51    m_connectionToWebProcess.connection().removeThreadMessageReceiver(Messages::RemoteAudioMediaStreamTrackRendererManager::messageReceiverName());
     52}
    4353
    44 void RemoteAudioMediaStreamTrackRendererManager::didReceiveRendererMessage(IPC::Connection& connection, IPC::Decoder& decoder)
     54void RemoteAudioMediaStreamTrackRendererManager::close()
    4555{
     56    dispatchToThread([this, protectedThis = makeRef(*this)] {
     57        m_renderers.clear();
     58    });
     59}
     60
     61void RemoteAudioMediaStreamTrackRendererManager::dispatchToThread(Function<void()>&& callback)
     62{
     63    m_queue->dispatch(WTFMove(callback));
     64}
     65
     66void RemoteAudioMediaStreamTrackRendererManager::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)
     67{
     68    if (!decoder.destinationID()) {
     69        if (decoder.messageName() == Messages::RemoteAudioMediaStreamTrackRendererManager::CreateRenderer::name()) {
     70            IPC::handleMessage<Messages::RemoteAudioMediaStreamTrackRendererManager::CreateRenderer>(decoder, this, &RemoteAudioMediaStreamTrackRendererManager::createRenderer);
     71            return;
     72        }
     73        if (decoder.messageName() == Messages::RemoteAudioMediaStreamTrackRendererManager::ReleaseRenderer::name()) {
     74            IPC::handleMessage<Messages::RemoteAudioMediaStreamTrackRendererManager::ReleaseRenderer>(decoder, this, &RemoteAudioMediaStreamTrackRendererManager::releaseRenderer);
     75            return;
     76        }
     77        return;
     78    }
    4679    if (auto* renderer = m_renderers.get(makeObjectIdentifier<AudioMediaStreamTrackRendererIdentifierType>(decoder.destinationID())))
    4780        renderer->didReceiveMessage(connection, decoder);
  • trunk/Source/WebKit/GPUProcess/webrtc/RemoteAudioMediaStreamTrackRendererManager.h

    r266745 r267021  
    2929
    3030#include "AudioMediaStreamTrackRendererIdentifier.h"
     31#include "Connection.h"
    3132#include "GPUConnectionToWebProcess.h"
    32 #include "MessageReceiver.h"
    3333#include <wtf/Forward.h>
    3434#include <wtf/HashMap.h>
     
    4343class RemoteAudioMediaStreamTrackRenderer;
    4444
    45 class RemoteAudioMediaStreamTrackRendererManager final : private IPC::MessageReceiver {
     45class RemoteAudioMediaStreamTrackRendererManager final : public IPC::Connection::ThreadMessageReceiver {
    4646    WTF_MAKE_FAST_ALLOCATED;
    4747public:
    48     explicit RemoteAudioMediaStreamTrackRendererManager(GPUConnectionToWebProcess&);
     48    static Ref<RemoteAudioMediaStreamTrackRendererManager> create(GPUConnectionToWebProcess& process) { return adoptRef(*new RemoteAudioMediaStreamTrackRendererManager(process)); }
    4949    ~RemoteAudioMediaStreamTrackRendererManager();
    5050
     
    5454    IPC::Connection& connection() const { return m_connectionToWebProcess.connection(); }
    5555
     56    void close();
     57
    5658private:
     59    explicit RemoteAudioMediaStreamTrackRendererManager(GPUConnectionToWebProcess&);
     60
     61    // IPC::Connection::ThreadMessageReceiver
     62    void dispatchToThread(Function<void()>&&) final;
     63
    5764    // IPC::MessageReceiver
    5865    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;
     
    6168
    6269    GPUConnectionToWebProcess& m_connectionToWebProcess;
     70    Ref<WorkQueue> m_queue;
    6371    HashMap<AudioMediaStreamTrackRendererIdentifier, std::unique_ptr<RemoteAudioMediaStreamTrackRenderer>> m_renderers;
    6472};
  • trunk/Source/WebKit/SourcesCocoa.txt

    r266342 r267021  
    665665RemoteAudioSessionMessageReceiver.cpp
    666666RemoteAudioSessionProxyMessageReceiver.cpp
    667 RemoteAudioMediaStreamTrackRendererManagerMessageReceiver.cpp
    668667RemoteAudioMediaStreamTrackRendererMessageReceiver.cpp
    669668RemoteMediaRecorderMessageReceiver.cpp
Note: See TracChangeset for help on using the changeset viewer.