Rename RTCEncoderIdentifier to VideoEncoderIdentifier

https://bugs.webkit.org/show_bug.cgi?id=245666
rdar://problem/100402861

Reviewed by Eric Carlson.

We also rename RTCDecoderIdentifier in VideoDecoderIdentifier.

* Source/WebKit/GPUProcess/webrtc/LibWebRTCCodecsProxy.h:
* Source/WebKit/GPUProcess/webrtc/LibWebRTCCodecsProxy.messages.in:
* Source/WebKit/GPUProcess/webrtc/LibWebRTCCodecsProxy.mm:
(WebKit::LibWebRTCCodecsProxy::createDecoderCallback):
(WebKit::LibWebRTCCodecsProxy::createH264Decoder):
(WebKit::LibWebRTCCodecsProxy::createH265Decoder):
(WebKit::LibWebRTCCodecsProxy::createVP9Decoder):
(WebKit::LibWebRTCCodecsProxy::releaseDecoder):
(WebKit::LibWebRTCCodecsProxy::createEncoder):
(WebKit::LibWebRTCCodecsProxy::releaseEncoder):
(WebKit::LibWebRTCCodecsProxy::initializeEncoder):
(WebKit::LibWebRTCCodecsProxy::findEncoder):
(WebKit::LibWebRTCCodecsProxy::encodeFrame):
(WebKit::LibWebRTCCodecsProxy::setEncodeRates):
(WebKit::LibWebRTCCodecsProxy::setSharedVideoFrameSemaphore):
(WebKit::LibWebRTCCodecsProxy::setSharedVideoFrameMemory):
* Source/WebKit/Scripts/webkit/messages.py:
(serialized_identifiers):
* Source/WebKit/Scripts/webkit/tests/MessageArgumentDescriptions.cpp:
(IPC::serializedIdentifiers):
* Source/WebKit/WebKit.xcodeproj/project.pbxproj:
* Source/WebKit/WebProcess/GPU/webrtc/LibWebRTCCodecs.cpp:
(WebKit::LibWebRTCCodecs::createDecoder):
(WebKit::LibWebRTCCodecs::failedDecoding):
(WebKit::LibWebRTCCodecs::completedDecoding):
(WebKit::LibWebRTCCodecs::completedDecodingCV):
(WebKit::LibWebRTCCodecs::createEncoder):
(WebKit::LibWebRTCCodecs::completedEncoding):
* Source/WebKit/WebProcess/GPU/webrtc/LibWebRTCCodecs.h:
* Source/WebKit/WebProcess/GPU/webrtc/LibWebRTCCodecs.messages.in:
* Source/WebKit/WebProcess/GPU/webrtc/VideoDecoderIdentifier.h: Renamed from Source/WebKit/WebProcess/GPU/webrtc/RTCDecoderIdentifier.h.
* Source/WebKit/WebProcess/GPU/webrtc/VideoEncoderIdentifier.h: Renamed from Source/WebKit/WebProcess/GPU/webrtc/RTCEncoderIdentifier.h.

Canonical link: https://commits.webkit.org/254903@main

Source/WebKit/GPUProcess/webrtc/LibWebRTCCodecsProxy.h

@@ -29,11 +29,11 @@
 
 #include "Connection.h"
 #include "DataReference.h"
-#include "RTCDecoderIdentifier.h"
-#include "RTCEncoderIdentifier.h"
 #include "RemoteVideoFrameIdentifier.h"
 #include "SharedMemory.h"
 #include "SharedVideoFrame.h"
+#include "VideoDecoderIdentifier.h"
+#include "VideoEncoderIdentifier.h"
 #include "WorkQueueMessageReceiver.h"
 #include <WebCore/ProcessIdentity.h>
 #include <atomic>
