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

Adopt absl::string_view in call/

Browse source 
Bug: webrtc:13579
Change-Id: Ib616eb3372da341fafb55c23038182751b9da5a2
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/262780
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Ali Tofigh <alito@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36910}
This commit is contained in:
Ali Tofigh 2022-05-17 11:48:46 +02:00 committed by WebRTC LUCI CQ
parent d01e692e01
commit 641a1b11b6
29 changed files with 117 additions and 78 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
call/BUILD.gn
View file

@ -78,6 +78,7 @@ rtc_library("call_interfaces") {
] ]
absl_deps = [ absl_deps = [
"//third_party/abseil-cpp/absl/functional:bind_front", "//third_party/abseil-cpp/absl/functional:bind_front",
"//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional", "//third_party/abseil-cpp/absl/types:optional",
] ]
} }
@ -127,6 +128,7 @@ rtc_library("rtp_interfaces") {
] ]
absl_deps = [ absl_deps = [
"//third_party/abseil-cpp/absl/algorithm:container", "//third_party/abseil-cpp/absl/algorithm:container",
"//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional", "//third_party/abseil-cpp/absl/types:optional",
] ]
} }
@ -339,6 +341,7 @@ rtc_library("call") {
] ]
absl_deps = [ absl_deps = [
"//third_party/abseil-cpp/absl/functional:bind_front", "//third_party/abseil-cpp/absl/functional:bind_front",
"//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional", "//third_party/abseil-cpp/absl/types:optional",
] ]
} }
@ -591,7 +594,10 @@ if (rtc_include_tests) {
"../video", "../video",
"//testing/gtest", "//testing/gtest",
] ]
absl_deps = [ "//third_party/abseil-cpp/absl/flags:flag" ] absl_deps = [
"//third_party/abseil-cpp/absl/flags:flag",
"//third_party/abseil-cpp/absl/strings",
]
} }
} }
@ -616,6 +622,7 @@ if (rtc_include_tests) {
"../rtc_base/network:sent_packet", "../rtc_base/network:sent_packet",
"../test:test_support", "../test:test_support",
] ]
absl_deps = [ "//third_party/abseil-cpp/absl/strings" ]
} }
rtc_source_set("mock_bitrate_allocator") { rtc_source_set("mock_bitrate_allocator") {
testonly = true testonly = true

6
call/adaptation/BUILD.gn
View file

@ -57,6 +57,7 @@ rtc_library("resource_adaptation") {
] ]
absl_deps = [ absl_deps = [
"//third_party/abseil-cpp/absl/algorithm:container", "//third_party/abseil-cpp/absl/algorithm:container",
"//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional", "//third_party/abseil-cpp/absl/types:optional",
"//third_party/abseil-cpp/absl/types:variant", "//third_party/abseil-cpp/absl/types:variant",
] ]
@ -123,6 +124,9 @@ if (rtc_include_tests) {
"../../rtc_base/task_utils:to_queued_task", "../../rtc_base/task_utils:to_queued_task",
"../../test:test_support", "../../test:test_support",
] ]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ] absl_deps = [
"//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional",
]
} }
} }

3
call/adaptation/broadcast_resource_listener.cc
View file

