mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-17 07:37:51 +01:00
3a034e15b4
Done in preparation for some threading changes that would be quite messy if implemented with the class as-is. This results in some code duplication, but is preferable to one class having two completely different modes of operation. RTP data channels are in the process of being removed anyway, so the duplicated code won't last forever. Bug: webrtc:9883 Change-Id: Idfd41a669b56a4bb4819572e4a264a4ffaaba9c0 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/178940 Commit-Queue: Taylor <deadbeef@webrtc.org> Reviewed-by: Harald Alvestrand <hta@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31691}
235 lines
9.6 KiB
C++
235 lines
9.6 KiB
C++
/*
|
|
* Copyright 2019 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#ifndef PC_DATA_CHANNEL_CONTROLLER_H_
|
|
#define PC_DATA_CHANNEL_CONTROLLER_H_
|
|
|
|
#include <map>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "pc/channel.h"
|
|
#include "pc/rtp_data_channel.h"
|
|
#include "pc/sctp_data_channel.h"
|
|
#include "rtc_base/weak_ptr.h"
|
|
|
|
namespace webrtc {
|
|
|
|
class PeerConnection;
|
|
|
|
class DataChannelController : public RtpDataChannelProviderInterface,
|
|
public SctpDataChannelProviderInterface,
|
|
public DataChannelSink {
|
|
public:
|
|
explicit DataChannelController(PeerConnection* pc) : pc_(pc) {}
|
|
|
|
// Not copyable or movable.
|
|
DataChannelController(DataChannelController&) = delete;
|
|
DataChannelController& operator=(const DataChannelController& other) = delete;
|
|
DataChannelController(DataChannelController&&) = delete;
|
|
DataChannelController& operator=(DataChannelController&& other) = delete;
|
|
|
|
// Implements RtpDataChannelProviderInterface/
|
|
// SctpDataChannelProviderInterface.
|
|
bool SendData(const cricket::SendDataParams& params,
|
|
const rtc::CopyOnWriteBuffer& payload,
|
|
cricket::SendDataResult* result) override;
|
|
bool ConnectDataChannel(RtpDataChannel* webrtc_data_channel) override;
|
|
void DisconnectDataChannel(RtpDataChannel* webrtc_data_channel) override;
|
|
bool ConnectDataChannel(SctpDataChannel* webrtc_data_channel) override;
|
|
void DisconnectDataChannel(SctpDataChannel* webrtc_data_channel) override;
|
|
void AddSctpDataStream(int sid) override;
|
|
void RemoveSctpDataStream(int sid) override;
|
|
bool ReadyToSendData() const override;
|
|
|
|
// Implements DataChannelSink.
|
|
void OnDataReceived(int channel_id,
|
|
DataMessageType type,
|
|
const rtc::CopyOnWriteBuffer& buffer) override;
|
|
void OnChannelClosing(int channel_id) override;
|
|
void OnChannelClosed(int channel_id) override;
|
|
void OnReadyToSend() override;
|
|
void OnTransportClosed() override;
|
|
|
|
// Called from PeerConnection::SetupDataChannelTransport_n
|
|
void SetupDataChannelTransport_n();
|
|
// Called from PeerConnection::TeardownDataChannelTransport_n
|
|
void TeardownDataChannelTransport_n();
|
|
|
|
// Called from PeerConnection::OnTransportChanged
|
|
// to make required changes to datachannels' transports.
|
|
void OnTransportChanged(
|
|
DataChannelTransportInterface* data_channel_transport);
|
|
|
|
// Called from PeerConnection::GetDataChannelStats on the signaling thread.
|
|
std::vector<DataChannelStats> GetDataChannelStats() const;
|
|
|
|
// Creates channel and adds it to the collection of DataChannels that will
|
|
// be offered in a SessionDescription, and wraps it in a proxy object.
|
|
rtc::scoped_refptr<DataChannelInterface> InternalCreateDataChannelWithProxy(
|
|
const std::string& label,
|
|
const InternalDataChannelInit*
|
|
config) /* RTC_RUN_ON(signaling_thread()) */;
|
|
void AllocateSctpSids(rtc::SSLRole role);
|
|
|
|
SctpDataChannel* FindDataChannelBySid(int sid) const;
|
|
|
|
// Checks if any data channel has been added.
|
|
bool HasDataChannels() const;
|
|
bool HasSctpDataChannels() const {
|
|
RTC_DCHECK_RUN_ON(signaling_thread());
|
|
return !sctp_data_channels_.empty();
|
|
}
|
|
bool HasRtpDataChannels() const {
|
|
RTC_DCHECK_RUN_ON(signaling_thread());
|
|
return !rtp_data_channels_.empty();
|
|
}
|
|
|
|
void UpdateLocalRtpDataChannels(const cricket::StreamParamsVec& streams);
|
|
void UpdateRemoteRtpDataChannels(const cricket::StreamParamsVec& streams);
|
|
|
|
// Accessors
|
|
cricket::DataChannelType data_channel_type() const;
|
|
void set_data_channel_type(cricket::DataChannelType type);
|
|
cricket::RtpDataChannel* rtp_data_channel() const {
|
|
return rtp_data_channel_;
|
|
}
|
|
void set_rtp_data_channel(cricket::RtpDataChannel* channel) {
|
|
rtp_data_channel_ = channel;
|
|
}
|
|
DataChannelTransportInterface* data_channel_transport() const;
|
|
void set_data_channel_transport(DataChannelTransportInterface* transport);
|
|
const std::map<std::string, rtc::scoped_refptr<RtpDataChannel>>*
|
|
rtp_data_channels() const;
|
|
|
|
sigslot::signal1<RtpDataChannel*>& SignalRtpDataChannelCreated() {
|
|
RTC_DCHECK_RUN_ON(signaling_thread());
|
|
return SignalRtpDataChannelCreated_;
|
|
}
|
|
sigslot::signal1<SctpDataChannel*>& SignalSctpDataChannelCreated() {
|
|
RTC_DCHECK_RUN_ON(signaling_thread());
|
|
return SignalSctpDataChannelCreated_;
|
|
}
|
|
// Called when the transport for the data channels is closed or destroyed.
|
|
void OnTransportChannelClosed();
|
|
|
|
void OnSctpDataChannelClosed(SctpDataChannel* channel);
|
|
|
|
private:
|
|
rtc::scoped_refptr<RtpDataChannel> InternalCreateRtpDataChannel(
|
|
const std::string& label,
|
|
const DataChannelInit* config) /* RTC_RUN_ON(signaling_thread()) */;
|
|
|
|
rtc::scoped_refptr<SctpDataChannel> InternalCreateSctpDataChannel(
|
|
const std::string& label,
|
|
const InternalDataChannelInit*
|
|
config) /* RTC_RUN_ON(signaling_thread()) */;
|
|
|
|
// Parses and handles open messages. Returns true if the message is an open
|
|
// message, false otherwise.
|
|
bool HandleOpenMessage_s(const cricket::ReceiveDataParams& params,
|
|
const rtc::CopyOnWriteBuffer& buffer)
|
|
RTC_RUN_ON(signaling_thread());
|
|
// Called when a valid data channel OPEN message is received.
|
|
void OnDataChannelOpenMessage(const std::string& label,
|
|
const InternalDataChannelInit& config)
|
|
RTC_RUN_ON(signaling_thread());
|
|
|
|
void CreateRemoteRtpDataChannel(const std::string& label,
|
|
uint32_t remote_ssrc)
|
|
RTC_RUN_ON(signaling_thread());
|
|
|
|
void UpdateClosingRtpDataChannels(
|
|
const std::vector<std::string>& active_channels,
|
|
bool is_local_update) RTC_RUN_ON(signaling_thread());
|
|
|
|
// Called from SendData when data_channel_transport() is true.
|
|
bool DataChannelSendData(const cricket::SendDataParams& params,
|
|
const rtc::CopyOnWriteBuffer& payload,
|
|
cricket::SendDataResult* result);
|
|
|
|
// Called when all data channels need to be notified of a transport channel
|
|
// (calls OnTransportChannelCreated on the signaling thread).
|
|
void NotifyDataChannelsOfTransportCreated();
|
|
|
|
rtc::Thread* network_thread() const;
|
|
rtc::Thread* signaling_thread() const;
|
|
|
|
// Specifies which kind of data channel is allowed. This is controlled
|
|
// by the chrome command-line flag and constraints:
|
|
// 1. If chrome command-line switch 'enable-sctp-data-channels' is enabled,
|
|
// constraint kEnableDtlsSrtp is true, and constaint kEnableRtpDataChannels is
|
|
// not set or false, SCTP is allowed (DCT_SCTP);
|
|
// 2. If constraint kEnableRtpDataChannels is true, RTP is allowed (DCT_RTP);
|
|
// 3. If both 1&2 are false, data channel is not allowed (DCT_NONE).
|
|
cricket::DataChannelType data_channel_type_ =
|
|
cricket::DCT_NONE; // TODO(bugs.webrtc.org/9987): Accessed on both
|
|
// signaling and network thread.
|
|
|
|
// Plugin transport used for data channels. Pointer may be accessed and
|
|
// checked from any thread, but the object may only be touched on the
|
|
// network thread.
|
|
// TODO(bugs.webrtc.org/9987): Accessed on both signaling and network
|
|
// thread.
|
|
DataChannelTransportInterface* data_channel_transport_ = nullptr;
|
|
|
|
// Cached value of whether the data channel transport is ready to send.
|
|
bool data_channel_transport_ready_to_send_
|
|
RTC_GUARDED_BY(signaling_thread()) = false;
|
|
|
|
// |rtp_data_channel_| is used if in RTP data channel mode,
|
|
// |data_channel_transport_| when using SCTP.
|
|
cricket::RtpDataChannel* rtp_data_channel_ = nullptr;
|
|
// TODO(bugs.webrtc.org/9987): Accessed on both
|
|
// signaling and some other thread.
|
|
|
|
SctpSidAllocator sid_allocator_ /* RTC_GUARDED_BY(signaling_thread()) */;
|
|
std::vector<rtc::scoped_refptr<SctpDataChannel>> sctp_data_channels_
|
|
RTC_GUARDED_BY(signaling_thread());
|
|
std::vector<rtc::scoped_refptr<SctpDataChannel>> sctp_data_channels_to_free_
|
|
RTC_GUARDED_BY(signaling_thread());
|
|
|
|
// Map of label -> DataChannel
|
|
std::map<std::string, rtc::scoped_refptr<RtpDataChannel>> rtp_data_channels_
|
|
RTC_GUARDED_BY(signaling_thread());
|
|
|
|
// Signals from |data_channel_transport_|. These are invoked on the
|
|
// signaling thread.
|
|
// TODO(bugs.webrtc.org/11547): These '_s' signals likely all belong on the
|
|
// network thread.
|
|
sigslot::signal1<bool> SignalDataChannelTransportWritable_s
|
|
RTC_GUARDED_BY(signaling_thread());
|
|
sigslot::signal2<const cricket::ReceiveDataParams&,
|
|
const rtc::CopyOnWriteBuffer&>
|
|
SignalDataChannelTransportReceivedData_s
|
|
RTC_GUARDED_BY(signaling_thread());
|
|
sigslot::signal1<int> SignalDataChannelTransportChannelClosing_s
|
|
RTC_GUARDED_BY(signaling_thread());
|
|
sigslot::signal1<int> SignalDataChannelTransportChannelClosed_s
|
|
RTC_GUARDED_BY(signaling_thread());
|
|
|
|
sigslot::signal1<RtpDataChannel*> SignalRtpDataChannelCreated_
|
|
RTC_GUARDED_BY(signaling_thread());
|
|
sigslot::signal1<SctpDataChannel*> SignalSctpDataChannelCreated_
|
|
RTC_GUARDED_BY(signaling_thread());
|
|
|
|
// Used to invoke data channel transport signals on the signaling thread.
|
|
std::unique_ptr<rtc::AsyncInvoker> data_channel_transport_invoker_
|
|
RTC_GUARDED_BY(network_thread());
|
|
|
|
// Owning PeerConnection.
|
|
PeerConnection* const pc_;
|
|
rtc::WeakPtrFactory<DataChannelController> weak_factory_{this};
|
|
};
|
|
|
|
} // namespace webrtc
|
|
|
|
#endif // PC_DATA_CHANNEL_CONTROLLER_H_
|