@@ -72,40 +72,40 @@ class LibWebRTCCodecsProxy final : public IPC::WorkQueueMessageReceiver {
 private:
     explicit LibWebRTCCodecsProxy(GPUConnectionToWebProcess&);
     void initialize();
-    auto createDecoderCallback(RTCDecoderIdentifier, bool useRemoteFrames);
+    auto createDecoderCallback(VideoDecoderIdentifier, bool useRemoteFrames);
     WorkQueue& workQueue() const { return m_queue; }
 
     // IPC::WorkQueueMessageReceiver overrides.
     void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;
 
-    void createH264Decoder(RTCDecoderIdentifier, bool useRemoteFrames);
-    void createH265Decoder(RTCDecoderIdentifier, bool useRemoteFrames);
-    void createVP9Decoder(RTCDecoderIdentifier, bool useRemoteFrames);
-    void releaseDecoder(RTCDecoderIdentifier);
-    void decodeFrame(RTCDecoderIdentifier, uint32_t timeStamp, const IPC::DataReference&);
-    void setFrameSize(RTCDecoderIdentifier, uint16_t width, uint16_t height);
-
-    void createEncoder(RTCEncoderIdentifier, const String&, const Vector<std::pair<String, String>>&, bool useLowLatency);
-    void releaseEncoder(RTCEncoderIdentifier);
-    void initializeEncoder(RTCEncoderIdentifier, uint16_t width, uint16_t height, unsigned startBitrate, unsigned maxBitrate, unsigned minBitrate, uint32_t maxFramerate);
-    void encodeFrame(RTCEncoderIdentifier, SharedVideoFrame&&, uint32_t timeStamp, bool shouldEncodeAsKeyFrame);
-    void setEncodeRates(RTCEncoderIdentifier, uint32_t bitRate, uint32_t frameRate);
-    void setSharedVideoFrameSemaphore(RTCEncoderIdentifier, IPC::Semaphore&&);
-    void setSharedVideoFrameMemory(RTCEncoderIdentifier, const SharedMemory::Handle&);
+    void createH264Decoder(VideoDecoderIdentifier, bool useRemoteFrames);
+    void createH265Decoder(VideoDecoderIdentifier, bool useRemoteFrames);
+    void createVP9Decoder(VideoDecoderIdentifier, bool useRemoteFrames);
+    void releaseDecoder(VideoDecoderIdentifier);
+    void decodeFrame(VideoDecoderIdentifier, uint32_t timeStamp, const IPC::DataReference&);
+    void setFrameSize(VideoDecoderIdentifier, uint16_t width, uint16_t height);
+
+    void createEncoder(VideoEncoderIdentifier, const String&, const Vector<std::pair<String, String>>&, bool useLowLatency);
+    void releaseEncoder(VideoEncoderIdentifier);
+    void initializeEncoder(VideoEncoderIdentifier, uint16_t width, uint16_t height, unsigned startBitrate, unsigned maxBitrate, unsigned minBitrate, uint32_t maxFramerate);
+    void encodeFrame(VideoEncoderIdentifier, SharedVideoFrame&&, uint32_t timeStamp, bool shouldEncodeAsKeyFrame);
+    void setEncodeRates(VideoEncoderIdentifier, uint32_t bitRate, uint32_t frameRate);
+    void setSharedVideoFrameSemaphore(VideoEncoderIdentifier, IPC::Semaphore&&);
+    void setSharedVideoFrameMemory(VideoEncoderIdentifier, const SharedMemory::Handle&);
     void setRTCLoggingLevel(WTFLogLevel);
 
     struct Encoder {
         webrtc::LocalEncoder webrtcEncoder { nullptr };
         std::unique_ptr<SharedVideoFrameReader> frameReader;
     };
-    Encoder* findEncoder(RTCEncoderIdentifier) WTF_REQUIRES_CAPABILITY(workQueue());
+    Encoder* findEncoder(VideoEncoderIdentifier) WTF_REQUIRES_CAPABILITY(workQueue());
 
     Ref<IPC::Connection> m_connection;
     Ref<WorkQueue> m_queue;
     Ref<RemoteVideoFrameObjectHeap> m_videoFrameObjectHeap;
     WebCore::ProcessIdentity m_resourceOwner;
-    HashMap<RTCDecoderIdentifier, webrtc::LocalDecoder> m_decoders WTF_GUARDED_BY_CAPABILITY(workQueue());
-    HashMap<RTCEncoderIdentifier, Encoder> m_encoders WTF_GUARDED_BY_CAPABILITY(workQueue());
+    HashMap<VideoDecoderIdentifier, webrtc::LocalDecoder> m_decoders WTF_GUARDED_BY_CAPABILITY(workQueue());
+    HashMap<VideoEncoderIdentifier, Encoder> m_encoders WTF_GUARDED_BY_CAPABILITY(workQueue());
     std::atomic<bool> m_hasEncodersOrDecoders { false };
 
     std::unique_ptr<WebCore::PixelBufferConformerCV> m_pixelBufferConformer;

Source/WebKit/GPUProcess/webrtc/LibWebRTCCodecsProxy.messages.in

@@ -24,20 +24,20 @@
 #if USE(LIBWEBRTC) && PLATFORM(COCOA) && ENABLE(GPU_PROCESS)
 
 messages -> LibWebRTCCodecsProxy NotRefCounted {
-    CreateH264Decoder(WebKit::RTCDecoderIdentifier id, bool useRemoteFrames)
-    CreateH265Decoder(WebKit::RTCDecoderIdentifier id, bool useRemoteFrames)
-    CreateVP9Decoder(WebKit::RTCDecoderIdentifier id, bool useRemoteFrames)
-    ReleaseDecoder(WebKit::RTCDecoderIdentifier id)
-    DecodeFrame(WebKit::RTCDecoderIdentifier id, uint32_t timeStamp, IPC::DataReference data)
-    SetFrameSize(WebKit::RTCDecoderIdentifier id, uint16_t width, uint16_t height)
+    CreateH264Decoder(WebKit::VideoDecoderIdentifier id, bool useRemoteFrames)
+    CreateH265Decoder(WebKit::VideoDecoderIdentifier id, bool useRemoteFrames)
+    CreateVP9Decoder(WebKit::VideoDecoderIdentifier id, bool useRemoteFrames)
+    ReleaseDecoder(WebKit::VideoDecoderIdentifier id)
+    DecodeFrame(WebKit::VideoDecoderIdentifier id, uint32_t timeStamp, IPC::DataReference data)
+    SetFrameSize(WebKit::VideoDecoderIdentifier id, uint16_t width, uint16_t height)
 
-    CreateEncoder(WebKit::RTCEncoderIdentifier id, String formatName, Vector<std::pair<String, String>> parameters, bool useLowLatency);
-    ReleaseEncoder(WebKit::RTCEncoderIdentifier id)
-    InitializeEncoder(WebKit::RTCEncoderIdentifier id, uint16_t width, uint16_t height, unsigned startBitrate, unsigned maxBitrate, unsigned minBitrate, uint32_t maxFramerate)
-    EncodeFrame(WebKit::RTCEncoderIdentifier id, struct WebKit::SharedVideoFrame buffer, uint32_t timeStamp, bool shouldEncodeAsKeyFrame)
-    SetEncodeRates(WebKit::RTCEncoderIdentifier id, uint32_t bitRate, uint32_t frameRate)
-    SetSharedVideoFrameSemaphore(WebKit::RTCEncoderIdentifier id, IPC::Semaphore semaphore)
-    SetSharedVideoFrameMemory(WebKit::RTCEncoderIdentifier id, WebKit::SharedMemory::Handle storageHandle)
+    CreateEncoder(WebKit::VideoEncoderIdentifier id, String formatName, Vector<std::pair<String, String>> parameters, bool useLowLatency);
+    ReleaseEncoder(WebKit::VideoEncoderIdentifier id)
+    InitializeEncoder(WebKit::VideoEncoderIdentifier id, uint16_t width, uint16_t height, unsigned startBitrate, unsigned maxBitrate, unsigned minBitrate, uint32_t maxFramerate)
+    EncodeFrame(WebKit::VideoEncoderIdentifier id, struct WebKit::SharedVideoFrame buffer, uint32_t timeStamp, bool shouldEncodeAsKeyFrame)
+    SetEncodeRates(WebKit::VideoEncoderIdentifier id, uint32_t bitRate, uint32_t frameRate)
+    SetSharedVideoFrameSemaphore(WebKit::VideoEncoderIdentifier id, IPC::Semaphore semaphore)
+    SetSharedVideoFrameMemory(WebKit::VideoEncoderIdentifier id, WebKit::SharedMemory::Handle storageHandle)
     SetRTCLoggingLevel(WTFLogLevel level)
 }
 

Source/WebKit/GPUProcess/webrtc/LibWebRTCCodecsProxy.mm

@@ -94,7 +94,7 @@
     m_connection->addWorkQueueMessageReceiver(Messages::LibWebRTCCodecsProxy::messageReceiverName(), m_queue, *this);
 }
 
