mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove DeliverPacketAsync.

Browse source 
This is currently unused and since we ultimately don't want the delivery
of packets to be async at this stage (but rather stay on the network
thread), we don't need it.

Bug: webrtc:11993
Change-Id: I6809026b6901c8ecfacd961e98ddf79aaa16d0bd
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/220601
Reviewed-by: Markus Handell <handellm@webrtc.org>
Commit-Queue: Markus Handell <handellm@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34152}
This commit is contained in:
Tommi 2021-05-28 15:26:59 +02:00 committed by WebRTC LUCI CQ
parent 785725129a
commit cbb4421eac
2 changed files with 0 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
call/call.cc
View file

@ -300,10 +300,6 @@ class Call final : public webrtc::Call,
DeliveryStatus DeliverPacket(MediaType media_type,
rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) override;
void DeliverPacketAsync(MediaType media_type,
rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us,
PacketCallback callback) override;
// Implements RecoveredPacketReceiver.
void OnRecoveredPacket(const uint8_t* packet, size_t length) override;
@ -1516,30 +1512,6 @@ PacketReceiver::DeliveryStatus Call::DeliverPacket(
return DeliverRtp(media_type, std::move(packet), packet_time_us);
}
void Call::DeliverPacketAsync(MediaType media_type,
rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us,
PacketCallback callback) {
RTC_DCHECK_RUN_ON(network_thread_);
TaskQueueBase* network_thread = rtc::Thread::Current();
RTC_DCHECK(network_thread);
worker_thread_->PostTask(ToQueuedTask(
task_safety_, [this, network_thread, media_type, p = std::move(packet),
packet_time_us, cb = std::move(callback)] {
RTC_DCHECK_RUN_ON(worker_thread_);
DeliveryStatus status = DeliverPacket(media_type, p, packet_time_us);
if (cb) {
network_thread->PostTask(
ToQueuedTask([cb = std::move(cb), status, media_type,
p = std::move(p), packet_time_us]() {
cb(status, media_type, std::move(p), packet_time_us);
}));
}
}));
}
void Call::OnRecoveredPacket(const uint8_t* packet, size_t length) {
// TODO(bugs.webrtc.org/11993): Expect to be called on the network thread.
// This method is called synchronously via |OnRtpPacket()| (see DeliverRtp)

33
call/packet_receiver.h
View file

@ -10,13 +10,6 @@
#ifndef CALL_PACKET_RECEIVER_H_
#define CALL_PACKET_RECEIVER_H_
#include <algorithm>
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "api/media_types.h"
#include "rtc_base/copy_on_write_buffer.h"
@ -30,32 +23,6 @@ class PacketReceiver {
DELIVERY_PACKET_ERROR,
};
// Definition of the callback to execute when packet delivery is complete.
// The callback will be issued on the same thread as called DeliverPacket.
typedef std::function<
void(DeliveryStatus, MediaType, rtc::CopyOnWriteBuffer, int64_t)>
PacketCallback;
// Asynchronously handle packet delivery and report back to the caller when
// delivery of the packet has completed.
// Note that if the packet is invalid or can be processed without the need of
// asynchronous operations that the |callback| may have been called before
// the function returns.
// TODO(bugs.webrtc.org/11993): This function is meant to be called on the
// network thread exclusively but while the code is being updated to align
// with those goals, it may be called either on the worker or network threads.
// Update docs etc when the work has been completed. Once we're done with the
// updates, we might be able to go back to returning the status from this
// function instead of having to report it via a callback.
virtual void DeliverPacketAsync(MediaType media_type,
rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us,
PacketCallback callback) {
DeliveryStatus status = DeliverPacket(media_type, packet, packet_time_us);
if (callback)
callback(status, media_type, std::move(packet), packet_time_us);
}
virtual DeliveryStatus DeliverPacket(MediaType media_type,
rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) = 0;