int* error) {
// Always succeeds, since this is an unreliable transport anyway.
// TODO: Should this block if channel_'s temporarily unwritable?
- channel_->SendPacket(
- static_cast<const char*>(data), data_len, talk_base::DSCP_NO_CHANGE);
+ talk_base::PacketOptions packet_options;
+ channel_->SendPacket(static_cast<const char*>(data), data_len,
+ packet_options);
if (written) {
*written = data_len;
}
&DtlsTransportChannelWrapper::OnRoleConflict);
channel_->SignalRouteChange.connect(this,
&DtlsTransportChannelWrapper::OnRouteChange);
+ channel_->SignalConnectionRemoved.connect(this,
+ &DtlsTransportChannelWrapper::OnConnectionRemoved);
}
DtlsTransportChannelWrapper::~DtlsTransportChannelWrapper() {
// Called from upper layers to send a media packet.
-int DtlsTransportChannelWrapper::SendPacket(const char* data, size_t size,
- talk_base::DiffServCodePoint dscp,
- int flags) {
+int DtlsTransportChannelWrapper::SendPacket(
+ const char* data, size_t size,
+ const talk_base::PacketOptions& options, int flags) {
int result = -1;
switch (dtls_state_) {
break;
}
- result = channel_->SendPacket(data, size, dscp);
+ result = channel_->SendPacket(data, size, options);
} else {
result = (dtls_->WriteAll(data, size, NULL, NULL) ==
talk_base::SR_SUCCESS) ? static_cast<int>(size) : -1;
break;
// Not doing DTLS.
case STATE_NONE:
- result = channel_->SendPacket(data, size, dscp);
+ result = channel_->SendPacket(data, size, options);
break;
case STATE_CLOSED: // Can't send anything when we're closed.
}
}
-void DtlsTransportChannelWrapper::OnReadPacket(TransportChannel* channel,
- const char* data, size_t size,
- int flags) {
+void DtlsTransportChannelWrapper::OnReadPacket(
+ TransportChannel* channel, const char* data, size_t size,
+ const talk_base::PacketTime& packet_time, int flags) {
ASSERT(talk_base::Thread::Current() == worker_thread_);
ASSERT(channel == channel_);
ASSERT(flags == 0);
switch (dtls_state_) {
case STATE_NONE:
// We are not doing DTLS
- SignalReadPacket(this, data, size, 0);
+ SignalReadPacket(this, data, size, packet_time, 0);
break;
case STATE_OFFERED:
ASSERT(!srtp_ciphers_.empty());
// Signal this upwards as a bypass packet.
- SignalReadPacket(this, data, size, PF_SRTP_BYPASS);
+ SignalReadPacket(this, data, size, packet_time, PF_SRTP_BYPASS);
}
break;
case STATE_CLOSED:
char buf[kMaxDtlsPacketLen];
size_t read;
if (dtls_->Read(buf, sizeof(buf), &read, NULL) == talk_base::SR_SUCCESS) {
- SignalReadPacket(this, buf, read, 0);
+ SignalReadPacket(this, buf, read, talk_base::CreatePacketTime(0), 0);
}
}
if (sig & talk_base::SE_CLOSE) {
SignalRouteChange(this, candidate);
}
+void DtlsTransportChannelWrapper::OnConnectionRemoved(
+ TransportChannelImpl* channel) {
+ ASSERT(channel == channel_);
+ SignalConnectionRemoved(this);
+}
+
} // namespace cricket