-auto LibWebRTCCodecsProxy::createDecoderCallback(RTCDecoderIdentifier identifier, bool useRemoteFrames)
+auto LibWebRTCCodecsProxy::createDecoderCallback(VideoDecoderIdentifier identifier, bool useRemoteFrames)
 {
     RefPtr<RemoteVideoFrameObjectHeap> videoFrameObjectHeap;
     if (useRemoteFrames)
@@ -112,31 +112,31 @@
     };
 }
 
-void LibWebRTCCodecsProxy::createH264Decoder(RTCDecoderIdentifier identifier, bool useRemoteFrames)
+void LibWebRTCCodecsProxy::createH264Decoder(VideoDecoderIdentifier identifier, bool useRemoteFrames)
 {
     assertIsCurrent(workQueue());
     auto result = m_decoders.add(identifier, webrtc::createLocalH264Decoder(makeBlockPtr(createDecoderCallback(identifier, useRemoteFrames)).get()));
     ASSERT_UNUSED(result, result.isNewEntry || IPC::isTestingIPC());
     m_hasEncodersOrDecoders = true;
 }
 
-void LibWebRTCCodecsProxy::createH265Decoder(RTCDecoderIdentifier identifier, bool useRemoteFrames)
+void LibWebRTCCodecsProxy::createH265Decoder(VideoDecoderIdentifier identifier, bool useRemoteFrames)
 {
     assertIsCurrent(workQueue());
     auto result = m_decoders.add(identifier, webrtc::createLocalH265Decoder(makeBlockPtr(createDecoderCallback(identifier, useRemoteFrames)).get()));
     ASSERT_UNUSED(result, result.isNewEntry || IPC::isTestingIPC());
     m_hasEncodersOrDecoders = true;
 }
 
