RTCDataChannel close event does not fire if RTCPeerConnection closes

youennf · youennf · commit e83716d17383 · 2025-12-22T04:28:11.000-08:00
rdar://165617848 https://bugs.webkit.org/show_bug.cgi?id=303052 Reviewed by Jean-Yves Avenard. Since closing the peer connection backend is severing the state updates of the data channel backend, we add the logic to close the data channel from RTCPeerConnection::close. For that reason, we keep a list of channel identifiers in RTCPeerConnection. We then call RTCDataChannelHandlerClient::peerConnectionIsClosing for each of this identifier. This will do the following: - If the data channel lives in main thread, it will call RTCDataChannel::peerConnectionIsClosing() directly. - If the data channel lives in another process, it will call RTCDataChannel::peerConnectionIsClosing() directly. - If the data channel lives in a worker, it will call RTCDataChannel::peerConnectionIsClosing() after hopping to the service worker thread. - If the data channel is being transferred, it will call RTCDataChannel::peerConnectionIsClosing() which will make the newly transferred data channel moving to closed state. Covered by added test. Canonical link: https://commits.webkit.org/304859@main
diff --git a/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCDataChannel-local-close-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCDataChannel-local-close-expected.txt
@@ -0,0 +1,5 @@
+
+PASS Close peerconnection causes close event on local channel
+PASS Close peerconnection causes close event on transfered channel
+PASS Close peerconnection causes close event on local being transfered channel
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCDataChannel-local-close.html b/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCDataChannel-local-close.html
@@ -0,0 +1,85 @@
+<!doctype html>
+<meta charset=utf-8>
+<meta name="timeout" content="long">
+<title>RTCDataChannel.prototype.close</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="RTCPeerConnection-helper.js"></script>
+<script>
+'use strict';
+
+promise_test(async t => {
+  const pc1 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  const [channel1, channel2] = await createDataChannelPairWithLabel(t, 'local_close', [], pc1);
+
+  const haveClosed1 = new Promise((resolve, reject) => {
+    channel1.addEventListener('close', () => {
+      assert_true(isClosed);
+      resolve();
+    });
+    t.step_timeout(() => reject('test1 timed out'), 2000);
+  });
+  const haveClosed2 = new Promise((resolve, reject) => {
+    channel2.addEventListener('close', resolve);
+    t.step_timeout(() => reject('test2 timed out'), 2000);
+  });
+
+  let isClosed = false;
+  let isClosing1 = false;
+  let isClosing2 = false;
+  channel1.onclosing = () => {
+    isClosing1 = true;
+    assert_true(isClosed, "isClosed for channel1.onclosing");
+  }
+  channel2.onclosing = () => {
+    isClosing2 = true;
+    assert_true(isClosed, "isClosed for channel2.onclosing");
+  }
+ 
+  pc1.close();
+  isClosed = true;
+  await haveClosed1;
+  await haveClosed2;
+
+  assert_false(isClosing1, "isClosing1");
+  assert_true(isClosing2, "isClosing2");
+}, `Close peerconnection causes close event on local channel`);
+
+promise_test(async t => {
+  const pc1 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  const channel1 = pc1.createDataChannel("test");
+
+  const worker = new Worker(`data:text/javascript,onmessage = e => { e.data.onclose = () => postMessage('CLOSED'); postMessage("OK"); };`);
+
+  worker.postMessage(channel1, [channel1]);
+  const transferResult = await new Promise(resolve => worker.addEventListener('message', e => resolve(e.data)));
+  assert_equals(transferResult, "OK");
+
+  const haveClosed1 = new Promise((resolve, reject) => {
+    worker.addEventListener('message', e => resolve(e.data));
+    t.step_timeout(() => reject("test timed out"), 1000);
+  });
+
+  pc1.close();
+  assert_equals(await haveClosed1, "CLOSED");
+}, `Close peerconnection causes close event on transfered channel`);
+
+promise_test(async t => {
+  const pc1 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  const channel1 = pc1.createDataChannel("test");
+
+  const worker = new Worker(`data:text/javascript,onmessage = e => { if (e.data.readyState === 'closed') postMessage('CLOSED'); e.data.onclose = () => postMessage('CLOSED'); };`);
+  const haveClosed1 = new Promise((resolve, reject) => {
+    worker.onmessage = e => resolve(e.data);
+    t.step_timeout(() => reject("test timed out"), 1000);
+  });
+
+  worker.postMessage(channel1, [channel1]);
+  pc1.close();
+  assert_equals(await haveClosed1, "CLOSED");
+}, `Close peerconnection causes close event on local being transfered channel`);
+
+</script>
diff --git a/Source/WebCore/Modules/mediastream/RTCDataChannel.cpp b/Source/WebCore/Modules/mediastream/RTCDataChannel.cpp
@@ -53,10 +53,9 @@ namespace WebCore {
 WTF_MAKE_TZONE_ALLOCATED_IMPL(DetachedRTCDataChannel);
 WTF_MAKE_TZONE_ALLOCATED_IMPL(RTCDataChannel);
 
-Ref<RTCDataChannel> RTCDataChannel::create(ScriptExecutionContext& context, std::unique_ptr<RTCDataChannelHandler>&& handler, String&& label, RTCDataChannelInit&& options, RTCDataChannelState state)
+Ref<RTCDataChannel> RTCDataChannel::create(ScriptExecutionContext& context, std::unique_ptr<RTCDataChannelHandler>&& handler, String&& label, RTCDataChannelInit&& options, RTCDataChannelState state, std::optional<RTCDataChannelIdentifier> identifier)
 {
-    ASSERT(handler);
-    Ref channel = adoptRef(*new RTCDataChannel(context, WTF::move(handler), WTF::move(label), WTF::move(options), state));
+    Ref channel = adoptRef(*new RTCDataChannel(context, identifier.value_or(RTCDataChannelIdentifier::generate()), WTF::move(handler), WTF::move(label), WTF::move(options), state));
     channel->suspendIfNeeded();
     queueTaskKeepingObjectAlive(channel.get(), TaskSource::Networking, [](auto& channel) {
         if (!channel.m_isDetachable)
@@ -87,10 +86,10 @@ Ref<NetworkSendQueue> RTCDataChannel::createMessageQueue(ScriptExecutionContext&
     });
 }
 
-RTCDataChannel::RTCDataChannel(ScriptExecutionContext& context, std::unique_ptr<RTCDataChannelHandler>&& handler, String&& label, RTCDataChannelInit&& options, RTCDataChannelState readyState)
+RTCDataChannel::RTCDataChannel(ScriptExecutionContext& context, RTCDataChannelIdentifier identifier, std::unique_ptr<RTCDataChannelHandler>&& handler, String&& label, RTCDataChannelInit&& options, RTCDataChannelState readyState)
     : ActiveDOMObject(&context)
+    , RTCDataChannelHandlerClient(context.identifier(), identifier)
     , m_handler(WTF::move(handler))
-    , m_identifier(RTCDataChannelIdentifier::generate())
     , m_contextIdentifier(context.isDocument() ? std::nullopt : std::optional { context.identifier() })
     , m_readyState(readyState)
     , m_label(WTF::move(label))
@@ -284,6 +283,8 @@ std::unique_ptr<DetachedRTCDataChannel> RTCDataChannel::detach()
     m_isDetached = true;
     m_readyState = RTCDataChannelState::Closed;
 
+    willDetach();
+
     Locker locker { s_rtcDataChannelLocalMapLock };
     rtcDataChannelLocalMap().add(identifier().object(), WTF::move(m_handler));
 
@@ -321,18 +322,21 @@ Ref<RTCDataChannel> RTCDataChannel::create(ScriptExecutionContext& context, RTCD
 {
     CheckedPtr<RTCDataChannelRemoteHandler> remoteHandlerPtr;
     std::unique_ptr<RTCDataChannelHandler> handler;
-    if (identifier.processIdentifier() == Process::identifier())
+    std::optional<RTCDataChannelIdentifier> localIdentifier;
+    if (identifier.processIdentifier() == Process::identifier()) {
         handler = RTCDataChannel::handlerFromIdentifier(identifier.object());
-    else {
+        localIdentifier = identifier;
+    } else {
         auto remoteHandler = RTCDataChannelRemoteHandler::create(identifier, context.createRTCDataChannelRemoteHandlerConnection());
         remoteHandlerPtr = remoteHandler.get();
         handler = WTF::move(remoteHandler);
+        localIdentifier = RTCDataChannelIdentifier::generate();
     }
 
     if (!handler)
         return createClosedChannel(context, WTF::move(label), WTF::move(options));
 
-    auto channel = RTCDataChannel::create(context, WTF::move(handler), WTF::move(label), WTF::move(options), state);
+    auto channel = RTCDataChannel::create(context, WTF::move(handler), WTF::move(label), WTF::move(options), state, *localIdentifier);
 
     if (remoteHandlerPtr)
         remoteHandlerPtr->setLocalIdentifier(channel->identifier());
diff --git a/Source/WebCore/Modules/mediastream/RTCDataChannel.h b/Source/WebCore/Modules/mediastream/RTCDataChannel.h
@@ -54,7 +54,7 @@ template<typename> class ExceptionOr;
 class RTCDataChannel final : public RefCounted<RTCDataChannel>, public ActiveDOMObject, public RTCDataChannelHandlerClient, public EventTarget {
     WTF_MAKE_TZONE_ALLOCATED(RTCDataChannel);
 public:
-    static Ref<RTCDataChannel> create(ScriptExecutionContext&, std::unique_ptr<RTCDataChannelHandler>&&, String&&, RTCDataChannelInit&&, RTCDataChannelState);
+    static Ref<RTCDataChannel> create(ScriptExecutionContext&, std::unique_ptr<RTCDataChannelHandler>&&, String&&, RTCDataChannelInit&&, RTCDataChannelState, std::optional<RTCDataChannelIdentifier> identifier = { });
     static Ref<RTCDataChannel> create(ScriptExecutionContext&, RTCDataChannelIdentifier, String&&, RTCDataChannelInit&&, RTCDataChannelState);
     WEBCORE_EXPORT virtual ~RTCDataChannel();
 
@@ -89,15 +89,15 @@ class RTCDataChannel final : public RefCounted<RTCDataChannel>, public ActiveDOM
 
     void close();
 
-    RTCDataChannelIdentifier identifier() const { return m_identifier; }
     bool canDetach() const;
     std::unique_ptr<DetachedRTCDataChannel> detach();
 
+    static void removeDetachedRTCDataChannel(RTCDataChannelIdentifier identifer) { handlerFromIdentifier(identifer.object()); }
     WEBCORE_EXPORT static std::unique_ptr<RTCDataChannelHandler> handlerFromIdentifier(RTCDataChannelLocalIdentifier);
     void fireOpenEventIfNeeded();
 
 private:
-    RTCDataChannel(ScriptExecutionContext&, std::unique_ptr<RTCDataChannelHandler>&&, String&&, RTCDataChannelInit&&, RTCDataChannelState);
+    RTCDataChannel(ScriptExecutionContext&, RTCDataChannelIdentifier, std::unique_ptr<RTCDataChannelHandler>&&, String&&, RTCDataChannelInit&&, RTCDataChannelState);
 
     static Ref<NetworkSendQueue> createMessageQueue(ScriptExecutionContext&, RTCDataChannel&);
 
@@ -121,9 +121,9 @@ class RTCDataChannel final : public RefCounted<RTCDataChannel>, public ActiveDOM
     void didReceiveRawData(std::span<const uint8_t>) final;
     void didDetectError(Ref<RTCError>&&) final;
     void bufferedAmountIsDecreasing(size_t) final;
+    void peerConnectionIsClosing() final { didChangeReadyState(RTCDataChannelState::Closed); }
 
     std::unique_ptr<RTCDataChannelHandler> m_handler;
-    RTCDataChannelIdentifier m_identifier;
     Markable<ScriptExecutionContextIdentifier> m_contextIdentifier;
     // FIXME: m_stopped is probably redundant with m_readyState.
     bool m_stopped { false };
diff --git a/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteSource.cpp b/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteSource.cpp
@@ -36,22 +36,78 @@ namespace WebCore {
 
 WTF_MAKE_TZONE_ALLOCATED_IMPL(RTCDataChannelRemoteSource);
 
-Ref<RTCDataChannelRemoteSource> RTCDataChannelRemoteSource::create(RTCDataChannelIdentifier identifier, UniqueRef<RTCDataChannelHandler>&& handler, Ref<RTCDataChannelRemoteSourceConnection>&& connection)
+Ref<RTCDataChannelRemoteSource> RTCDataChannelRemoteSource::create(RTCDataChannelIdentifier localIdentifier, RTCDataChannelIdentifier remoteIdentifier, UniqueRef<RTCDataChannelHandler>&& handler, Ref<RTCDataChannelRemoteSourceConnection>&& connection)
 {
-    return adoptRef(*new RTCDataChannelRemoteSource(identifier, WTF::move(handler), WTF::move(connection)));
+    return adoptRef(*new RTCDataChannelRemoteSource(localIdentifier, remoteIdentifier, WTF::move(handler), WTF::move(connection)));
 }
 
-RTCDataChannelRemoteSource::RTCDataChannelRemoteSource(RTCDataChannelIdentifier identifier, UniqueRef<RTCDataChannelHandler>&& handler, Ref<RTCDataChannelRemoteSourceConnection>&& connection)
-    : m_identifier(identifier)
+RTCDataChannelRemoteSource::RTCDataChannelRemoteSource(RTCDataChannelIdentifier localIdentifier, RTCDataChannelIdentifier remoteIdentifier, UniqueRef<RTCDataChannelHandler>&& handler, Ref<RTCDataChannelRemoteSourceConnection>&& connection)
+    : RTCDataChannelHandlerClient(std::nullopt, localIdentifier)
+    , m_remoteIdentifier(remoteIdentifier)
     , m_handler(WTF::move(handler))
     , m_connection(WTF::move(connection))
 {
+    ASSERT(isMainThread());
     // FIXME: We should ask m_handler to call us on its own background thread.
     m_handler->setClient(*this, std::nullopt);
 }
 
 RTCDataChannelRemoteSource::~RTCDataChannelRemoteSource() = default;
 
+void RTCDataChannelRemoteSource::didChangeReadyState(RTCDataChannelState state)
+{
+    ASSERT(isMainThread());
+    if (m_isClosed)
+        return;
+    if (state == RTCDataChannelState::Closed)
+        m_isClosed = true;
+    m_connection->didChangeReadyState(m_remoteIdentifier, state);
+}
+
+void RTCDataChannelRemoteSource::didReceiveStringData(const String& text)
+{
+    ASSERT(isMainThread());
+    if (m_isClosed)
+        return;
+    m_connection->didReceiveStringData(m_remoteIdentifier, text);
+}
+
+void RTCDataChannelRemoteSource::didReceiveRawData(std::span<const uint8_t> data)
+{
+    ASSERT(isMainThread());
+    if (m_isClosed)
+        return;
+    m_connection->didReceiveRawData(m_remoteIdentifier, data);
+}
+
+void RTCDataChannelRemoteSource::didDetectError(Ref<RTCError>&& error)
+{
+    ASSERT(isMainThread());
+    if (m_isClosed)
+        return;
+    m_connection->didDetectError(m_remoteIdentifier, error->errorDetail(), error->message());
+}
+
+void RTCDataChannelRemoteSource::bufferedAmountIsDecreasing(size_t amount)
+{
+    ASSERT(isMainThread());
+    if (m_isClosed)
+        return;
+    m_connection->bufferedAmountIsDecreasing(m_remoteIdentifier, amount);
+}
+
+size_t RTCDataChannelRemoteSource::bufferedAmount() const
+{
+    ASSERT(isMainThread());
+    return 0;
+}
+
+void RTCDataChannelRemoteSource::peerConnectionIsClosing()
+{
+    ASSERT(isMainThread());
+    didChangeReadyState(RTCDataChannelState::Closed);
+}
+
 } // namespace WebCore
 
 #endif // ENABLE(WEB_RTC)
diff --git a/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteSource.h b/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteSource.h
@@ -40,7 +40,7 @@ namespace WebCore {
 class RTCDataChannelRemoteSource : public RTCDataChannelHandlerClient, public RefCounted<RTCDataChannelRemoteSource> {
     WTF_MAKE_TZONE_ALLOCATED_EXPORT(RTCDataChannelRemoteSource, WEBCORE_EXPORT);
 public:
-    WEBCORE_EXPORT static Ref<RTCDataChannelRemoteSource> create(RTCDataChannelIdentifier, UniqueRef<RTCDataChannelHandler>&&, Ref<RTCDataChannelRemoteSourceConnection>&&);
+    WEBCORE_EXPORT static Ref<RTCDataChannelRemoteSource> create(RTCDataChannelIdentifier localIdentifier, RTCDataChannelIdentifier remoteIdentifier, UniqueRef<RTCDataChannelHandler>&&, Ref<RTCDataChannelRemoteSourceConnection>&&);
     ~RTCDataChannelRemoteSource();
 
     void ref() const final { RefCounted::ref(); }
@@ -51,17 +51,19 @@ class RTCDataChannelRemoteSource : public RTCDataChannelHandlerClient, public Re
     void close() { m_handler->close(); }
 
 private:
-    WEBCORE_EXPORT RTCDataChannelRemoteSource(RTCDataChannelIdentifier, UniqueRef<RTCDataChannelHandler>&&, Ref<RTCDataChannelRemoteSourceConnection>&&);
+    WEBCORE_EXPORT RTCDataChannelRemoteSource(RTCDataChannelIdentifier localIdentifier, RTCDataChannelIdentifier remoteIdentifier, UniqueRef<RTCDataChannelHandler>&&, Ref<RTCDataChannelRemoteSourceConnection>&&);
 
     // RTCDataChannelHandlerClient
-    void didChangeReadyState(RTCDataChannelState state) final { m_connection->didChangeReadyState(m_identifier, state); }
-    void didReceiveStringData(const String& text) final { m_connection->didReceiveStringData(m_identifier, text); }
-    void didReceiveRawData(std::span<const uint8_t> data) final { m_connection->didReceiveRawData(m_identifier, data); }
-    void didDetectError(Ref<RTCError>&& error) final { m_connection->didDetectError(m_identifier, error->errorDetail(), error->message()); }
-    void bufferedAmountIsDecreasing(size_t amount) final { m_connection->bufferedAmountIsDecreasing(m_identifier, amount); }
-    size_t bufferedAmount() const final { return 0; }
+    void didChangeReadyState(RTCDataChannelState) final;
+    void didReceiveStringData(const String&) final;
+    void didReceiveRawData(std::span<const uint8_t>) final;
+    void didDetectError(Ref<RTCError>&&) final;
+    void bufferedAmountIsDecreasing(size_t) final;
+    size_t bufferedAmount() const final;
+    void peerConnectionIsClosing() final;
 
-    RTCDataChannelIdentifier m_identifier;
+    const RTCDataChannelIdentifier m_remoteIdentifier;
+    bool m_isClosed { false };
     const UniqueRef<RTCDataChannelHandler> m_handler;
     const Ref<RTCDataChannelRemoteSourceConnection> m_connection;
 };
diff --git a/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp b/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp
@@ -689,7 +689,10 @@ ExceptionOr<Ref<RTCDataChannel>> RTCPeerConnection::createDataChannel(String&& l
     if (!channelHandler)
         return Exception { ExceptionCode::OperationError };
 
-    return RTCDataChannel::create(*document(), WTF::move(channelHandler), WTF::move(label), WTF::move(options), RTCDataChannelState::Connecting);
+    Ref channel = RTCDataChannel::create(*document(), WTF::move(channelHandler), WTF::move(label), WTF::move(options), RTCDataChannelState::Connecting);
+
+    m_channels.append(channel->identifier());
+    return channel;
 }
 
 bool RTCPeerConnection::doClose()
@@ -714,6 +717,9 @@ bool RTCPeerConnection::doClose()
     }
     m_operations.clear();
 
+    for (auto identifier : std::exchange(m_channels, { }))
+        RTCDataChannelHandlerClient::peerConnectionIsClosing(identifier);
+
     for (auto& transport : m_dtlsTransports)
         transport->close();
 
@@ -1004,6 +1010,7 @@ void RTCPeerConnection::dispatchDataChannelEvent(UniqueRef<RTCDataChannelHandler
             return;
 
         Ref channel = RTCDataChannel::create(*connection.document(), channelHandler.moveToUniquePtr(), WTF::move(label), WTF::move(channelInit), RTCDataChannelState::Open);
+        connection.m_channels.append(channel->identifier());
         ALWAYS_LOG_WITH_THIS(&connection, LOGIDENTIFIER_WITH_THIS(&connection), makeString("Dispatching data-channel event for channel "_s, channel->label()));
         connection.dispatchEvent(RTCDataChannelEvent::create(eventNames().datachannelEvent, Event::CanBubble::No, Event::IsCancelable::No, Ref { channel }));
         channel->fireOpenEventIfNeeded();
diff --git a/Source/WebCore/Modules/mediastream/RTCPeerConnection.h b/Source/WebCore/Modules/mediastream/RTCPeerConnection.h
@@ -283,6 +283,7 @@ class RTCPeerConnection final
     RTCConfiguration m_configuration;
     WeakPtr<RTCController> m_controller;
     Vector<RefPtr<RTCCertificate>> m_certificates;
+    Vector<RTCDataChannelIdentifier> m_channels;
     bool m_shouldDelayTasks { false };
     Deque<std::pair<Ref<DeferredPromise>, Function<void(Ref<DeferredPromise>&&)>>> m_operations;
     bool m_hasPendingOperation { false };
diff --git a/Source/WebCore/Sources.txt b/Source/WebCore/Sources.txt
@@ -2717,6 +2717,7 @@ platform/mediastream/MediaEndpointConfiguration.cpp
 platform/mediastream/MediaStreamPrivate.cpp
 platform/mediastream/MediaStreamTrackDataHolder.cpp
 platform/mediastream/MediaStreamTrackPrivate.cpp
+platform/mediastream/RTCDataChannelHandlerClient.cpp
 platform/mediastream/RTCIceCandidateDescriptor.cpp
 platform/mediastream/RTCSessionDescriptionDescriptor.cpp
 platform/mediastream/RealtimeIncomingAudioSource.cpp
diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
@@ -10474,6 +10474,7 @@
 		410B3939292F70D50003E515 /* InternalReadableStream.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = InternalReadableStream.cpp; sourceTree = "<group>"; };
 		410B393A292F70D60003E515 /* InternalReadableStream.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = InternalReadableStream.h; sourceTree = "<group>"; };
 		410B7E711045FAB000D8224F /* JSMessageEventCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSMessageEventCustom.cpp; sourceTree = "<group>"; };
+		410B7ECE2EF06B19001217C2 /* RTCDataChannelHandlerClient.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RTCDataChannelHandlerClient.cpp; sourceTree = "<group>"; };
 		410BA1312570FE57002E2F8A /* LibWebRTCRtpTransformableFrame.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LibWebRTCRtpTransformableFrame.cpp; path = libwebrtc/LibWebRTCRtpTransformableFrame.cpp; sourceTree = "<group>"; };
 		410BCF5326F0CD8B0040B124 /* RTCLocalSessionDescriptionInit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCLocalSessionDescriptionInit.h; sourceTree = "<group>"; };
 		410BCF5526F0CD8C0040B124 /* RTCLocalSessionDescriptionInit.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = RTCLocalSessionDescriptionInit.idl; sourceTree = "<group>"; };
@@ -23381,6 +23382,7 @@
 				073930D92AC644A000C1D1B1 /* RedEyeReduction.h */,
 				3135910C1E7DDCB600F30630 /* RTCBundlePolicy.h */,
 				07221BA217CF0AD400848E51 /* RTCDataChannelHandler.h */,
+				410B7ECE2EF06B19001217C2 /* RTCDataChannelHandlerClient.cpp */,
 				07221BA317CF0AD400848E51 /* RTCDataChannelHandlerClient.h */,
 				416EDBFF2600E78700092675 /* RTCDataChannelIdentifier.h */,
 				861FC9E02992A1F500DFDF6D /* RTCDataChannelLocalIdentifier.h */,
diff --git a/Source/WebCore/platform/mediastream/RTCDataChannelHandlerClient.cpp b/Source/WebCore/platform/mediastream/RTCDataChannelHandlerClient.cpp
diff --git a/Source/WebCore/platform/mediastream/RTCDataChannelHandlerClient.h b/Source/WebCore/platform/mediastream/RTCDataChannelHandlerClient.h
diff --git a/Source/WebKit/WebProcess/Network/webrtc/RTCDataChannelRemoteManager.cpp b/Source/WebKit/WebProcess/Network/webrtc/RTCDataChannelRemoteManager.cpp
diff --git a/Tools/TestWebKitAPI/Tests/WebKit/WebRTC.mm b/Tools/TestWebKitAPI/Tests/WebKit/WebRTC.mm