@ -14,6 +14,7 @@
#include <string> #include <string>
#include <utility> #include <utility>
#include "absl/strings/string_view.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/ref_counted_object.h" #include "rtc_base/ref_counted_object.h"
#include "rtc_base/synchronization/mutex.h" #include "rtc_base/synchronization/mutex.h"
@ -24,7 +25,7 @@ namespace webrtc {
// a single ResourceListener. // a single ResourceListener.
class BroadcastResourceListener::AdapterResource : public Resource { class BroadcastResourceListener::AdapterResource : public Resource {
public: public:
explicit AdapterResource(std::string name) : name_(std::move(name)) {} explicit AdapterResource(absl::string_view name) : name_(std::move(name)) {}
~AdapterResource() override { RTC_DCHECK(!listener_); } ~AdapterResource() override { RTC_DCHECK(!listener_); }
// The parent is letting us know we have a usage neasurement. // The parent is letting us know we have a usage neasurement.

6
call/adaptation/resource_adaptation_processor.cc
View file

@ -15,6 +15,7 @@
#include <utility> #include <utility>
#include "absl/algorithm/container.h" #include "absl/algorithm/container.h"
#include "absl/strings/string_view.h"
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/video/video_adaptation_counters.h" #include "api/video/video_adaptation_counters.h"
#include "call/adaptation/video_stream_adapter.h" #include "call/adaptation/video_stream_adapter.h"
@ -59,8 +60,9 @@ ResourceAdaptationProcessor::MitigationResultAndLogMessage::
: result(MitigationResult::kAdaptationApplied), message() {} : result(MitigationResult::kAdaptationApplied), message() {}
ResourceAdaptationProcessor::MitigationResultAndLogMessage:: ResourceAdaptationProcessor::MitigationResultAndLogMessage::
MitigationResultAndLogMessage(MitigationResult result, std::string message) MitigationResultAndLogMessage(MitigationResult result,
: result(result), message(std::move(message)) {} absl::string_view message)
: result(result), message(message) {}
ResourceAdaptationProcessor::ResourceAdaptationProcessor( ResourceAdaptationProcessor::ResourceAdaptationProcessor(
VideoStreamAdapter* stream_adapter) VideoStreamAdapter* stream_adapter)

4
call/adaptation/resource_adaptation_processor.h
View file

@ -17,6 +17,7 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "absl/strings/string_view.h"
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/adaptation/resource.h" #include "api/adaptation/resource.h"
#include "api/rtp_parameters.h" #include "api/rtp_parameters.h"
@ -108,7 +109,8 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
struct MitigationResultAndLogMessage { struct MitigationResultAndLogMessage {
MitigationResultAndLogMessage(); MitigationResultAndLogMessage();
MitigationResultAndLogMessage(MitigationResult result, std::string message); MitigationResultAndLogMessage(MitigationResult result,
absl::string_view message);
MitigationResult result; MitigationResult result;
std::string message; std::string message;
}; };

6
call/adaptation/test/fake_adaptation_constraint.cc
View file

@ -12,10 +12,12 @@
#include <utility> #include <utility>
#include "absl/strings/string_view.h"
namespace webrtc { namespace webrtc {
FakeAdaptationConstraint::FakeAdaptationConstraint(std::string name) FakeAdaptationConstraint::FakeAdaptationConstraint(absl::string_view name)
: name_(std::move(name)), is_adaptation_up_allowed_(true) {} : name_(name), is_adaptation_up_allowed_(true) {}
FakeAdaptationConstraint::~FakeAdaptationConstraint() = default; FakeAdaptationConstraint::~FakeAdaptationConstraint() = default;

3
call/adaptation/test/fake_adaptation_constraint.h
View file

@ -13,13 +13,14 @@
#include <string> #include <string>
#include "absl/strings/string_view.h"
#include "call/adaptation/adaptation_constraint.h" #include "call/adaptation/adaptation_constraint.h"
namespace webrtc { namespace webrtc {
class FakeAdaptationConstraint : public AdaptationConstraint { class FakeAdaptationConstraint : public AdaptationConstraint {
public: public:
explicit FakeAdaptationConstraint(std::string name); explicit FakeAdaptationConstraint(absl::string_view name);
~FakeAdaptationConstraint() override; ~FakeAdaptationConstraint() override;
void set_is_adaptation_up_allowed(bool is_adaptation_up_allowed); void set_is_adaptation_up_allowed(bool is_adaptation_up_allowed);

7
call/adaptation/test/fake_resource.cc
View file

@ -13,17 +13,18 @@
#include <algorithm> #include <algorithm>
#include <utility> #include <utility>
#include "absl/strings/string_view.h"
#include "rtc_base/ref_counted_object.h" #include "rtc_base/ref_counted_object.h"
namespace webrtc { namespace webrtc {
// static // static
rtc::scoped_refptr<FakeResource> FakeResource::Create(std::string name) { rtc::scoped_refptr<FakeResource> FakeResource::Create(absl::string_view name) {
return rtc::make_ref_counted<FakeResource>(name); return rtc::make_ref_counted<FakeResource>(name);
} }
FakeResource::FakeResource(std::string name) FakeResource::FakeResource(absl::string_view name)
: Resource(), name_(std::move(name)), listener_(nullptr) {} : Resource(), name_(name), listener_(nullptr) {}
FakeResource::~FakeResource() {} FakeResource::~FakeResource() {}

5
call/adaptation/test/fake_resource.h
View file

@ -14,6 +14,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "absl/strings/string_view.h"
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/adaptation/resource.h" #include "api/adaptation/resource.h"
#include "api/scoped_refptr.h" #include "api/scoped_refptr.h"
@ -23,9 +24,9 @@ namespace webrtc {
// Fake resource used for testing. // Fake resource used for testing.
class FakeResource : public Resource { class FakeResource : public Resource {
public: public:
static rtc::scoped_refptr<FakeResource> Create(std::string name); static rtc::scoped_refptr<FakeResource> Create(absl::string_view name);
explicit FakeResource(std::string name); explicit FakeResource(absl::string_view name);
~FakeResource() override; ~FakeResource() override;
void SetUsageState(ResourceUsageState usage_state); void SetUsageState(ResourceUsageState usage_state);

3
call/bitrate_allocator_unittest.cc
View file

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "absl/strings/string_view.h"
#include "system_wrappers/include/clock.h" #include "system_wrappers/include/clock.h"
#include "test/gmock.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
@ -306,7 +307,7 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
uint32_t max_bitrate_bps, uint32_t max_bitrate_bps,
uint32_t pad_up_bitrate_bps, uint32_t pad_up_bitrate_bps,
bool enforce_min_bitrate, bool enforce_min_bitrate,
std::string track_id, absl::string_view track_id,
double bitrate_priority) { double bitrate_priority) {
allocator_->AddObserver( allocator_->AddObserver(
observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps, 0, observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps, 0,

6
call/bitrate_estimator_tests.cc
View file

@ -41,7 +41,7 @@ class LogObserver {
~LogObserver() { rtc::LogMessage::RemoveLogToStream(&callback_); } ~LogObserver() { rtc::LogMessage::RemoveLogToStream(&callback_); }
void PushExpectedLogLine(const std::string& expected_log_line) { void PushExpectedLogLine(absl::string_view expected_log_line) {
callback_.PushExpectedLogLine(expected_log_line); callback_.PushExpectedLogLine(expected_log_line);
} }
@ -83,9 +83,9 @@ class LogObserver {
bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeoutMs); } bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeoutMs); }
void PushExpectedLogLine(const std::string& expected_log_line) { void PushExpectedLogLine(absl::string_view expected_log_line) {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
expected_log_lines_.push_back(expected_log_line); expected_log_lines_.emplace_back(expected_log_line);
} }
private: private:

13
call/call.cc
View file

@ -21,6 +21,7 @@
#include <vector> #include <vector>
#include "absl/functional/bind_front.h" #include "absl/functional/bind_front.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/rtc_event_log/rtc_event_log.h" #include "api/rtc_event_log/rtc_event_log.h"
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
@ -272,7 +273,7 @@ class Call final : public webrtc::Call,
uint32_t local_ssrc) override; uint32_t local_ssrc) override;
void OnUpdateSyncGroup(webrtc::AudioReceiveStream& stream, void OnUpdateSyncGroup(webrtc::AudioReceiveStream& stream,
const std::string& sync_group) override; absl::string_view sync_group) override;
void OnSentPacket(const rtc::SentPacket& sent_packet) override; void OnSentPacket(const rtc::SentPacket& sent_packet) override;
@ -349,9 +350,9 @@ class Call final : public webrtc::Call,
rtc::CopyOnWriteBuffer packet, rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) RTC_RUN_ON(worker_thread_); int64_t packet_time_us) RTC_RUN_ON(worker_thread_);
AudioReceiveStream* FindAudioStreamForSyncGroup(const std::string& sync_group) AudioReceiveStream* FindAudioStreamForSyncGroup(absl::string_view sync_group)
RTC_RUN_ON(worker_thread_); RTC_RUN_ON(worker_thread_);
void ConfigureSync(const std::string& sync_group) RTC_RUN_ON(worker_thread_); void ConfigureSync(absl::string_view sync_group) RTC_RUN_ON(worker_thread_);
void NotifyBweOfReceivedPacket(const RtpPacketReceived& packet, void NotifyBweOfReceivedPacket(const RtpPacketReceived& packet,
MediaType media_type, MediaType media_type,
@ -1403,7 +1404,7 @@ void Call::OnLocalSsrcUpdated(FlexfecReceiveStream& stream,
} }
void Call::OnUpdateSyncGroup(webrtc::AudioReceiveStream& stream, void Call::OnUpdateSyncGroup(webrtc::AudioReceiveStream& stream,
const std::string& sync_group) { absl::string_view sync_group) {
RTC_DCHECK_RUN_ON(worker_thread_); RTC_DCHECK_RUN_ON(worker_thread_);
webrtc::internal::AudioReceiveStream& receive_stream = webrtc::internal::AudioReceiveStream& receive_stream =
static_cast<webrtc::internal::AudioReceiveStream&>(stream); static_cast<webrtc::internal::AudioReceiveStream&>(stream);
@ -1476,7 +1477,7 @@ void Call::OnAllocationLimitsChanged(BitrateAllocationLimits limits) {
// RTC_RUN_ON(worker_thread_) // RTC_RUN_ON(worker_thread_)
AudioReceiveStream* Call::FindAudioStreamForSyncGroup( AudioReceiveStream* Call::FindAudioStreamForSyncGroup(
const std::string& sync_group) { absl::string_view sync_group) {
RTC_DCHECK_RUN_ON(&receive_11993_checker_); RTC_DCHECK_RUN_ON(&receive_11993_checker_);
if (!sync_group.empty()) { if (!sync_group.empty()) {
for (AudioReceiveStream* stream : audio_receive_streams_) { for (AudioReceiveStream* stream : audio_receive_streams_) {
@ -1490,7 +1491,7 @@ AudioReceiveStream* Call::FindAudioStreamForSyncGroup(
// TODO(bugs.webrtc.org/11993): Expect to be called on the network thread. // TODO(bugs.webrtc.org/11993): Expect to be called on the network thread.
// RTC_RUN_ON(worker_thread_) // RTC_RUN_ON(worker_thread_)
void Call::ConfigureSync(const std::string& sync_group) { void Call::ConfigureSync(absl::string_view sync_group) {
// `audio_stream` may be nullptr when clearing the audio stream for a group. // `audio_stream` may be nullptr when clearing the audio stream for a group.
AudioReceiveStream* audio_stream = FindAudioStreamForSyncGroup(sync_group); AudioReceiveStream* audio_stream = FindAudioStreamForSyncGroup(sync_group);

3
call/call.h
View file

@ -15,6 +15,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "absl/strings/string_view.h"
#include "api/adaptation/resource.h" #include "api/adaptation/resource.h"
#include "api/media_types.h" #include "api/media_types.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
@ -171,7 +172,7 @@ class Call {
uint32_t local_ssrc) = 0; uint32_t local_ssrc) = 0;
virtual void OnUpdateSyncGroup(AudioReceiveStream& stream, virtual void OnUpdateSyncGroup(AudioReceiveStream& stream,
const std::string& sync_group) = 0; absl::string_view sync_group) = 0;
virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0; virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0;

13
call/call_perf_tests.cc
View file

@ -13,6 +13,7 @@
#include <memory> #include <memory>
#include <string> #include <string>
#include "absl/strings/string_view.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h" #include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/rtc_event_log/rtc_event_log.h" #include "api/rtc_event_log/rtc_event_log.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
@ -76,7 +77,7 @@ class CallPerfTest : public test::CallTest {
float video_ntp_speed, float video_ntp_speed,
float video_rtp_speed, float video_rtp_speed,
float audio_rtp_speed, float audio_rtp_speed,
const std::string& test_label); absl::string_view test_label);
void TestMinTransmitBitrate(bool pad_to_min_bitrate); void TestMinTransmitBitrate(bool pad_to_min_bitrate);
@ -91,7 +92,7 @@ class CallPerfTest : public test::CallTest {
int start_bwe, int start_bwe,
int max_bwe); int max_bwe);
void TestEncodeFramerate(VideoEncoderFactory* encoder_factory, void TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
const std::string& payload_name, absl::string_view payload_name,
const std::vector<int>& max_framerates); const std::vector<int>& max_framerates);
}; };
@ -104,7 +105,7 @@ class VideoRtcpAndSyncObserver : public test::RtpRtcpObserver,
public: public:
explicit VideoRtcpAndSyncObserver(TaskQueueBase* task_queue, explicit VideoRtcpAndSyncObserver(TaskQueueBase* task_queue,
Clock* clock, Clock* clock,
const std::string& test_label) absl::string_view test_label)
: test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs), : test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs),
clock_(clock), clock_(clock),
test_label_(test_label), test_label_(test_label),
@ -169,7 +170,7 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
float video_ntp_speed, float video_ntp_speed,
float video_rtp_speed, float video_rtp_speed,
float audio_rtp_speed, float audio_rtp_speed,
const std::string& test_label) { absl::string_view test_label) {
const char* kSyncGroup = "av_sync"; const char* kSyncGroup = "av_sync";
const uint32_t kAudioSendSsrc = 1234; const uint32_t kAudioSendSsrc = 1234;
const uint32_t kAudioRecvSsrc = 5678; const uint32_t kAudioRecvSsrc = 5678;
@ -1055,7 +1056,7 @@ TEST_F(CallPerfTest, MAYBE_Min_Bitrate_VideoAndAudio) {
} }
void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory, void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
const std::string& payload_name, absl::string_view payload_name,
const std::vector<int>& max_framerates) { const std::vector<int>& max_framerates) {
static constexpr double kAllowedFpsDiff = 1.5; static constexpr double kAllowedFpsDiff = 1.5;
static constexpr TimeDelta kMinGetStatsInterval = TimeDelta::Millis(400); static constexpr TimeDelta kMinGetStatsInterval = TimeDelta::Millis(400);
@ -1067,7 +1068,7 @@ void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
public test::FrameGeneratorCapturer::SinkWantsObserver { public test::FrameGeneratorCapturer::SinkWantsObserver {
public: public:
FramerateObserver(VideoEncoderFactory* encoder_factory, FramerateObserver(VideoEncoderFactory* encoder_factory,
const std::string& payload_name, absl::string_view payload_name,
const std::vector<int>& max_framerates, const std::vector<int>& max_framerates,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeoutMs),

5
call/call_unittest.cc
View file

@ -16,6 +16,7 @@
#include <utility> #include <utility>
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "absl/strings/string_view.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h" #include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/rtc_event_log/rtc_event_log.h" #include "api/rtc_event_log/rtc_event_log.h"
#include "api/task_queue/default_task_queue_factory.h" #include "api/task_queue/default_task_queue_factory.h"
@ -82,9 +83,9 @@ namespace {
rtc::scoped_refptr<Resource> FindResourceWhoseNameContains( rtc::scoped_refptr<Resource> FindResourceWhoseNameContains(
const std::vector<rtc::scoped_refptr<Resource>>& resources, const std::vector<rtc::scoped_refptr<Resource>>& resources,
const std::string& name_contains) { absl::string_view name_contains) {
for (const auto& resource : resources) { for (const auto& resource : resources) {
if (resource->Name().find(name_contains) != std::string::npos) if (resource->Name().find(std::string(name_contains)) != std::string::npos)
return resource; return resource;
} }
return nullptr; return nullptr;

3
call/degraded_call.cc
View file

@ -13,6 +13,7 @@
#include <memory> #include <memory>
#include <utility> #include <utility>
#include "absl/strings/string_view.h"
#include "rtc_base/location.h" #include "rtc_base/location.h"
namespace webrtc { namespace webrtc {
@ -315,7 +316,7 @@ void DegradedCall::OnLocalSsrcUpdated(FlexfecReceiveStream& stream,
} }
void DegradedCall::OnUpdateSyncGroup(AudioReceiveStream& stream, void DegradedCall::OnUpdateSyncGroup(AudioReceiveStream& stream,
const std::string& sync_group) { absl::string_view sync_group) {
call_->OnUpdateSyncGroup(stream, sync_group); call_->OnUpdateSyncGroup(stream, sync_group);
} }

3
call/degraded_call.h
View file

@ -19,6 +19,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "absl/strings/string_view.h"
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/call/transport.h" #include "api/call/transport.h"
#include "api/fec_controller.h" #include "api/fec_controller.h"
@ -105,7 +106,7 @@ class DegradedCall : public Call, private PacketReceiver {
void OnLocalSsrcUpdated(FlexfecReceiveStream& stream, void OnLocalSsrcUpdated(FlexfecReceiveStream& stream,
uint32_t local_ssrc) override; uint32_t local_ssrc) override;
void OnUpdateSyncGroup(AudioReceiveStream& stream, void OnUpdateSyncGroup(AudioReceiveStream& stream,
const std::string& sync_group) override; absl::string_view sync_group) override;
void OnSentPacket(const rtc::SentPacket& sent_packet) override; void OnSentPacket(const rtc::SentPacket& sent_packet) override;
protected: protected:

9
call/rampup_tests.cc
View file

@ -13,6 +13,7 @@
#include <memory> #include <memory>
#include "absl/flags/flag.h" #include "absl/flags/flag.h"
#include "absl/strings/string_view.h"
#include "api/rtc_event_log/rtc_event_log_factory.h" #include "api/rtc_event_log/rtc_event_log_factory.h"
#include "api/rtc_event_log_output_file.h" #include "api/rtc_event_log_output_file.h"
#include "api/task_queue/default_task_queue_factory.h" #include "api/task_queue/default_task_queue_factory.h"
@ -58,7 +59,7 @@ RampUpTester::RampUpTester(size_t num_video_streams,
size_t num_flexfec_streams, size_t num_flexfec_streams,
unsigned int start_bitrate_bps, unsigned int start_bitrate_bps,
int64_t min_run_time_ms, int64_t min_run_time_ms,
const std::string& extension_type, absl::string_view extension_type,
bool rtx, bool rtx,
bool red, bool red,
bool report_perf_stats, bool report_perf_stats,
@ -329,9 +330,9 @@ void RampUpTester::PollStats() {
} }
void RampUpTester::ReportResult( void RampUpTester::ReportResult(
const std::string& measurement, absl::string_view measurement,
size_t value, size_t value,
const std::string& units, absl::string_view units,
test::ImproveDirection improve_direction) const { test::ImproveDirection improve_direction) const {
webrtc::test::PrintResult( webrtc::test::PrintResult(
measurement, "", measurement, "",
@ -420,7 +421,7 @@ RampUpDownUpTester::RampUpDownUpTester(size_t num_video_streams,
size_t num_audio_streams, size_t num_audio_streams,
size_t num_flexfec_streams, size_t num_flexfec_streams,
unsigned int start_bitrate_bps, unsigned int start_bitrate_bps,
const std::string& extension_type, absl::string_view extension_type,
bool rtx, bool rtx,
bool red, bool red,
const std::vector<int>& loss_rates, const std::vector<int>& loss_rates,

9
call/rampup_tests.h
View file

@ -17,6 +17,7 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "absl/strings/string_view.h"
#include "api/rtc_event_log/rtc_event_log.h" #include "api/rtc_event_log/rtc_event_log.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h" #include "api/test/simulated_network.h"
@ -43,7 +44,7 @@ class RampUpTester : public test::EndToEndTest {
size_t num_flexfec_streams, size_t num_flexfec_streams,
unsigned int start_bitrate_bps, unsigned int start_bitrate_bps,
int64_t min_run_time_ms, int64_t min_run_time_ms,
const std::string& extension_type, absl::string_view extension_type,
bool rtx, bool rtx,
bool red, bool red,
bool report_perf_stats, bool report_perf_stats,
@ -65,9 +66,9 @@ class RampUpTester : public test::EndToEndTest {
size_t* padding_sent, size_t* padding_sent,
size_t* media_sent) const; size_t* media_sent) const;
void ReportResult(const std::string& measurement, void ReportResult(absl::string_view measurement,
size_t value, size_t value,
const std::string& units, absl::string_view units,
test::ImproveDirection improve_direction) const; test::ImproveDirection improve_direction) const;
void TriggerTestDone(); void TriggerTestDone();
@ -128,7 +129,7 @@ class RampUpDownUpTester : public RampUpTester {
size_t num_audio_streams, size_t num_audio_streams,
size_t num_flexfec_streams, size_t num_flexfec_streams,
unsigned int start_bitrate_bps, unsigned int start_bitrate_bps,
const std::string& extension_type, absl::string_view extension_type,
bool rtx, bool rtx,
bool red, bool red,
const std::vector<int>& loss_rates, const std::vector<int>& loss_rates,

16
call/rtp_demuxer.cc
View file

@ -10,6 +10,7 @@
#include "call/rtp_demuxer.h" #include "call/rtp_demuxer.h"
#include "absl/strings/string_view.h"
#include "call/rtp_packet_sink_interface.h" #include "call/rtp_packet_sink_interface.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h" #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "modules/rtp_rtcp/source/rtp_packet_received.h"
@ -238,8 +239,7 @@ bool RtpDemuxer::AddSink(uint32_t ssrc, RtpPacketSinkInterface* sink) {
return AddSink(criteria, sink); return AddSink(criteria, sink);
} }
void RtpDemuxer::AddSink(const std::string& rsid, void RtpDemuxer::AddSink(absl::string_view rsid, RtpPacketSinkInterface* sink) {
RtpPacketSinkInterface* sink) {
RtpDemuxerCriteria criteria(absl::string_view() /* mid */, rsid); RtpDemuxerCriteria criteria(absl::string_view() /* mid */, rsid);
AddSink(criteria, sink); AddSink(criteria, sink);
} }
@ -363,7 +363,7 @@ RtpPacketSinkInterface* RtpDemuxer::ResolveSink(
return ResolveSinkByPayloadType(packet.PayloadType(), ssrc); return ResolveSinkByPayloadType(packet.PayloadType(), ssrc);
} }
RtpPacketSinkInterface* RtpDemuxer::ResolveSinkByMid(const std::string& mid, RtpPacketSinkInterface* RtpDemuxer::ResolveSinkByMid(absl::string_view mid,
uint32_t ssrc) { uint32_t ssrc) {
const auto it = sink_by_mid_.find(mid); const auto it = sink_by_mid_.find(mid);
if (it != sink_by_mid_.end()) { if (it != sink_by_mid_.end()) {
@ -374,11 +374,11 @@ RtpPacketSinkInterface* RtpDemuxer::ResolveSinkByMid(const std::string& mid,
return nullptr; return nullptr;
} }
RtpPacketSinkInterface* RtpDemuxer::ResolveSinkByMidRsid( RtpPacketSinkInterface* RtpDemuxer::ResolveSinkByMidRsid(absl::string_view mid,
const std::string& mid, absl::string_view rsid,
const std::string& rsid,
uint32_t ssrc) { uint32_t ssrc) {
const auto it = sink_by_mid_and_rsid_.find(std::make_pair(mid, rsid)); const auto it = sink_by_mid_and_rsid_.find(
std::make_pair(std::string(mid), std::string(rsid)));
if (it != sink_by_mid_and_rsid_.end()) { if (it != sink_by_mid_and_rsid_.end()) {
RtpPacketSinkInterface* sink = it->second; RtpPacketSinkInterface* sink = it->second;
AddSsrcSinkBinding(ssrc, sink); AddSsrcSinkBinding(ssrc, sink);
@ -387,7 +387,7 @@ RtpPacketSinkInterface* RtpDemuxer::ResolveSinkByMidRsid(
return nullptr; return nullptr;
} }
RtpPacketSinkInterface* RtpDemuxer::ResolveSinkByRsid(const std::string& rsid, RtpPacketSinkInterface* RtpDemuxer::ResolveSinkByRsid(absl::string_view rsid,
uint32_t ssrc) { uint32_t ssrc) {
const auto it = sink_by_rsid_.find(rsid); const auto it = sink_by_rsid_.find(rsid);
if (it != sink_by_rsid_.end()) { if (it != sink_by_rsid_.end()) {

10
call/rtp_demuxer.h
View file

@ -145,7 +145,7 @@ class RtpDemuxer {
// Registers a sink's association to an RSID. Only one sink may be associated // Registers a sink's association to an RSID. Only one sink may be associated
// with a given RSID. Null pointer is not allowed. // with a given RSID. Null pointer is not allowed.
void AddSink(const std::string& rsid, RtpPacketSinkInterface* sink); void AddSink(absl::string_view rsid, RtpPacketSinkInterface* sink);
// Removes a sink. Return value reports if anything was actually removed. // Removes a sink. Return value reports if anything was actually removed.
// Null pointer is not allowed. // Null pointer is not allowed.
@ -167,12 +167,12 @@ class RtpDemuxer {
RtpPacketSinkInterface* ResolveSink(const RtpPacketReceived& packet); RtpPacketSinkInterface* ResolveSink(const RtpPacketReceived& packet);
// Used by the ResolveSink algorithm. // Used by the ResolveSink algorithm.
RtpPacketSinkInterface* ResolveSinkByMid(const std::string& mid, RtpPacketSinkInterface* ResolveSinkByMid(absl::string_view mid,
uint32_t ssrc); uint32_t ssrc);
RtpPacketSinkInterface* ResolveSinkByMidRsid(const std::string& mid, RtpPacketSinkInterface* ResolveSinkByMidRsid(absl::string_view mid,
const std::string& rsid, absl::string_view rsid,
uint32_t ssrc); uint32_t ssrc);
RtpPacketSinkInterface* ResolveSinkByRsid(const std::string& rsid, RtpPacketSinkInterface* ResolveSinkByRsid(absl::string_view rsid,
uint32_t ssrc); uint32_t ssrc);
RtpPacketSinkInterface* ResolveSinkByPayloadType(uint8_t payload_type, RtpPacketSinkInterface* ResolveSinkByPayloadType(uint8_t payload_type,
uint32_t ssrc); uint32_t ssrc);

23
call/rtp_demuxer_unittest.cc
View file

@ -14,6 +14,7 @@
#include <set> #include <set>
#include <string> #include <string>
#include "absl/strings/string_view.h"
#include "call/test/mock_rtp_packet_sink_interface.h" #include "call/test/mock_rtp_packet_sink_interface.h"
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h" #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h" #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
@ -60,18 +61,18 @@ class RtpDemuxerTest : public ::testing::Test {
return AddSink(criteria, sink); return AddSink(criteria, sink);
} }
bool AddSinkOnlyRsid(const std::string& rsid, RtpPacketSinkInterface* sink) { bool AddSinkOnlyRsid(absl::string_view rsid, RtpPacketSinkInterface* sink) {
RtpDemuxerCriteria criteria(absl::string_view(), rsid); RtpDemuxerCriteria criteria(absl::string_view(), rsid);
return AddSink(criteria, sink); return AddSink(criteria, sink);
} }
bool AddSinkOnlyMid(const std::string& mid, RtpPacketSinkInterface* sink) { bool AddSinkOnlyMid(absl::string_view mid, RtpPacketSinkInterface* sink) {
RtpDemuxerCriteria criteria(mid); RtpDemuxerCriteria criteria(mid);
return AddSink(criteria, sink); return AddSink(criteria, sink);
} }
bool AddSinkBothMidRsid(const std::string& mid, bool AddSinkBothMidRsid(absl::string_view mid,
const std::string& rsid, absl::string_view rsid,
RtpPacketSinkInterface* sink) { RtpPacketSinkInterface* sink) {
RtpDemuxerCriteria criteria(mid, rsid); RtpDemuxerCriteria criteria(mid, rsid);
return AddSink(criteria, sink); return AddSink(criteria, sink);
@ -110,7 +111,7 @@ class RtpDemuxerTest : public ::testing::Test {
std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcMid( std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcMid(
uint32_t ssrc, uint32_t ssrc,
const std::string& mid) { absl::string_view mid) {
RtpPacketReceived::ExtensionManager extension_manager; RtpPacketReceived::ExtensionManager extension_manager;
extension_manager.Register<RtpMid>(11); extension_manager.Register<RtpMid>(11);
@ -121,7 +122,7 @@ class RtpDemuxerTest : public ::testing::Test {
std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcRsid( std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcRsid(
uint32_t ssrc, uint32_t ssrc,
const std::string& rsid) { absl::string_view rsid) {
RtpPacketReceived::ExtensionManager extension_manager; RtpPacketReceived::ExtensionManager extension_manager;
extension_manager.Register<RtpStreamId>(6); extension_manager.Register<RtpStreamId>(6);
@ -132,7 +133,7 @@ class RtpDemuxerTest : public ::testing::Test {
std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcRrid( std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcRrid(
uint32_t ssrc, uint32_t ssrc,
const std::string& rrid) { absl::string_view rrid) {
RtpPacketReceived::ExtensionManager extension_manager; RtpPacketReceived::ExtensionManager extension_manager;
extension_manager.Register<RepairedRtpStreamId>(7); extension_manager.Register<RepairedRtpStreamId>(7);
@ -143,8 +144,8 @@ class RtpDemuxerTest : public ::testing::Test {
std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcMidRsid( std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcMidRsid(
uint32_t ssrc, uint32_t ssrc,
const std::string& mid, absl::string_view mid,
const std::string& rsid) { absl::string_view rsid) {
RtpPacketReceived::ExtensionManager extension_manager; RtpPacketReceived::ExtensionManager extension_manager;
extension_manager.Register<RtpMid>(11); extension_manager.Register<RtpMid>(11);
extension_manager.Register<RtpStreamId>(6); extension_manager.Register<RtpStreamId>(6);
@ -157,8 +158,8 @@ class RtpDemuxerTest : public ::testing::Test {
std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcRsidRrid( std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcRsidRrid(
uint32_t ssrc, uint32_t ssrc,
const std::string& rsid, absl::string_view rsid,
const std::string& rrid) { absl::string_view rrid) {
RtpPacketReceived::ExtensionManager extension_manager; RtpPacketReceived::ExtensionManager extension_manager;
extension_manager.Register<RtpStreamId>(6); extension_manager.Register<RtpStreamId>(6);
extension_manager.Register<RepairedRtpStreamId>(7); extension_manager.Register<RepairedRtpStreamId>(7);

3
call/rtp_transport_controller_send.cc
View file

@ -14,6 +14,7 @@
#include <vector> #include <vector>
#include "absl/strings/match.h" #include "absl/strings/match.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/transport/goog_cc_factory.h" #include "api/transport/goog_cc_factory.h"
#include "api/transport/network_types.h" #include "api/transport/network_types.h"
@ -270,7 +271,7 @@ bool RtpTransportControllerSend::IsRelevantRouteChange(
} }
void RtpTransportControllerSend::OnNetworkRouteChanged( void RtpTransportControllerSend::OnNetworkRouteChanged(
const std::string& transport_name, absl::string_view transport_name,
const rtc::NetworkRoute& network_route) { const rtc::NetworkRoute& network_route) {
// Check if the network route is connected. // Check if the network route is connected.

3
call/rtp_transport_controller_send.h
View file

@ -17,6 +17,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "absl/strings/string_view.h"
#include "api/network_state_predictor.h" #include "api/network_state_predictor.h"
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/transport/network_control.h" #include "api/transport/network_control.h"
@ -94,7 +95,7 @@ class RtpTransportControllerSend final
StreamFeedbackProvider* GetStreamFeedbackProvider() override; StreamFeedbackProvider* GetStreamFeedbackProvider() override;
void RegisterTargetTransferRateObserver( void RegisterTargetTransferRateObserver(
TargetTransferRateObserver* observer) override; TargetTransferRateObserver* observer) override;
void OnNetworkRouteChanged(const std::string& transport_name, void OnNetworkRouteChanged(absl::string_view transport_name,
const rtc::NetworkRoute& network_route) override; const rtc::NetworkRoute& network_route) override;
void OnNetworkAvailability(bool network_available) override; void OnNetworkAvailability(bool network_available) override;
RtcpBandwidthObserver* GetBandwidthObserver() override; RtcpBandwidthObserver* GetBandwidthObserver() override;

3
call/rtp_transport_controller_send_interface.h
View file

@ -18,6 +18,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "absl/strings/string_view.h"
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/crypto/crypto_options.h" #include "api/crypto/crypto_options.h"
#include "api/fec_controller.h" #include "api/fec_controller.h"
@ -127,7 +128,7 @@ class RtpTransportControllerSendInterface {
virtual void RegisterTargetTransferRateObserver( virtual void RegisterTargetTransferRateObserver(
TargetTransferRateObserver* observer) = 0; TargetTransferRateObserver* observer) = 0;
virtual void OnNetworkRouteChanged( virtual void OnNetworkRouteChanged(
const std::string& transport_name, absl::string_view transport_name,
const rtc::NetworkRoute& network_route) = 0; const rtc::NetworkRoute& network_route) = 0;
virtual void OnNetworkAvailability(bool network_available) = 0; virtual void OnNetworkAvailability(bool network_available) = 0;
virtual RtcpBandwidthObserver* GetBandwidthObserver() = 0; virtual RtcpBandwidthObserver* GetBandwidthObserver() = 0;

6
call/rtp_video_sender.cc
View file

@ -17,6 +17,7 @@
#include "absl/algorithm/container.h" #include "absl/algorithm/container.h"
#include "absl/strings/match.h" #include "absl/strings/match.h"
#include "absl/strings/string_view.h"
#include "api/array_view.h" #include "api/array_view.h"
#include "api/transport/field_trial_based_config.h" #include "api/transport/field_trial_based_config.h"
#include "api/video_codecs/video_codec.h" #include "api/video_codecs/video_codec.h"
@ -55,9 +56,10 @@ static const size_t kPathMTU = 1500;
using webrtc_internal_rtp_video_sender::RtpStreamSender; using webrtc_internal_rtp_video_sender::RtpStreamSender;
bool PayloadTypeSupportsSkippingFecPackets(const std::string& payload_name, bool PayloadTypeSupportsSkippingFecPackets(absl::string_view payload_name,
const FieldTrialsView& trials) { const FieldTrialsView& trials) {
const VideoCodecType codecType = PayloadStringToCodecType(payload_name); const VideoCodecType codecType =
PayloadStringToCodecType(std::string(payload_name));
if (codecType == kVideoCodecVP8 || codecType == kVideoCodecVP9) { if (codecType == kVideoCodecVP8 || codecType == kVideoCodecVP9) {
return true; return true;
} }

3
call/test/mock_rtp_transport_controller_send.h
View file

@ -16,6 +16,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "absl/strings/string_view.h"
#include "api/crypto/crypto_options.h" #include "api/crypto/crypto_options.h"
#include "api/crypto/frame_encryptor_interface.h" #include "api/crypto/frame_encryptor_interface.h"
#include "api/frame_transformer_interface.h" #include "api/frame_transformer_interface.h"
@ -76,7 +77,7 @@ class MockRtpTransportControllerSend
(override)); (override));
MOCK_METHOD(void, MOCK_METHOD(void,
OnNetworkRouteChanged, OnNetworkRouteChanged,
(const std::string&, const rtc::NetworkRoute&), (absl::string_view, const rtc::NetworkRoute&),
(override)); (override));
MOCK_METHOD(void, OnNetworkAvailability, (bool), (override)); MOCK_METHOD(void, OnNetworkAvailability, (bool), (override));
MOCK_METHOD(RtcpBandwidthObserver*, GetBandwidthObserver, (), (override)); MOCK_METHOD(RtcpBandwidthObserver*, GetBandwidthObserver, (), (override));

3
media/engine/fake_webrtc_call.cc
View file

@ -13,6 +13,7 @@
#include <utility> #include <utility>
#include "absl/algorithm/container.h" #include "absl/algorithm/container.h"
#include "absl/strings/string_view.h"
#include "api/call/audio_sink.h" #include "api/call/audio_sink.h"
#include "modules/rtp_rtcp/source/rtp_util.h" #include "modules/rtp_rtcp/source/rtp_util.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
@ -728,7 +729,7 @@ void FakeCall::OnLocalSsrcUpdated(webrtc::FlexfecReceiveStream& stream,
} }
void FakeCall::OnUpdateSyncGroup(webrtc::AudioReceiveStream& stream, void FakeCall::OnUpdateSyncGroup(webrtc::AudioReceiveStream& stream,
const std::string& sync_group) { absl::string_view sync_group) {
auto& fake_stream = static_cast<FakeAudioReceiveStream&>(stream); auto& fake_stream = static_cast<FakeAudioReceiveStream&>(stream);
fake_stream.SetSyncGroup(sync_group); fake_stream.SetSyncGroup(sync_group);
} }

7
media/engine/fake_webrtc_call.h
View file

@ -25,6 +25,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "absl/strings/string_view.h"
#include "api/transport/field_trial_based_config.h" #include "api/transport/field_trial_based_config.h"
#include "api/video/video_frame.h" #include "api/video/video_frame.h"
#include "call/audio_receive_stream.h" #include "call/audio_receive_stream.h"
@ -105,8 +106,8 @@ class FakeAudioReceiveStream final : public webrtc::AudioReceiveStream {
config_.rtp.local_ssrc = local_ssrc; config_.rtp.local_ssrc = local_ssrc;
} }
void SetSyncGroup(const std::string& sync_group) { void SetSyncGroup(absl::string_view sync_group) {
config_.sync_group = sync_group; config_.sync_group = std::string(sync_group);
} }
private: private:
@ -424,7 +425,7 @@ class FakeCall final : public webrtc::Call, public webrtc::PacketReceiver {
void OnLocalSsrcUpdated(webrtc::FlexfecReceiveStream& stream, void OnLocalSsrcUpdated(webrtc::FlexfecReceiveStream& stream,
uint32_t local_ssrc) override; uint32_t local_ssrc) override;
void OnUpdateSyncGroup(webrtc::AudioReceiveStream& stream, void OnUpdateSyncGroup(webrtc::AudioReceiveStream& stream,
const std::string& sync_group) override; absl::string_view sync_group) override;
void OnSentPacket(const rtc::SentPacket& sent_packet) override; void OnSentPacket(const rtc::SentPacket& sent_packet) override;
webrtc::TaskQueueBase* const network_thread_; webrtc::TaskQueueBase* const network_thread_;