-void LibWebRTCCodecsProxy::createVP9Decoder(RTCDecoderIdentifier identifier, bool useRemoteFrames)
+void LibWebRTCCodecsProxy::createVP9Decoder(VideoDecoderIdentifier identifier, bool useRemoteFrames)
 {
     assertIsCurrent(workQueue());
     auto result = m_decoders.add(identifier, webrtc::createLocalVP9Decoder(makeBlockPtr(createDecoderCallback(identifier, useRemoteFrames)).get()));
     ASSERT_UNUSED(result, result.isNewEntry || IPC::isTestingIPC());
     m_hasEncodersOrDecoders = true;
 }
 
-void LibWebRTCCodecsProxy::releaseDecoder(RTCDecoderIdentifier identifier)
+void LibWebRTCCodecsProxy::releaseDecoder(VideoDecoderIdentifier identifier)
 {
     assertIsCurrent(workQueue());
     auto decoder = m_decoders.take(identifier);
@@ -148,7 +148,7 @@
     m_hasEncodersOrDecoders = !m_encoders.isEmpty() || !m_decoders.isEmpty();
 }
 
-void LibWebRTCCodecsProxy::decodeFrame(RTCDecoderIdentifier identifier, uint32_t timeStamp, const IPC::DataReference& data) WTF_IGNORES_THREAD_SAFETY_ANALYSIS
+void LibWebRTCCodecsProxy::decodeFrame(VideoDecoderIdentifier identifier, uint32_t timeStamp, const IPC::DataReference& data) WTF_IGNORES_THREAD_SAFETY_ANALYSIS
 {
     assertIsCurrent(workQueue());
     auto decoder = m_decoders.get(identifier);
@@ -160,7 +160,7 @@
         m_connection->send(Messages::LibWebRTCCodecs::FailedDecoding { identifier }, 0);
 }
 
-void LibWebRTCCodecsProxy::setFrameSize(RTCDecoderIdentifier identifier, uint16_t width, uint16_t height) WTF_IGNORES_THREAD_SAFETY_ANALYSIS
+void LibWebRTCCodecsProxy::setFrameSize(VideoDecoderIdentifier identifier, uint16_t width, uint16_t height) WTF_IGNORES_THREAD_SAFETY_ANALYSIS
 {
     assertIsCurrent(workQueue());
     auto decoder = m_decoders.get(identifier);
@@ -171,7 +171,7 @@
     webrtc::setDecoderFrameSize(decoder, width, height);
 }
 
-void LibWebRTCCodecsProxy::createEncoder(RTCEncoderIdentifier identifier, const String& formatName, const Vector<std::pair<String, String>>& parameters, bool useLowLatency)
+void LibWebRTCCodecsProxy::createEncoder(VideoEncoderIdentifier identifier, const String& formatName, const Vector<std::pair<String, String>>& parameters, bool useLowLatency)
 {
     assertIsCurrent(workQueue());
     std::map<std::string, std::string> rtcParameters;
@@ -187,7 +187,7 @@
     m_hasEncodersOrDecoders = true;
 }
 
-void LibWebRTCCodecsProxy::releaseEncoder(RTCEncoderIdentifier identifier)
+void LibWebRTCCodecsProxy::releaseEncoder(VideoEncoderIdentifier identifier)
 {
     assertIsCurrent(workQueue());
     auto encoder = m_encoders.take(identifier);
@@ -199,7 +199,7 @@
     m_hasEncodersOrDecoders = !m_encoders.isEmpty() || !m_decoders.isEmpty();
 }
 
-void LibWebRTCCodecsProxy::initializeEncoder(RTCEncoderIdentifier identifier, uint16_t width, uint16_t height, unsigned startBitrate, unsigned maxBitrate, unsigned minBitrate, uint32_t maxFramerate)
+void LibWebRTCCodecsProxy::initializeEncoder(VideoEncoderIdentifier identifier, uint16_t width, uint16_t height, unsigned startBitrate, unsigned maxBitrate, unsigned minBitrate, uint32_t maxFramerate)
 {
     assertIsCurrent(workQueue());
     auto* encoder = findEncoder(identifier);
@@ -210,7 +210,7 @@
     webrtc::initializeLocalEncoder(encoder->webrtcEncoder, width, height, startBitrate, maxBitrate, minBitrate, maxFramerate);
 }
 
-LibWebRTCCodecsProxy::Encoder* LibWebRTCCodecsProxy::findEncoder(RTCEncoderIdentifier identifier)
+LibWebRTCCodecsProxy::Encoder* LibWebRTCCodecsProxy::findEncoder(VideoEncoderIdentifier identifier)
 {
     auto iterator = m_encoders.find(identifier);
     if (iterator == m_encoders.end())
@@ -234,7 +234,7 @@
     return webrtc::kVideoRotation_0;
 }
 
-void LibWebRTCCodecsProxy::encodeFrame(RTCEncoderIdentifier identifier, SharedVideoFrame&& sharedVideoFrame, uint32_t timeStamp, bool shouldEncodeAsKeyFrame)
+void LibWebRTCCodecsProxy::encodeFrame(VideoEncoderIdentifier identifier, SharedVideoFrame&& sharedVideoFrame, uint32_t timeStamp, bool shouldEncodeAsKeyFrame)
 {
     assertIsCurrent(workQueue());
     auto* encoder = findEncoder(identifier);
@@ -264,7 +264,7 @@
 #endif
 }
 
-void LibWebRTCCodecsProxy::setEncodeRates(RTCEncoderIdentifier identifier, uint32_t bitRate, uint32_t frameRate)
+void LibWebRTCCodecsProxy::setEncodeRates(VideoEncoderIdentifier identifier, uint32_t bitRate, uint32_t frameRate)
 {
     assertIsCurrent(workQueue());
     auto* encoder = findEncoder(identifier);
@@ -276,7 +276,7 @@
     webrtc::setLocalEncoderRates(encoder->webrtcEncoder, bitRate, frameRate);
 }
 
-void LibWebRTCCodecsProxy::setSharedVideoFrameSemaphore(RTCEncoderIdentifier identifier, IPC::Semaphore&& semaphore)
+void LibWebRTCCodecsProxy::setSharedVideoFrameSemaphore(VideoEncoderIdentifier identifier, IPC::Semaphore&& semaphore)
 {
     assertIsCurrent(workQueue());
     auto* encoder = findEncoder(identifier);
@@ -288,7 +288,7 @@
     encoder->frameReader->setSemaphore(WTFMove(semaphore));
 }
 
-void LibWebRTCCodecsProxy::setSharedVideoFrameMemory(RTCEncoderIdentifier identifier, const SharedMemory::Handle& handle)
+void LibWebRTCCodecsProxy::setSharedVideoFrameMemory(VideoEncoderIdentifier identifier, const SharedMemory::Handle& handle)
 {
     assertIsCurrent(workQueue());
     auto* encoder = findEncoder(identifier);

Source/WebKit/Scripts/webkit/messages.py

@@ -304,8 +304,6 @@ def serialized_identifiers():
         'WebKit::PageGroupIdentifier',
         'WebKit::PlaybackSessionContextIdentifier',
         'WebKit::QuotaIncreaseRequestIdentifier',
-        'WebKit::RTCDecoderIdentifier',
-        'WebKit::RTCEncoderIdentifier',
         'WebKit::RemoteAudioDestinationIdentifier',
         'WebKit::RemoteAudioHardwareListenerIdentifier',
         'WebKit::RemoteAudioSessionIdentifier',
@@ -326,6 +324,8 @@ def serialized_identifiers():
         'WebKit::TapIdentifier',
         'WebKit::TrackPrivateRemoteIdentifier',
         'WebKit::UserContentControllerIdentifier',
+        'WebKit::VideoDecoderIdentifier',
+        'WebKit::VideoEncoderIdentifier',
         'WebKit::WebGPUIdentifier',
         'WebKit::WebPageProxyIdentifier',
         'WebKit::WebURLSchemeHandlerIdentifier',

Source/WebKit/Scripts/webkit/tests/MessageArgumentDescriptions.cpp

@@ -44,8 +44,6 @@
 #include "PDFPluginIdentifier.h"
 #include "PlaybackSessionContextIdentifier.h"
 #include "QuotaIncreaseRequestIdentifier.h"
-#include "RTCDecoderIdentifier.h"
-#include "RTCEncoderIdentifier.h"
 #include "RemoteAudioDestinationIdentifier.h"
 #include "RemoteAudioHardwareListenerIdentifier.h"
 #include "RemoteAudioSessionIdentifier.h"
@@ -65,6 +63,8 @@
 #include "StorageNamespaceIdentifier.h"
 #include "TrackPrivateRemoteIdentifier.h"
 #include "UserContentControllerIdentifier.h"
+#include "VideoDecoderIdentifier.h"
+#include "VideoEncoderIdentifier.h"
 #include "WebGPUIdentifier.h"
 #include "WebPageProxyIdentifier.h"
 #include "WebURLSchemeHandlerIdentifier.h"
@@ -417,8 +417,6 @@ Vector<ASCIILiteral> serializedIdentifiers()
     static_assert(sizeof(uint64_t) == sizeof(WebKit::PageGroupIdentifier));
     static_assert(sizeof(uint64_t) == sizeof(WebKit::PlaybackSessionContextIdentifier));
     static_assert(sizeof(uint64_t) == sizeof(WebKit::QuotaIncreaseRequestIdentifier));
-    static_assert(sizeof(uint64_t) == sizeof(WebKit::RTCDecoderIdentifier));
-    static_assert(sizeof(uint64_t) == sizeof(WebKit::RTCEncoderIdentifier));
     static_assert(sizeof(uint64_t) == sizeof(WebKit::RemoteAudioDestinationIdentifier));
     static_assert(sizeof(uint64_t) == sizeof(WebKit::RemoteAudioHardwareListenerIdentifier));
     static_assert(sizeof(uint64_t) == sizeof(WebKit::RemoteAudioSessionIdentifier));
@@ -439,6 +437,8 @@ Vector<ASCIILiteral> serializedIdentifiers()
     static_assert(sizeof(uint64_t) == sizeof(WebKit::TapIdentifier));
     static_assert(sizeof(uint64_t) == sizeof(WebKit::TrackPrivateRemoteIdentifier));
     static_assert(sizeof(uint64_t) == sizeof(WebKit::UserContentControllerIdentifier));
+    static_assert(sizeof(uint64_t) == sizeof(WebKit::VideoDecoderIdentifier));
+    static_assert(sizeof(uint64_t) == sizeof(WebKit::VideoEncoderIdentifier));
     static_assert(sizeof(uint64_t) == sizeof(WebKit::WebGPUIdentifier));
     static_assert(sizeof(uint64_t) == sizeof(WebKit::WebPageProxyIdentifier));
     static_assert(sizeof(uint64_t) == sizeof(WebKit::WebURLSchemeHandlerIdentifier));
@@ -490,8 +490,6 @@ Vector<ASCIILiteral> serializedIdentifiers()
         "WebKit::PageGroupIdentifier"_s,
         "WebKit::PlaybackSessionContextIdentifier"_s,
         "WebKit::QuotaIncreaseRequestIdentifier"_s,
-        "WebKit::RTCDecoderIdentifier"_s,
-        "WebKit::RTCEncoderIdentifier"_s,
         "WebKit::RemoteAudioDestinationIdentifier"_s,
         "WebKit::RemoteAudioHardwareListenerIdentifier"_s,
         "WebKit::RemoteAudioSessionIdentifier"_s,
@@ -512,6 +510,8 @@ Vector<ASCIILiteral> serializedIdentifiers()
         "WebKit::TapIdentifier"_s,
         "WebKit::TrackPrivateRemoteIdentifier"_s,
         "WebKit::UserContentControllerIdentifier"_s,
+        "WebKit::VideoDecoderIdentifier"_s,
+        "WebKit::VideoEncoderIdentifier"_s,
         "WebKit::WebGPUIdentifier"_s,
         "WebKit::WebPageProxyIdentifier"_s,
         "WebKit::WebURLSchemeHandlerIdentifier"_s,