Use webrtc name specifier instead of rtc/cricket in call
WebRTC has unified all namespaces to webrtc, and the rtc:: and cricket::
name specifiers need to be replaced with webrtc::. This was generated using
a combination of clang AST rewriting tools and sed.
This CL was uploaded by git cl split.
Bug: webrtc:42232595
Change-Id: I640a0ab40aa215fe41650d7de7974d65f5fb4f7b
No-Iwyu: LSC
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/386660
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44399}
diff --git a/call/adaptation/broadcast_resource_listener.cc b/call/adaptation/broadcast_resource_listener.cc
index 9a29426..5305964 100644
--- a/call/adaptation/broadcast_resource_listener.cc
+++ b/call/adaptation/broadcast_resource_listener.cc
@@ -37,7 +37,7 @@
MutexLock lock(&lock_);
if (!listener_)
return;
- listener_->OnResourceUsageStateMeasured(rtc::scoped_refptr<Resource>(this),
+ listener_->OnResourceUsageStateMeasured(scoped_refptr<Resource>(this),
usage_state);
}
@@ -56,7 +56,7 @@
};
BroadcastResourceListener::BroadcastResourceListener(
- rtc::scoped_refptr<Resource> source_resource)
+ scoped_refptr<Resource> source_resource)
: source_resource_(source_resource), is_listening_(false) {
RTC_DCHECK(source_resource_);
}
@@ -65,7 +65,7 @@
RTC_DCHECK(!is_listening_);
}
-rtc::scoped_refptr<Resource> BroadcastResourceListener::SourceResource() const {
+scoped_refptr<Resource> BroadcastResourceListener::SourceResource() const {
return source_resource_;
}
@@ -84,28 +84,26 @@
is_listening_ = false;
}
-rtc::scoped_refptr<Resource>
-BroadcastResourceListener::CreateAdapterResource() {
+scoped_refptr<Resource> BroadcastResourceListener::CreateAdapterResource() {
MutexLock lock(&lock_);
RTC_DCHECK(is_listening_);
- rtc::scoped_refptr<AdapterResource> adapter =
- rtc::make_ref_counted<AdapterResource>(source_resource_->Name() +
- "Adapter");
+ scoped_refptr<AdapterResource> adapter =
+ make_ref_counted<AdapterResource>(source_resource_->Name() + "Adapter");
adapters_.push_back(adapter);
return adapter;
}
void BroadcastResourceListener::RemoveAdapterResource(
- rtc::scoped_refptr<Resource> resource) {
+ scoped_refptr<Resource> resource) {
MutexLock lock(&lock_);
auto it = std::find(adapters_.begin(), adapters_.end(), resource);
RTC_DCHECK(it != adapters_.end());
adapters_.erase(it);
}
-std::vector<rtc::scoped_refptr<Resource>>
+std::vector<scoped_refptr<Resource>>
BroadcastResourceListener::GetAdapterResources() {
- std::vector<rtc::scoped_refptr<Resource>> resources;
+ std::vector<scoped_refptr<Resource>> resources;
MutexLock lock(&lock_);
for (const auto& adapter : adapters_) {
resources.push_back(adapter);
@@ -114,7 +112,7 @@
}
void BroadcastResourceListener::OnResourceUsageStateMeasured(
- rtc::scoped_refptr<Resource> resource,
+ scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
RTC_DCHECK_EQ(resource, source_resource_);
MutexLock lock(&lock_);
diff --git a/call/adaptation/broadcast_resource_listener.h b/call/adaptation/broadcast_resource_listener.h
index 2c11560..9d4ae70 100644
--- a/call/adaptation/broadcast_resource_listener.h
+++ b/call/adaptation/broadcast_resource_listener.h
@@ -36,39 +36,37 @@
// and DCHECK that a Resource's listener is never overwritten.
class BroadcastResourceListener : public ResourceListener {
public:
- explicit BroadcastResourceListener(
- rtc::scoped_refptr<Resource> source_resource);
+ explicit BroadcastResourceListener(scoped_refptr<Resource> source_resource);
~BroadcastResourceListener() override;
- rtc::scoped_refptr<Resource> SourceResource() const;
+ scoped_refptr<Resource> SourceResource() const;
void StartListening();
void StopListening();
// Creates a Resource that redirects any resource usage measurements that
// BroadcastResourceListener receives to its listener.
- rtc::scoped_refptr<Resource> CreateAdapterResource();
+ scoped_refptr<Resource> CreateAdapterResource();
// Unregister the adapter from the BroadcastResourceListener; it will no
// longer receive resource usage measurement and will no longer be referenced.
// Use this to prevent memory leaks of old adapters.
- void RemoveAdapterResource(rtc::scoped_refptr<Resource> resource);
- std::vector<rtc::scoped_refptr<Resource>> GetAdapterResources();
+ void RemoveAdapterResource(scoped_refptr<Resource> resource);
+ std::vector<scoped_refptr<Resource>> GetAdapterResources();
// ResourceListener implementation.
- void OnResourceUsageStateMeasured(rtc::scoped_refptr<Resource> resource,
+ void OnResourceUsageStateMeasured(scoped_refptr<Resource> resource,
ResourceUsageState usage_state) override;
private:
class AdapterResource;
friend class AdapterResource;
- const rtc::scoped_refptr<Resource> source_resource_;
+ const scoped_refptr<Resource> source_resource_;
Mutex lock_;
bool is_listening_ RTC_GUARDED_BY(lock_);
// The AdapterResource unregisters itself prior to destruction, guaranteeing
// that these pointers are safe to use.
- std::vector<rtc::scoped_refptr<AdapterResource>> adapters_
- RTC_GUARDED_BY(lock_);
+ std::vector<scoped_refptr<AdapterResource>> adapters_ RTC_GUARDED_BY(lock_);
};
} // namespace webrtc
diff --git a/call/adaptation/broadcast_resource_listener_unittest.cc b/call/adaptation/broadcast_resource_listener_unittest.cc
index c7d5f46..124a83f 100644
--- a/call/adaptation/broadcast_resource_listener_unittest.cc
+++ b/call/adaptation/broadcast_resource_listener_unittest.cc
@@ -25,17 +25,17 @@
using ::testing::StrictMock;
TEST(BroadcastResourceListenerTest, CreateAndRemoveAdapterResource) {
- rtc::scoped_refptr<FakeResource> source_resource =
+ scoped_refptr<FakeResource> source_resource =
FakeResource::Create("SourceResource");
BroadcastResourceListener broadcast_resource_listener(source_resource);
broadcast_resource_listener.StartListening();
EXPECT_TRUE(broadcast_resource_listener.GetAdapterResources().empty());
- rtc::scoped_refptr<Resource> adapter =
+ scoped_refptr<Resource> adapter =
broadcast_resource_listener.CreateAdapterResource();
StrictMock<MockResourceListener> listener;
adapter->SetResourceListener(&listener);
- EXPECT_EQ(std::vector<rtc::scoped_refptr<Resource>>{adapter},
+ EXPECT_EQ(std::vector<scoped_refptr<Resource>>{adapter},
broadcast_resource_listener.GetAdapterResources());
// The removed adapter is not referenced by the broadcaster.
@@ -50,12 +50,12 @@
}
TEST(BroadcastResourceListenerTest, AdapterNameIsBasedOnSourceResourceName) {
- rtc::scoped_refptr<FakeResource> source_resource =
+ scoped_refptr<FakeResource> source_resource =
FakeResource::Create("FooBarResource");
BroadcastResourceListener broadcast_resource_listener(source_resource);
broadcast_resource_listener.StartListening();
- rtc::scoped_refptr<Resource> adapter =
+ scoped_refptr<Resource> adapter =
broadcast_resource_listener.CreateAdapterResource();
EXPECT_EQ("FooBarResourceAdapter", adapter->Name());
@@ -64,31 +64,31 @@
}
TEST(BroadcastResourceListenerTest, AdaptersForwardsUsageMeasurements) {
- rtc::scoped_refptr<FakeResource> source_resource =
+ scoped_refptr<FakeResource> source_resource =
FakeResource::Create("SourceResource");
BroadcastResourceListener broadcast_resource_listener(source_resource);
broadcast_resource_listener.StartListening();
StrictMock<MockResourceListener> destination_listener1;
StrictMock<MockResourceListener> destination_listener2;
- rtc::scoped_refptr<Resource> adapter1 =
+ scoped_refptr<Resource> adapter1 =
broadcast_resource_listener.CreateAdapterResource();
adapter1->SetResourceListener(&destination_listener1);
- rtc::scoped_refptr<Resource> adapter2 =
+ scoped_refptr<Resource> adapter2 =
broadcast_resource_listener.CreateAdapterResource();
adapter2->SetResourceListener(&destination_listener2);
// Expect kOveruse to be echoed.
EXPECT_CALL(destination_listener1, OnResourceUsageStateMeasured(_, _))
.Times(1)
- .WillOnce([adapter1](rtc::scoped_refptr<Resource> resource,
+ .WillOnce([adapter1](scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(adapter1, resource);
EXPECT_EQ(ResourceUsageState::kOveruse, usage_state);
});
EXPECT_CALL(destination_listener2, OnResourceUsageStateMeasured(_, _))
.Times(1)
- .WillOnce([adapter2](rtc::scoped_refptr<Resource> resource,
+ .WillOnce([adapter2](scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(adapter2, resource);
EXPECT_EQ(ResourceUsageState::kOveruse, usage_state);
@@ -98,14 +98,14 @@
// Expect kUnderuse to be echoed.
EXPECT_CALL(destination_listener1, OnResourceUsageStateMeasured(_, _))
.Times(1)
- .WillOnce([adapter1](rtc::scoped_refptr<Resource> resource,
+ .WillOnce([adapter1](scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(adapter1, resource);
EXPECT_EQ(ResourceUsageState::kUnderuse, usage_state);
});
EXPECT_CALL(destination_listener2, OnResourceUsageStateMeasured(_, _))
.Times(1)
- .WillOnce([adapter2](rtc::scoped_refptr<Resource> resource,
+ .WillOnce([adapter2](scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(adapter2, resource);
EXPECT_EQ(ResourceUsageState::kUnderuse, usage_state);
diff --git a/call/adaptation/resource_adaptation_processor.cc b/call/adaptation/resource_adaptation_processor.cc
index 5784b33..c6b1374 100644
--- a/call/adaptation/resource_adaptation_processor.cc
+++ b/call/adaptation/resource_adaptation_processor.cc
@@ -48,12 +48,12 @@
}
void ResourceAdaptationProcessor::ResourceListenerDelegate::
- OnResourceUsageStateMeasured(rtc::scoped_refptr<Resource> resource,
+ OnResourceUsageStateMeasured(scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
if (!task_queue_->IsCurrent()) {
task_queue_->PostTask(
- [this_ref = rtc::scoped_refptr<ResourceListenerDelegate>(this),
- resource, usage_state] {
+ [this_ref = scoped_refptr<ResourceListenerDelegate>(this), resource,
+ usage_state] {
this_ref->OnResourceUsageStateMeasured(resource, usage_state);
});
return;
@@ -77,7 +77,7 @@
VideoStreamAdapter* stream_adapter)
: task_queue_(TaskQueueBase::Current()),
resource_listener_delegate_(
- rtc::make_ref_counted<ResourceListenerDelegate>(this)),
+ make_ref_counted<ResourceListenerDelegate>(this)),
resources_(),
stream_adapter_(stream_adapter),
last_reported_source_restrictions_(),
@@ -116,7 +116,7 @@
}
void ResourceAdaptationProcessor::AddResource(
- rtc::scoped_refptr<Resource> resource) {
+ scoped_refptr<Resource> resource) {
RTC_DCHECK(resource);
{
MutexLock crit(&resources_lock_);
@@ -128,14 +128,14 @@
RTC_LOG(LS_INFO) << "Registered resource \"" << resource->Name() << "\".";
}
-std::vector<rtc::scoped_refptr<Resource>>
-ResourceAdaptationProcessor::GetResources() const {
+std::vector<scoped_refptr<Resource>> ResourceAdaptationProcessor::GetResources()
+ const {
MutexLock crit(&resources_lock_);
return resources_;
}
void ResourceAdaptationProcessor::RemoveResource(
- rtc::scoped_refptr<Resource> resource) {
+ scoped_refptr<Resource> resource) {
RTC_DCHECK(resource);
RTC_LOG(LS_INFO) << "Removing resource \"" << resource->Name() << "\".";
resource->SetResourceListener(nullptr);
@@ -150,7 +150,7 @@
}
void ResourceAdaptationProcessor::RemoveLimitationsImposedByResource(
- rtc::scoped_refptr<Resource> resource) {
+ scoped_refptr<Resource> resource) {
if (!task_queue_->IsCurrent()) {
task_queue_->PostTask(
[this, resource]() { RemoveLimitationsImposedByResource(resource); });
@@ -193,7 +193,7 @@
}
void ResourceAdaptationProcessor::OnResourceUsageStateMeasured(
- rtc::scoped_refptr<Resource> resource,
+ scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
RTC_DCHECK_RUN_ON(task_queue_);
RTC_DCHECK(resource);
@@ -236,7 +236,7 @@
ResourceAdaptationProcessor::MitigationResultAndLogMessage
ResourceAdaptationProcessor::OnResourceUnderuse(
- rtc::scoped_refptr<Resource> reason_resource) {
+ scoped_refptr<Resource> reason_resource) {
RTC_DCHECK_RUN_ON(task_queue_);
// How can this stream be adapted up?
Adaptation adaptation = stream_adapter_->GetAdaptationUp();
@@ -248,7 +248,7 @@
message.Release());
}
// Check that resource is most limited.
- std::vector<rtc::scoped_refptr<Resource>> most_limited_resources;
+ std::vector<scoped_refptr<Resource>> most_limited_resources;
VideoStreamAdapter::RestrictionsWithCounters most_limited_restrictions;
std::tie(most_limited_resources, most_limited_restrictions) =
FindMostLimitedResources();
@@ -292,7 +292,7 @@
ResourceAdaptationProcessor::MitigationResultAndLogMessage
ResourceAdaptationProcessor::OnResourceOveruse(
- rtc::scoped_refptr<Resource> reason_resource) {
+ scoped_refptr<Resource> reason_resource) {
RTC_DCHECK_RUN_ON(task_queue_);
// How can this stream be adapted up?
Adaptation adaptation = stream_adapter_->GetAdaptationDown();
@@ -321,10 +321,10 @@
message.Release());
}
-std::pair<std::vector<rtc::scoped_refptr<Resource>>,
+std::pair<std::vector<scoped_refptr<Resource>>,
VideoStreamAdapter::RestrictionsWithCounters>
ResourceAdaptationProcessor::FindMostLimitedResources() const {
- std::vector<rtc::scoped_refptr<Resource>> most_limited_resources;
+ std::vector<scoped_refptr<Resource>> most_limited_resources;
VideoStreamAdapter::RestrictionsWithCounters most_limited_restrictions{
VideoSourceRestrictions(), VideoAdaptationCounters()};
@@ -347,7 +347,7 @@
}
void ResourceAdaptationProcessor::UpdateResourceLimitations(
- rtc::scoped_refptr<Resource> reason_resource,
+ scoped_refptr<Resource> reason_resource,
const VideoSourceRestrictions& restrictions,
const VideoAdaptationCounters& counters) {
auto& adaptation_limits = adaptation_limits_by_resources_[reason_resource];
@@ -357,7 +357,7 @@
}
adaptation_limits = {restrictions, counters};
- std::map<rtc::scoped_refptr<Resource>, VideoAdaptationCounters> limitations;
+ std::map<scoped_refptr<Resource>, VideoAdaptationCounters> limitations;
for (const auto& p : adaptation_limits_by_resources_) {
limitations.insert(std::make_pair(p.first, p.second.counters));
}
@@ -370,7 +370,7 @@
void ResourceAdaptationProcessor::OnVideoSourceRestrictionsUpdated(
VideoSourceRestrictions /* restrictions */,
const VideoAdaptationCounters& adaptation_counters,
- rtc::scoped_refptr<Resource> reason,
+ scoped_refptr<Resource> reason,
const VideoSourceRestrictions& unfiltered_restrictions) {
RTC_DCHECK_RUN_ON(task_queue_);
if (reason) {
diff --git a/call/adaptation/resource_adaptation_processor.h b/call/adaptation/resource_adaptation_processor.h
index 4506292..97d3e47 100644
--- a/call/adaptation/resource_adaptation_processor.h
+++ b/call/adaptation/resource_adaptation_processor.h
@@ -61,20 +61,20 @@
ResourceLimitationsListener* limitations_listener) override;
void RemoveResourceLimitationsListener(
ResourceLimitationsListener* limitations_listener) override;
- void AddResource(rtc::scoped_refptr<Resource> resource) override;
- std::vector<rtc::scoped_refptr<Resource>> GetResources() const override;
- void RemoveResource(rtc::scoped_refptr<Resource> resource) override;
+ void AddResource(scoped_refptr<Resource> resource) override;
+ std::vector<scoped_refptr<Resource>> GetResources() const override;
+ void RemoveResource(scoped_refptr<Resource> resource) override;
// ResourceListener implementation.
// Triggers OnResourceUnderuse() or OnResourceOveruse().
- void OnResourceUsageStateMeasured(rtc::scoped_refptr<Resource> resource,
+ void OnResourceUsageStateMeasured(scoped_refptr<Resource> resource,
ResourceUsageState usage_state) override;
// VideoSourceRestrictionsListener implementation.
void OnVideoSourceRestrictionsUpdated(
VideoSourceRestrictions restrictions,
const VideoAdaptationCounters& adaptation_counters,
- rtc::scoped_refptr<Resource> reason,
+ scoped_refptr<Resource> reason,
const VideoSourceRestrictions& unfiltered_restrictions) override;
private:
@@ -89,7 +89,7 @@
void OnProcessorDestroyed();
// ResourceListener implementation.
- void OnResourceUsageStateMeasured(rtc::scoped_refptr<Resource> resource,
+ void OnResourceUsageStateMeasured(scoped_refptr<Resource> resource,
ResourceUsageState usage_state) override;
private:
@@ -116,11 +116,11 @@
// informing listeners of the new VideoSourceRestriction and adaptation
// counters.
MitigationResultAndLogMessage OnResourceUnderuse(
- rtc::scoped_refptr<Resource> reason_resource);
+ scoped_refptr<Resource> reason_resource);
MitigationResultAndLogMessage OnResourceOveruse(
- rtc::scoped_refptr<Resource> reason_resource);
+ scoped_refptr<Resource> reason_resource);
- void UpdateResourceLimitations(rtc::scoped_refptr<Resource> reason_resource,
+ void UpdateResourceLimitations(scoped_refptr<Resource> reason_resource,
const VideoSourceRestrictions& restrictions,
const VideoAdaptationCounters& counters)
RTC_RUN_ON(task_queue_);
@@ -130,23 +130,22 @@
// resource performing the adaptation is the only most limited resource. This
// function returns the list of all most limited resources as well as the
// corresponding adaptation of that resource.
- std::pair<std::vector<rtc::scoped_refptr<Resource>>,
+ std::pair<std::vector<scoped_refptr<Resource>>,
VideoStreamAdapter::RestrictionsWithCounters>
FindMostLimitedResources() const RTC_RUN_ON(task_queue_);
- void RemoveLimitationsImposedByResource(
- rtc::scoped_refptr<Resource> resource);
+ void RemoveLimitationsImposedByResource(scoped_refptr<Resource> resource);
TaskQueueBase* task_queue_;
- rtc::scoped_refptr<ResourceListenerDelegate> resource_listener_delegate_;
+ scoped_refptr<ResourceListenerDelegate> resource_listener_delegate_;
// Input and output.
mutable Mutex resources_lock_;
- std::vector<rtc::scoped_refptr<Resource>> resources_
+ std::vector<scoped_refptr<Resource>> resources_
RTC_GUARDED_BY(resources_lock_);
std::vector<ResourceLimitationsListener*> resource_limitations_listeners_
RTC_GUARDED_BY(task_queue_);
// Purely used for statistics, does not ensure mapped resources stay alive.
- std::map<rtc::scoped_refptr<Resource>,
+ std::map<scoped_refptr<Resource>,
VideoStreamAdapter::RestrictionsWithCounters>
adaptation_limits_by_resources_ RTC_GUARDED_BY(task_queue_);
// Responsible for generating and applying possible adaptations.
diff --git a/call/adaptation/resource_adaptation_processor_interface.h b/call/adaptation/resource_adaptation_processor_interface.h
index 6446cc9..a1535f1 100644
--- a/call/adaptation/resource_adaptation_processor_interface.h
+++ b/call/adaptation/resource_adaptation_processor_interface.h
@@ -27,8 +27,8 @@
// The limitations on a resource were changed. This does not mean the current
// video restrictions have changed.
virtual void OnResourceLimitationChanged(
- rtc::scoped_refptr<Resource> resource,
- const std::map<rtc::scoped_refptr<Resource>, VideoAdaptationCounters>&
+ scoped_refptr<Resource> resource,
+ const std::map<scoped_refptr<Resource>, VideoAdaptationCounters>&
resource_limitations) = 0;
};
@@ -50,9 +50,9 @@
// with AddResource() and RemoveResource() instead. When the processor is
// multi-stream aware, stream-specific resouces will get added and removed
// over time.
- virtual void AddResource(rtc::scoped_refptr<Resource> resource) = 0;
- virtual std::vector<rtc::scoped_refptr<Resource>> GetResources() const = 0;
- virtual void RemoveResource(rtc::scoped_refptr<Resource> resource) = 0;
+ virtual void AddResource(scoped_refptr<Resource> resource) = 0;
+ virtual std::vector<scoped_refptr<Resource>> GetResources() const = 0;
+ virtual void RemoveResource(scoped_refptr<Resource> resource) = 0;
};
} // namespace webrtc
diff --git a/call/adaptation/resource_adaptation_processor_unittest.cc b/call/adaptation/resource_adaptation_processor_unittest.cc
index c1e0d09..79433c7 100644
--- a/call/adaptation/resource_adaptation_processor_unittest.cc
+++ b/call/adaptation/resource_adaptation_processor_unittest.cc
@@ -66,7 +66,7 @@
RTC_DCHECK_RUN_ON(&sequence_checker_);
return adaptation_counters_;
}
- rtc::scoped_refptr<Resource> reason() const {
+ scoped_refptr<Resource> reason() const {
RTC_DCHECK_RUN_ON(&sequence_checker_);
return reason_;
}
@@ -75,7 +75,7 @@
void OnVideoSourceRestrictionsUpdated(
VideoSourceRestrictions restrictions,
const VideoAdaptationCounters& adaptation_counters,
- rtc::scoped_refptr<Resource> reason,
+ scoped_refptr<Resource> reason,
const VideoSourceRestrictions& /* unfiltered_restrictions */) override {
RTC_DCHECK_RUN_ON(&sequence_checker_);
++restrictions_updated_count_;
@@ -90,7 +90,7 @@
VideoSourceRestrictions restrictions_ RTC_GUARDED_BY(&sequence_checker_);
VideoAdaptationCounters adaptation_counters_
RTC_GUARDED_BY(&sequence_checker_);
- rtc::scoped_refptr<Resource> reason_ RTC_GUARDED_BY(&sequence_checker_);
+ scoped_refptr<Resource> reason_ RTC_GUARDED_BY(&sequence_checker_);
};
class ResourceAdaptationProcessorTest : public ::testing::Test {
@@ -150,8 +150,8 @@
webrtc::test::ScopedKeyValueConfig field_trials_;
FakeFrameRateProvider frame_rate_provider_;
VideoStreamInputStateProvider input_state_provider_;
- rtc::scoped_refptr<FakeResource> resource_;
- rtc::scoped_refptr<FakeResource> other_resource_;
+ scoped_refptr<FakeResource> resource_;
+ scoped_refptr<FakeResource> other_resource_;
std::unique_ptr<VideoStreamAdapter> video_stream_adapter_;
std::unique_ptr<ResourceAdaptationProcessor> processor_;
VideoSourceRestrictionsListenerForTesting restrictions_listener_;
diff --git a/call/adaptation/resource_unittest.cc b/call/adaptation/resource_unittest.cc
index ac23362..d3b7622 100644
--- a/call/adaptation/resource_unittest.cc
+++ b/call/adaptation/resource_unittest.cc
@@ -27,7 +27,7 @@
ResourceTest() : fake_resource_(FakeResource::Create("FakeResource")) {}
protected:
- rtc::scoped_refptr<FakeResource> fake_resource_;
+ scoped_refptr<FakeResource> fake_resource_;
};
TEST_F(ResourceTest, RegisteringListenerReceivesCallbacks) {
@@ -35,7 +35,7 @@
fake_resource_->SetResourceListener(&resource_listener);
EXPECT_CALL(resource_listener, OnResourceUsageStateMeasured(_, _))
.Times(1)
- .WillOnce([](rtc::scoped_refptr<Resource> /* resource */,
+ .WillOnce([](scoped_refptr<Resource> /* resource */,
ResourceUsageState usage_state) {
EXPECT_EQ(ResourceUsageState::kOveruse, usage_state);
});
diff --git a/call/adaptation/test/fake_resource.cc b/call/adaptation/test/fake_resource.cc
index 7a47b79..e8c8708 100644
--- a/call/adaptation/test/fake_resource.cc
+++ b/call/adaptation/test/fake_resource.cc
@@ -20,8 +20,8 @@
namespace webrtc {
// static
-rtc::scoped_refptr<FakeResource> FakeResource::Create(absl::string_view name) {
- return rtc::make_ref_counted<FakeResource>(name);
+scoped_refptr<FakeResource> FakeResource::Create(absl::string_view name) {
+ return make_ref_counted<FakeResource>(name);
}
FakeResource::FakeResource(absl::string_view name)
@@ -31,7 +31,7 @@
void FakeResource::SetUsageState(ResourceUsageState usage_state) {
if (listener_) {
- listener_->OnResourceUsageStateMeasured(rtc::scoped_refptr<Resource>(this),
+ listener_->OnResourceUsageStateMeasured(scoped_refptr<Resource>(this),
usage_state);
}
}
diff --git a/call/adaptation/test/fake_resource.h b/call/adaptation/test/fake_resource.h
index 6284cfa..f5b26b2 100644
--- a/call/adaptation/test/fake_resource.h
+++ b/call/adaptation/test/fake_resource.h
@@ -22,7 +22,7 @@
// Fake resource used for testing.
class FakeResource : public Resource {
public:
- static rtc::scoped_refptr<FakeResource> Create(absl::string_view name);
+ static scoped_refptr<FakeResource> Create(absl::string_view name);
explicit FakeResource(absl::string_view name);
~FakeResource() override;
diff --git a/call/adaptation/test/mock_resource_listener.h b/call/adaptation/test/mock_resource_listener.h
index 14c6c17..74d8d05 100644
--- a/call/adaptation/test/mock_resource_listener.h
+++ b/call/adaptation/test/mock_resource_listener.h
@@ -21,7 +21,7 @@
public:
MOCK_METHOD(void,
OnResourceUsageStateMeasured,
- (rtc::scoped_refptr<Resource> resource,
+ (scoped_refptr<Resource> resource,
ResourceUsageState usage_state),
(override));
};
diff --git a/call/adaptation/video_source_restrictions.h b/call/adaptation/video_source_restrictions.h
index 31fb969..d32397a 100644
--- a/call/adaptation/video_source_restrictions.h
+++ b/call/adaptation/video_source_restrictions.h
@@ -63,7 +63,7 @@
void UpdateMin(const VideoSourceRestrictions& other);
private:
- // These map to rtc::VideoSinkWants's `max_pixel_count` and
+ // These map to VideoSinkWants's `max_pixel_count` and
// `target_pixel_count`.
std::optional<size_t> max_pixels_per_frame_;
std::optional<size_t> target_pixels_per_frame_;
diff --git a/call/adaptation/video_stream_adapter.cc b/call/adaptation/video_stream_adapter.cc
index bb608fa..5863931 100644
--- a/call/adaptation/video_stream_adapter.cc
+++ b/call/adaptation/video_stream_adapter.cc
@@ -657,9 +657,8 @@
return first_step;
}
-void VideoStreamAdapter::ApplyAdaptation(
- const Adaptation& adaptation,
- rtc::scoped_refptr<Resource> resource) {
+void VideoStreamAdapter::ApplyAdaptation(const Adaptation& adaptation,
+ scoped_refptr<Resource> resource) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DCHECK_EQ(adaptation.validation_id_, adaptation_validation_id_);
if (adaptation.status() != Adaptation::Status::kValid)
@@ -693,7 +692,7 @@
void VideoStreamAdapter::BroadcastVideoRestrictionsUpdate(
const VideoStreamInputState& /* input_state */,
- const rtc::scoped_refptr<Resource>& resource) {
+ const scoped_refptr<Resource>& resource) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
VideoSourceRestrictions filtered = FilterRestrictionsByDegradationPreference(
source_restrictions(), degradation_preference_);
diff --git a/call/adaptation/video_stream_adapter.h b/call/adaptation/video_stream_adapter.h
index 72647a0..285655a 100644
--- a/call/adaptation/video_stream_adapter.h
+++ b/call/adaptation/video_stream_adapter.h
@@ -46,7 +46,7 @@
virtual void OnVideoSourceRestrictionsUpdated(
VideoSourceRestrictions restrictions,
const VideoAdaptationCounters& adaptation_counters,
- rtc::scoped_refptr<Resource> reason,
+ scoped_refptr<Resource> reason,
const VideoSourceRestrictions& unfiltered_restrictions) = 0;
};
@@ -158,7 +158,7 @@
// Updates source_restrictions() the Adaptation.
void ApplyAdaptation(const Adaptation& adaptation,
- rtc::scoped_refptr<Resource> resource);
+ scoped_refptr<Resource> resource);
struct RestrictionsWithCounters {
VideoSourceRestrictions restrictions;
@@ -171,7 +171,7 @@
private:
void BroadcastVideoRestrictionsUpdate(
const VideoStreamInputState& input_state,
- const rtc::scoped_refptr<Resource>& resource);
+ const scoped_refptr<Resource>& resource);
bool HasSufficientInputForAdaptation(const VideoStreamInputState& input_state)
const RTC_RUN_ON(&sequence_checker_);
diff --git a/call/adaptation/video_stream_adapter_unittest.cc b/call/adaptation/video_stream_adapter_unittest.cc
index f1bc3cb..83720b4 100644
--- a/call/adaptation/video_stream_adapter_unittest.cc
+++ b/call/adaptation/video_stream_adapter_unittest.cc
@@ -113,7 +113,7 @@
void OnVideoSourceRestrictionsUpdated(
VideoSourceRestrictions /* restrictions */,
const VideoAdaptationCounters& /* adaptation_counters */,
- rtc::scoped_refptr<Resource> /* reason */,
+ scoped_refptr<Resource> /* reason */,
const VideoSourceRestrictions& unfiltered_restrictions) override {
calls_++;
last_restrictions_ = unfiltered_restrictions;
@@ -157,7 +157,7 @@
protected:
webrtc::test::ScopedKeyValueConfig field_trials_;
FakeVideoStreamInputStateProvider input_state_provider_;
- rtc::scoped_refptr<Resource> resource_;
+ scoped_refptr<Resource> resource_;
testing::StrictMock<MockVideoStreamEncoderObserver> encoder_stats_observer_;
VideoStreamAdapter adapter_;
};
diff --git a/call/audio_receive_stream.h b/call/audio_receive_stream.h
index 42502f5..4ae9ba0 100644
--- a/call/audio_receive_stream.h
+++ b/call/audio_receive_stream.h
@@ -150,7 +150,7 @@
// Decoder specifications for every payload type that we can receive.
std::map<int, SdpAudioFormat> decoder_map;
- rtc::scoped_refptr<AudioDecoderFactory> decoder_factory;
+ scoped_refptr<AudioDecoderFactory> decoder_factory;
std::optional<AudioCodecPairId> codec_pair_id;
@@ -163,14 +163,14 @@
// TODO(tommi): Remove this member variable from the struct. It's not
// a part of the AudioReceiveStreamInterface state but rather a pass through
// variable.
- rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor;
+ scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor;
// An optional frame transformer used by insertable streams to transform
// encoded frames.
// TODO(tommi): Remove this member variable from the struct. It's not
// a part of the AudioReceiveStreamInterface state but rather a pass through
// variable.
- rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer;
+ scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer;
};
// Methods that support reconfiguring the stream post initialization.
diff --git a/call/audio_send_stream.h b/call/audio_send_stream.h
index 768ba0b..d1b3e64 100644
--- a/call/audio_send_stream.h
+++ b/call/audio_send_stream.h
@@ -153,7 +153,7 @@
};
std::optional<SendCodecSpec> send_codec_spec;
- rtc::scoped_refptr<AudioEncoderFactory> encoder_factory;
+ scoped_refptr<AudioEncoderFactory> encoder_factory;
std::optional<AudioCodecPairId> codec_pair_id;
// Track ID as specified during track creation.
@@ -165,11 +165,11 @@
// An optional custom frame encryptor that allows the entire frame to be
// encryptor in whatever way the caller choses. This is not required by
// default.
- rtc::scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor;
+ scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor;
// An optional frame transformer used by insertable streams to transform
// encoded frames.
- rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer;
+ scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer;
};
virtual ~AudioSendStream() = default;
diff --git a/call/audio_state.h b/call/audio_state.h
index 7c17231..d58b7ff 100644
--- a/call/audio_state.h
+++ b/call/audio_state.h
@@ -31,16 +31,15 @@
// The audio mixer connected to active receive streams. One per
// AudioState.
- rtc::scoped_refptr<AudioMixer> audio_mixer;
+ scoped_refptr<AudioMixer> audio_mixer;
// The audio processing module.
- rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing;
+ scoped_refptr<webrtc::AudioProcessing> audio_processing;
// TODO(solenberg): Temporary: audio device module.
- rtc::scoped_refptr<webrtc::AudioDeviceModule> audio_device_module;
+ scoped_refptr<webrtc::AudioDeviceModule> audio_device_module;
- rtc::scoped_refptr<AsyncAudioProcessing::Factory>
- async_audio_processing_factory;
+ scoped_refptr<AsyncAudioProcessing::Factory> async_audio_processing_factory;
};
virtual AudioProcessing* audio_processing() = 0;
@@ -59,8 +58,7 @@
virtual void SetStereoChannelSwapping(bool enable) = 0;
- static rtc::scoped_refptr<AudioState> Create(
- const AudioState::Config& config);
+ static scoped_refptr<AudioState> Create(const AudioState::Config& config);
~AudioState() override {}
};
diff --git a/call/bitrate_allocator_unittest.cc b/call/bitrate_allocator_unittest.cc
index de8c61f..63f270f 100644
--- a/call/bitrate_allocator_unittest.cc
+++ b/call/bitrate_allocator_unittest.cc
@@ -78,7 +78,7 @@
uint32_t OnBitrateUpdated(BitrateAllocationUpdate update) override {
last_bitrate_bps_ = update.target_bitrate.bps();
last_fraction_loss_ =
- rtc::dchecked_cast<uint8_t>(update.packet_loss_ratio * 256);
+ dchecked_cast<uint8_t>(update.packet_loss_ratio * 256);
last_rtt_ms_ = update.round_trip_time.ms();
last_probing_interval_ms_ = update.bwe_period.ms();
return update.target_bitrate.bps() * protection_ratio_;
diff --git a/call/bitrate_estimator_tests.cc b/call/bitrate_estimator_tests.cc
index 12ca23b..28d401d 100644
--- a/call/bitrate_estimator_tests.cc
+++ b/call/bitrate_estimator_tests.cc
@@ -46,9 +46,9 @@
// writing tests that don't depend on the logging system.
class LogObserver {
public:
- LogObserver() { rtc::LogMessage::AddLogToStream(&callback_, rtc::LS_INFO); }
+ LogObserver() { LogMessage::AddLogToStream(&callback_, LS_INFO); }
- ~LogObserver() { rtc::LogMessage::RemoveLogToStream(&callback_); }
+ ~LogObserver() { LogMessage::RemoveLogToStream(&callback_); }
void PushExpectedLogLine(absl::string_view expected_log_line) {
callback_.PushExpectedLogLine(expected_log_line);
@@ -57,7 +57,7 @@
bool Wait() { return callback_.Wait(); }
private:
- class Callback : public rtc::LogSink {
+ class Callback : public LogSink {
public:
void OnLogMessage(const std::string& message) override {
OnLogMessage(absl::string_view(message));
diff --git a/call/call.cc b/call/call.cc
index 1e6d4d2..ace69e7 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -189,8 +189,8 @@
// and removing adapter resources to individual VideoSendStreams.
class ResourceVideoSendStreamForwarder {
public:
- ResourceVideoSendStreamForwarder(
- rtc::scoped_refptr<webrtc::Resource> resource)
+ explicit ResourceVideoSendStreamForwarder(
+ scoped_refptr<webrtc::Resource> resource)
: broadcast_resource_listener_(resource) {
broadcast_resource_listener_.StartListening();
}
@@ -199,7 +199,7 @@
broadcast_resource_listener_.StopListening();
}
- rtc::scoped_refptr<webrtc::Resource> Resource() const {
+ scoped_refptr<webrtc::Resource> Resource() const {
return broadcast_resource_listener_.SourceResource();
}
@@ -222,7 +222,7 @@
private:
BroadcastResourceListener broadcast_resource_listener_;
- std::map<VideoSendStream*, rtc::scoped_refptr<webrtc::Resource>>
+ std::map<VideoSendStream*, scoped_refptr<webrtc::Resource>>
adapter_resources_;
};
@@ -269,7 +269,7 @@
void DestroyFlexfecReceiveStream(
FlexfecReceiveStream* receive_stream) override;
- void AddAdaptationResource(rtc::scoped_refptr<Resource> resource) override;
+ void AddAdaptationResource(scoped_refptr<Resource> resource) override;
RtpTransportControllerSendInterface* GetTransportControllerSend() override;
@@ -287,7 +287,7 @@
TaskQueueBase* network_thread() const override;
TaskQueueBase* worker_thread() const override;
- void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override;
+ void DeliverRtcpPacket(CopyOnWriteBuffer packet) override;
void DeliverRtpPacket(
MediaType media_type,
@@ -309,7 +309,7 @@
void OnUpdateSyncGroup(webrtc::AudioReceiveStreamInterface& stream,
absl::string_view sync_group) override;
- void OnSentPacket(const rtc::SentPacket& sent_packet) override;
+ void OnSentPacket(const SentPacketInfo& sent_packet) override;
// Implements TargetTransferRateObserver,
void OnTargetTransferRate(TargetTransferRate msg) override;
@@ -378,7 +378,7 @@
RTC_GUARDED_BY(destructor_sequence_checker_);
};
- void DeliverRtcp(MediaType media_type, rtc::CopyOnWriteBuffer packet)
+ void DeliverRtcp(MediaType media_type, CopyOnWriteBuffer packet)
RTC_RUN_ON(network_thread_);
AudioReceiveStreamImpl* FindAudioStreamForSyncGroup(
@@ -506,7 +506,7 @@
// Sequence checker for outgoing network traffic. Could be the network thread.
// Could also be a pacer owned thread or TQ such as the TaskQueueSender.
RTC_NO_UNIQUE_ADDRESS SequenceChecker sent_packet_sequence_checker_;
- std::optional<rtc::SentPacket> last_sent_packet_
+ std::optional<SentPacketInfo> last_sent_packet_
RTC_GUARDED_BY(sent_packet_sequence_checker_);
// Declared last since it will issue callbacks from a task queue. Declaring it
// last ensures that it is destroyed first and any running tasks are finished.
@@ -1118,7 +1118,7 @@
delete receive_stream_impl;
}
-void Call::AddAdaptationResource(rtc::scoped_refptr<Resource> resource) {
+void Call::AddAdaptationResource(scoped_refptr<Resource> resource) {
RTC_DCHECK_RUN_ON(worker_thread_);
adaptation_resource_forwarders_.push_back(
std::make_unique<ResourceVideoSendStreamForwarder>(resource));
@@ -1297,7 +1297,7 @@
ConfigureSync(sync_group);
}
-void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
+void Call::OnSentPacket(const SentPacketInfo& sent_packet) {
RTC_DCHECK_RUN_ON(&sent_packet_sequence_checker_);
// When bundling is in effect, multiple senders may be sharing the same
// transport. It means every |sent_packet| will be multiply notified from
@@ -1399,7 +1399,7 @@
}
}
-void Call::DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) {
+void Call::DeliverRtcpPacket(CopyOnWriteBuffer packet) {
RTC_DCHECK_RUN_ON(worker_thread_);
RTC_DCHECK(IsRtcpPacket(packet));
TRACE_EVENT0("webrtc", "Call::DeliverRtcp");
diff --git a/call/call.h b/call/call.h
index ae6eaf8..87e1884 100644
--- a/call/call.h
+++ b/call/call.h
@@ -97,7 +97,7 @@
// When a resource is overused, the Call will try to reduce the load on the
// sysem, for example by reducing the resolution or frame rate of encoded
// streams.
- virtual void AddAdaptationResource(rtc::scoped_refptr<Resource> resource) = 0;
+ virtual void AddAdaptationResource(scoped_refptr<Resource> resource) = 0;
// All received RTP and RTCP packets for the call should be inserted to this
// PacketReceiver. The PacketReceiver pointer is valid as long as the
@@ -148,7 +148,7 @@
virtual void OnUpdateSyncGroup(AudioReceiveStreamInterface& stream,
absl::string_view sync_group) = 0;
- virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0;
+ virtual void OnSentPacket(const SentPacketInfo& sent_packet) = 0;
virtual void SetClientBitratePreferences(
const BitrateSettings& preferences) = 0;
diff --git a/call/call_config.h b/call/call_config.h
index d15651d..819297f 100644
--- a/call/call_config.h
+++ b/call/call_config.h
@@ -53,7 +53,7 @@
BitrateConstraints bitrate_config;
// AudioState which is possibly shared between multiple calls.
- rtc::scoped_refptr<AudioState> audio_state;
+ scoped_refptr<AudioState> audio_state;
// Audio Processing Module to be used in this call.
AudioProcessing* audio_processing = nullptr;
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index 525469d..b72558d 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -235,7 +235,7 @@
SendTask(task_queue(), [&]() {
metrics::Reset();
- rtc::scoped_refptr<AudioDeviceModule> fake_audio_device =
+ scoped_refptr<AudioDeviceModule> fake_audio_device =
TestAudioDeviceModule::Create(
&env().task_queue_factory(),
TestAudioDeviceModule::CreatePulsedNoiseCapturer(256, 48000),
@@ -569,7 +569,7 @@
private:
// TODO(holmer): Run this with a timer instead of once per packet.
- Action OnSendRtp(rtc::ArrayView<const uint8_t> /* packet */) override {
+ Action OnSendRtp(ArrayView<const uint8_t> /* packet */) override {
task_queue_->PostTask(SafeTask(task_safety_flag_, [this]() {
VideoSendStream::Stats stats = send_stream_->GetStats();
@@ -629,7 +629,7 @@
int num_bitrate_observations_in_range_;
SamplesStatsCounter bitrate_kbps_list_;
TaskQueueBase* task_queue_;
- rtc::scoped_refptr<PendingTaskSafetyFlag> task_safety_flag_;
+ scoped_refptr<PendingTaskSafetyFlag> task_safety_flag_;
} test(pad_to_min_bitrate, task_queue());
fake_encoder_max_bitrate_ = kMaxEncodeBitrateKbps;
@@ -739,7 +739,7 @@
bitrate_allocator_factory_.get();
encoder_config->max_bitrate_bps = 2 * kReconfigureThresholdKbps * 1000;
encoder_config->video_stream_factory =
- rtc::make_ref_counted<VideoStreamFactory>();
+ make_ref_counted<VideoStreamFactory>();
encoder_config_ = encoder_config->Copy();
}
@@ -1021,7 +1021,7 @@
}
}
- Action OnSendRtp(rtc::ArrayView<const uint8_t> /* packet */) override {
+ Action OnSendRtp(ArrayView<const uint8_t> /* packet */) override {
const Timestamp now = clock_->CurrentTime();
if (now - last_getstats_time_ > kMinGetStatsInterval) {
last_getstats_time_ = now;
diff --git a/call/call_unittest.cc b/call/call_unittest.cc
index 644f081..d891853 100644
--- a/call/call_unittest.cc
+++ b/call/call_unittest.cc
@@ -67,13 +67,13 @@
struct CallHelper {
explicit CallHelper(bool use_null_audio_processing) {
AudioState::Config audio_state_config;
- audio_state_config.audio_mixer = rtc::make_ref_counted<MockAudioMixer>();
+ audio_state_config.audio_mixer = make_ref_counted<MockAudioMixer>();
audio_state_config.audio_processing =
use_null_audio_processing
? nullptr
- : rtc::make_ref_counted<NiceMock<MockAudioProcessing>>();
+ : make_ref_counted<NiceMock<MockAudioProcessing>>();
audio_state_config.audio_device_module =
- rtc::make_ref_counted<MockAudioDeviceModule>();
+ make_ref_counted<MockAudioDeviceModule>();
CallConfig config(CreateEnvironment());
config.audio_state = AudioState::Create(audio_state_config);
call_ = Call::Create(std::move(config));
@@ -86,8 +86,8 @@
std::unique_ptr<Call> call_;
};
-rtc::scoped_refptr<Resource> FindResourceWhoseNameContains(
- const std::vector<rtc::scoped_refptr<Resource>>& resources,
+scoped_refptr<Resource> FindResourceWhoseNameContains(
+ const std::vector<scoped_refptr<Resource>>& resources,
absl::string_view name_contains) {
for (const auto& resource : resources) {
if (resource->Name().find(std::string(name_contains)) != std::string::npos)
@@ -124,7 +124,7 @@
config.rtp.remote_ssrc = 42;
config.rtcp_send_transport = &rtcp_send_transport;
config.decoder_factory =
- rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>();
+ make_ref_counted<webrtc::MockAudioDecoderFactory>();
AudioReceiveStreamInterface* stream =
call->CreateAudioReceiveStream(config);
EXPECT_NE(stream, nullptr);
@@ -164,7 +164,7 @@
MockTransport rtcp_send_transport;
config.rtcp_send_transport = &rtcp_send_transport;
config.decoder_factory =
- rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>();
+ make_ref_counted<webrtc::MockAudioDecoderFactory>();
std::list<AudioReceiveStreamInterface*> streams;
for (int i = 0; i < 2; ++i) {
for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) {
@@ -372,7 +372,7 @@
StrictMock<MockResourceListener> resource_listener1;
EXPECT_CALL(resource_listener1, OnResourceUsageStateMeasured(_, _))
.Times(1)
- .WillOnce([injected_resource1](rtc::scoped_refptr<Resource> resource,
+ .WillOnce([injected_resource1](scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(injected_resource1, resource);
EXPECT_EQ(ResourceUsageState::kOveruse, usage_state);
@@ -382,7 +382,7 @@
StrictMock<MockResourceListener> resource_listener2;
EXPECT_CALL(resource_listener2, OnResourceUsageStateMeasured(_, _))
.Times(1)
- .WillOnce([injected_resource2](rtc::scoped_refptr<Resource> resource,
+ .WillOnce([injected_resource2](scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(injected_resource2, resource);
EXPECT_EQ(ResourceUsageState::kOveruse, usage_state);
@@ -435,7 +435,7 @@
StrictMock<MockResourceListener> resource_listener1;
EXPECT_CALL(resource_listener1, OnResourceUsageStateMeasured(_, _))
.Times(1)
- .WillOnce([injected_resource1](rtc::scoped_refptr<Resource> resource,
+ .WillOnce([injected_resource1](scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(injected_resource1, resource);
EXPECT_EQ(ResourceUsageState::kUnderuse, usage_state);
@@ -445,7 +445,7 @@
StrictMock<MockResourceListener> resource_listener2;
EXPECT_CALL(resource_listener2, OnResourceUsageStateMeasured(_, _))
.Times(1)
- .WillOnce([injected_resource2](rtc::scoped_refptr<Resource> resource,
+ .WillOnce([injected_resource2](scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(injected_resource2, resource);
EXPECT_EQ(ResourceUsageState::kUnderuse, usage_state);
diff --git a/call/fake_network_pipe.cc b/call/fake_network_pipe.cc
index a895eed..a1150b3 100644
--- a/call/fake_network_pipe.cc
+++ b/call/fake_network_pipe.cc
@@ -38,7 +38,7 @@
constexpr int64_t kLogIntervalMs = 5000;
} // namespace
-NetworkPacket::NetworkPacket(rtc::CopyOnWriteBuffer packet,
+NetworkPacket::NetworkPacket(CopyOnWriteBuffer packet,
int64_t send_time,
int64_t arrival_time,
std::optional<PacketOptions> packet_options,
@@ -143,18 +143,18 @@
}
}
-bool FakeNetworkPipe::SendRtp(rtc::ArrayView<const uint8_t> packet,
+bool FakeNetworkPipe::SendRtp(ArrayView<const uint8_t> packet,
const PacketOptions& options,
Transport* transport) {
RTC_DCHECK(transport);
- EnqueuePacket(rtc::CopyOnWriteBuffer(packet), options, false, transport);
+ EnqueuePacket(CopyOnWriteBuffer(packet), options, false, transport);
return true;
}
-bool FakeNetworkPipe::SendRtcp(rtc::ArrayView<const uint8_t> packet,
+bool FakeNetworkPipe::SendRtcp(ArrayView<const uint8_t> packet,
Transport* transport) {
RTC_DCHECK(transport);
- EnqueuePacket(rtc::CopyOnWriteBuffer(packet), std::nullopt, true, transport);
+ EnqueuePacket(CopyOnWriteBuffer(packet), std::nullopt, true, transport);
return true;
}
@@ -168,7 +168,7 @@
NetworkPacket(std::move(packet), media_type, time_now_us, time_now_us));
}
-void FakeNetworkPipe::DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) {
+void FakeNetworkPipe::DeliverRtcpPacket(CopyOnWriteBuffer packet) {
EnqueuePacket(std::move(packet), std::nullopt, true, MediaType::ANY,
std::nullopt);
}
@@ -181,7 +181,7 @@
FakeNetworkPipe::StoredPacket::StoredPacket(NetworkPacket&& packet)
: packet(std::move(packet)) {}
-bool FakeNetworkPipe::EnqueuePacket(rtc::CopyOnWriteBuffer packet,
+bool FakeNetworkPipe::EnqueuePacket(CopyOnWriteBuffer packet,
std::optional<PacketOptions> options,
bool is_rtcp,
MediaType media_type,
@@ -193,7 +193,7 @@
packet_time_us, nullptr));
}
-bool FakeNetworkPipe::EnqueuePacket(rtc::CopyOnWriteBuffer packet,
+bool FakeNetworkPipe::EnqueuePacket(CopyOnWriteBuffer packet,
std::optional<PacketOptions> options,
bool is_rtcp,
Transport* transport) {
@@ -323,12 +323,10 @@
return;
}
if (packet->is_rtcp()) {
- transport->SendRtcp(
- rtc::MakeArrayView(packet->data(), packet->data_length()));
+ transport->SendRtcp(MakeArrayView(packet->data(), packet->data_length()));
} else {
- transport->SendRtp(
- rtc::MakeArrayView(packet->data(), packet->data_length()),
- packet->packet_options());
+ transport->SendRtp(MakeArrayView(packet->data(), packet->data_length()),
+ packet->packet_options());
}
} else if (receiver_) {
int64_t packet_time_us = packet->packet_time_us().value_or(-1);
diff --git a/call/fake_network_pipe.h b/call/fake_network_pipe.h
index dabc4b9..a30c50e 100644
--- a/call/fake_network_pipe.h
+++ b/call/fake_network_pipe.h
@@ -35,7 +35,7 @@
class NetworkPacket {
public:
- NetworkPacket(rtc::CopyOnWriteBuffer packet,
+ NetworkPacket(CopyOnWriteBuffer packet,
int64_t send_time,
int64_t arrival_time,
std::optional<PacketOptions> packet_options,
@@ -59,7 +59,7 @@
const uint8_t* data() const { return packet_.data(); }
size_t data_length() const { return packet_.size(); }
- rtc::CopyOnWriteBuffer* raw_packet() { return &packet_; }
+ CopyOnWriteBuffer* raw_packet() { return &packet_; }
int64_t send_time() const { return send_time_; }
int64_t arrival_time() const { return arrival_time_; }
void IncrementArrivalTime(int64_t extra_delay) {
@@ -80,7 +80,7 @@
Transport* transport() const { return transport_; }
private:
- rtc::CopyOnWriteBuffer packet_;
+ CopyOnWriteBuffer packet_;
// The time the packet was sent out on the network.
int64_t send_time_;
// The time the packet should arrive at the receiver.
@@ -133,10 +133,10 @@
// Methods for use with Transport interface. When/if packets are delivered,
// they will be passed to the instance specified by the `transport` parameter.
// Note that that instance must be in the map of active transports.
- bool SendRtp(rtc::ArrayView<const uint8_t> packet,
+ bool SendRtp(ArrayView<const uint8_t> packet,
const PacketOptions& options,
Transport* transport);
- bool SendRtcp(rtc::ArrayView<const uint8_t> packet, Transport* transport);
+ bool SendRtcp(ArrayView<const uint8_t> packet, Transport* transport);
// Implements the PacketReceiver interface. When/if packets are delivered,
// they will be passed directly to the receiver instance given in
@@ -146,7 +146,7 @@
MediaType media_type,
RtpPacketReceived packet,
OnUndemuxablePacketHandler undemuxable_packet_handler) override;
- void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override;
+ void DeliverRtcpPacket(CopyOnWriteBuffer packet) override;
// Processes the network queues and trigger PacketReceiver::IncomingPacket for
// packets ready to be delivered.
@@ -179,7 +179,7 @@
// Returns true if enqueued, or false if packet was dropped. Use this method
// when enqueueing packets that should be received by PacketReceiver instance.
- bool EnqueuePacket(rtc::CopyOnWriteBuffer packet,
+ bool EnqueuePacket(CopyOnWriteBuffer packet,
std::optional<PacketOptions> options,
bool is_rtcp,
MediaType media_type,
@@ -187,7 +187,7 @@
// Returns true if enqueued, or false if packet was dropped. Use this method
// when enqueueing packets that should be received by Transport instance.
- bool EnqueuePacket(rtc::CopyOnWriteBuffer packet,
+ bool EnqueuePacket(CopyOnWriteBuffer packet,
std::optional<PacketOptions> options,
bool is_rtcp,
Transport* transport);
diff --git a/call/fake_network_pipe_unittest.cc b/call/fake_network_pipe_unittest.cc
index 026bf19..05a348c 100644
--- a/call/fake_network_pipe_unittest.cc
+++ b/call/fake_network_pipe_unittest.cc
@@ -38,10 +38,7 @@
namespace webrtc {
class MockReceiver : public PacketReceiver {
public:
- MOCK_METHOD(void,
- DeliverRtcpPacket,
- (rtc::CopyOnWriteBuffer packet),
- (override));
+ MOCK_METHOD(void, DeliverRtcpPacket, (CopyOnWriteBuffer packet), (override));
MOCK_METHOD(void,
DeliverRtpPacket,
(MediaType media_type,
@@ -497,14 +494,14 @@
std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe(
&fake_clock_, std::move(simulated_network), &receiver));
- rtc::CopyOnWriteBuffer buffer(100);
+ CopyOnWriteBuffer buffer(100);
memset(buffer.MutableData(), 0, 100);
pipe->DeliverRtcpPacket(std::move(buffer));
// Advance the network delay to get the first packet.
fake_clock_.AdvanceTimeMilliseconds(config.queue_delay_ms);
EXPECT_CALL(receiver,
- DeliverRtcpPacket(Property(&rtc::CopyOnWriteBuffer::size, 100)));
+ DeliverRtcpPacket(Property(&CopyOnWriteBuffer::size, 100)));
pipe->Process();
}
diff --git a/call/flexfec_receive_stream_unittest.cc b/call/flexfec_receive_stream_unittest.cc
index 96d3491..e49d02d 100644
--- a/call/flexfec_receive_stream_unittest.cc
+++ b/call/flexfec_receive_stream_unittest.cc
@@ -51,7 +51,7 @@
return config;
}
-RtpPacketReceived ParsePacket(rtc::ArrayView<const uint8_t> packet) {
+RtpPacketReceived ParsePacket(ArrayView<const uint8_t> packet) {
RtpPacketReceived parsed_packet(nullptr);
EXPECT_TRUE(parsed_packet.Parse(packet));
return parsed_packet;
diff --git a/call/packet_receiver.h b/call/packet_receiver.h
index 974c435..c149f8e 100644
--- a/call/packet_receiver.h
+++ b/call/packet_receiver.h
@@ -20,7 +20,7 @@
class PacketReceiver {
public:
// Demux RTCP packets. Must be called on the worker thread.
- virtual void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) = 0;
+ virtual void DeliverRtcpPacket(CopyOnWriteBuffer packet) = 0;
// Invoked once when a packet is received that can not be demuxed.
// If the method returns true, a new attempt is made to demux the packet.
diff --git a/call/rampup_tests.cc b/call/rampup_tests.cc
index 66ed7ae..5b121f0 100644
--- a/call/rampup_tests.cc
+++ b/call/rampup_tests.cc
@@ -177,7 +177,7 @@
encoder_config->number_of_streams = num_video_streams_;
encoder_config->max_bitrate_bps = 2000000;
encoder_config->video_stream_factory =
- rtc::make_ref_counted<RampUpTester::VideoStreamFactory>();
+ make_ref_counted<RampUpTester::VideoStreamFactory>();
if (num_video_streams_ == 1) {
// For single stream rampup until 1mbps
expected_bitrate_bps_ = kSingleStreamTargetBps;
diff --git a/call/receive_stream.h b/call/receive_stream.h
index 14655b7..32678cb 100644
--- a/call/receive_stream.h
+++ b/call/receive_stream.h
@@ -59,11 +59,10 @@
virtual void Stop() = 0;
virtual void SetDepacketizerToDecoderFrameTransformer(
- rtc::scoped_refptr<webrtc::FrameTransformerInterface>
- frame_transformer) = 0;
+ scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) = 0;
virtual void SetFrameDecryptor(
- rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) = 0;
+ scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) = 0;
virtual std::vector<RtpSource> GetSources() const = 0;
diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc
index ea02467..992e3a4 100644
--- a/call/rtp_transport_controller_send.cc
+++ b/call/rtp_transport_controller_send.cc
@@ -166,7 +166,7 @@
const RtpSenderObservers& observers,
std::unique_ptr<FecController> fec_controller,
const RtpSenderFrameEncryptionConfig& frame_encryption_config,
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
+ scoped_refptr<FrameTransformerInterface> frame_transformer) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
video_rtp_senders_.push_back(std::make_unique<RtpVideoSender>(
env_, task_queue_, suspended_ssrcs, states, rtp_config,
@@ -454,7 +454,7 @@
UpdateStreamsConfig();
}
void RtpTransportControllerSend::OnSentPacket(
- const rtc::SentPacket& sent_packet) {
+ const SentPacketInfo& sent_packet) {
// Normally called on the network thread!
// TODO(crbug.com/1373439): Clarify other thread contexts calling in,
// and simplify task posting logic when the combined network/worker project
@@ -472,7 +472,7 @@
}
void RtpTransportControllerSend::ProcessSentPacket(
- const rtc::SentPacket& sent_packet) {
+ const SentPacketInfo& sent_packet) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
std::optional<SentPacket> packet_msg =
transport_feedback_adapter_.ProcessSentPacket(sent_packet);
@@ -809,7 +809,7 @@
void RtpTransportControllerSend::OnReport(
Timestamp receive_time,
- rtc::ArrayView<const ReportBlockData> report_blocks) {
+ ArrayView<const ReportBlockData> report_blocks) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
if (report_blocks.empty())
return;
diff --git a/call/rtp_transport_controller_send.h b/call/rtp_transport_controller_send.h
index 8dc0518..980856e 100644
--- a/call/rtp_transport_controller_send.h
+++ b/call/rtp_transport_controller_send.h
@@ -81,7 +81,7 @@
const RtpSenderObservers& observers,
std::unique_ptr<FecController> fec_controller,
const RtpSenderFrameEncryptionConfig& frame_encryption_config,
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) override;
+ scoped_refptr<FrameTransformerInterface> frame_transformer) override;
void DestroyRtpVideoSender(
RtpVideoSenderInterface* rtp_video_sender) override;
@@ -109,7 +109,7 @@
int64_t GetPacerQueuingDelayMs() const override;
std::optional<Timestamp> GetFirstPacketTime() const override;
void EnablePeriodicAlrProbing(bool enable) override;
- void OnSentPacket(const rtc::SentPacket& sent_packet) override;
+ void OnSentPacket(const SentPacketInfo& sent_packet) override;
void OnReceivedPacket(const ReceivedPacket& packet_msg) override;
void SetSdpBitrateParameters(const BitrateConstraints& constraints) override;
@@ -126,7 +126,7 @@
void OnReceiverEstimatedMaxBitrate(Timestamp receive_time,
DataRate bitrate) override;
void OnReport(Timestamp receive_time,
- rtc::ArrayView<const ReportBlockData> report_blocks) override;
+ ArrayView<const ReportBlockData> report_blocks) override;
void OnRttUpdate(Timestamp receive_time, TimeDelta rtt) override;
void OnTransportFeedback(Timestamp receive_time,
const rtcp::TransportFeedback& feedback) override;
@@ -179,7 +179,7 @@
// Called by packet router just before packet is sent to the RTP modules.
void NotifyBweOfPacedSentPacket(const RtpPacketToSend& packet,
const PacedPacketInfo& pacing_info);
- void ProcessSentPacket(const rtc::SentPacket& sent_packet)
+ void ProcessSentPacket(const SentPacketInfo& sent_packet)
RTC_RUN_ON(sequence_checker_);
void ProcessSentPacketUpdates(NetworkControlUpdate updates)
RTC_RUN_ON(sequence_checker_);
diff --git a/call/rtp_transport_controller_send_interface.h b/call/rtp_transport_controller_send_interface.h
index 0f1f815..1c7b9aa 100644
--- a/call/rtp_transport_controller_send_interface.h
+++ b/call/rtp_transport_controller_send_interface.h
@@ -101,7 +101,7 @@
const RtpSenderObservers& observers,
std::unique_ptr<FecController> fec_controller,
const RtpSenderFrameEncryptionConfig& frame_encryption_config,
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) = 0;
+ scoped_refptr<FrameTransformerInterface> frame_transformer) = 0;
virtual void DestroyRtpVideoSender(
RtpVideoSenderInterface* rtp_video_sender) = 0;
diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc
index 04a69ee..4943443 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -234,7 +234,7 @@
RateLimiter* retransmission_rate_limiter,
FrameEncryptorInterface* frame_encryptor,
const CryptoOptions& crypto_options,
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
+ scoped_refptr<FrameTransformerInterface> frame_transformer) {
RTC_DCHECK_GT(rtp_config.ssrcs.size(), 0);
RtpRtcpInterface::Configuration configuration;
@@ -404,7 +404,7 @@
std::unique_ptr<FecController> fec_controller,
FrameEncryptorInterface* frame_encryptor,
const CryptoOptions& crypto_options,
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer)
+ scoped_refptr<FrameTransformerInterface> frame_transformer)
: env_(env),
use_frame_rate_for_overhead_(absl::StartsWith(
env.field_trials().Lookup("WebRTC-Video-UseFrameRateForOverhead"),
@@ -726,7 +726,7 @@
void RtpVideoSender::DeliverRtcp(const uint8_t* packet, size_t length) {
// Runs on a network thread.
for (const RtpStreamSender& stream : rtp_streams_)
- stream.rtp_rtcp->IncomingRtcpPacket(rtc::MakeArrayView(packet, length));
+ stream.rtp_rtcp->IncomingRtcpPacket(MakeArrayView(packet, length));
}
void RtpVideoSender::ConfigureSsrcs(
@@ -924,7 +924,7 @@
std::vector<RtpSequenceNumberMap::Info> RtpVideoSender::GetSentRtpPacketInfos(
uint32_t ssrc,
- rtc::ArrayView<const uint16_t> sequence_numbers) const {
+ ArrayView<const uint16_t> sequence_numbers) const {
for (const auto& rtp_stream : rtp_streams_) {
if (ssrc == rtp_stream.rtp_rtcp->SSRC()) {
return rtp_stream.rtp_rtcp->GetSentRtpPacketInfos(sequence_numbers);
@@ -1019,7 +1019,7 @@
// clean up anyway.
continue;
}
- rtc::ArrayView<const uint16_t> rtp_sequence_numbers(kv.second);
+ ArrayView<const uint16_t> rtp_sequence_numbers(kv.second);
it->second->OnPacketsAcknowledged(rtp_sequence_numbers);
}
}
diff --git a/call/rtp_video_sender.h b/call/rtp_video_sender.h
index fa20385..6fce841 100644
--- a/call/rtp_video_sender.h
+++ b/call/rtp_video_sender.h
@@ -97,7 +97,7 @@
std::unique_ptr<FecController> fec_controller,
FrameEncryptorInterface* frame_encryptor,
const CryptoOptions& crypto_options, // move inside RtpTransport
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer);
+ scoped_refptr<FrameTransformerInterface> frame_transformer);
~RtpVideoSender() override;
RtpVideoSender(const RtpVideoSender&) = delete;
@@ -154,7 +154,7 @@
std::vector<RtpSequenceNumberMap::Info> GetSentRtpPacketInfos(
uint32_t ssrc,
- rtc::ArrayView<const uint16_t> sequence_numbers) const
+ ArrayView<const uint16_t> sequence_numbers) const
RTC_LOCKS_EXCLUDED(mutex_) override;
// From StreamFeedbackObserver.
diff --git a/call/rtp_video_sender_interface.h b/call/rtp_video_sender_interface.h
index 5fe4ad3..069a2a8 100644
--- a/call/rtp_video_sender_interface.h
+++ b/call/rtp_video_sender_interface.h
@@ -57,7 +57,7 @@
size_t num_temporal_layers) = 0;
virtual std::vector<RtpSequenceNumberMap::Info> GetSentRtpPacketInfos(
uint32_t ssrc,
- rtc::ArrayView<const uint16_t> sequence_numbers) const = 0;
+ ArrayView<const uint16_t> sequence_numbers) const = 0;
// Implements FecControllerOverride.
void SetFecAllowed(bool fec_allowed) override = 0;
diff --git a/call/rtp_video_sender_unittest.cc b/call/rtp_video_sender_unittest.cc
index 2ed9041..cee6e8d 100644
--- a/call/rtp_video_sender_unittest.cc
+++ b/call/rtp_video_sender_unittest.cc
@@ -136,7 +136,7 @@
const std::vector<uint32_t>& ssrcs,
const std::vector<uint32_t>& rtx_ssrcs,
int payload_type,
- rtc::ArrayView<const int> payload_types) {
+ ArrayView<const int> payload_types) {
VideoSendStream::Config config(transport);
config.rtp.ssrcs = ssrcs;
config.rtp.rtx.ssrcs = rtx_ssrcs;
@@ -173,7 +173,7 @@
int payload_type,
const std::map<uint32_t, RtpPayloadState>& suspended_payload_states,
FrameCountObserver* frame_count_observer,
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer,
+ scoped_refptr<FrameTransformerInterface> frame_transformer,
const std::vector<int>& payload_types,
const FieldTrialsView* field_trials = nullptr)
: time_controller_(Timestamp::Millis(1000000)),
@@ -213,7 +213,7 @@
int payload_type,
const std::map<uint32_t, RtpPayloadState>& suspended_payload_states,
FrameCountObserver* frame_count_observer,
- rtc::scoped_refptr<FrameTransformerInterface> frame_transformer,
+ scoped_refptr<FrameTransformerInterface> frame_transformer,
const FieldTrialsView* field_trials = nullptr)
: RtpVideoSenderTestFixture(ssrcs,
rtx_ssrcs,
@@ -508,15 +508,15 @@
std::vector<uint16_t> transport_sequence_numbers;
EXPECT_CALL(test.transport(), SendRtp)
.Times(2)
- .WillRepeatedly([&rtp_sequence_numbers, &transport_sequence_numbers](
- rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- RtpPacket rtp_packet;
- EXPECT_TRUE(rtp_packet.Parse(packet));
- rtp_sequence_numbers.push_back(rtp_packet.SequenceNumber());
- transport_sequence_numbers.push_back(options.packet_id);
- return true;
- });
+ .WillRepeatedly(
+ [&rtp_sequence_numbers, &transport_sequence_numbers](
+ ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ RtpPacket rtp_packet;
+ EXPECT_TRUE(rtp_packet.Parse(packet));
+ rtp_sequence_numbers.push_back(rtp_packet.SequenceNumber());
+ transport_sequence_numbers.push_back(options.packet_id);
+ return true;
+ });
EXPECT_EQ(EncodedImageCallback::Result::OK,
test.router()->OnEncodedImage(encoded_image, nullptr).error);
encoded_image.SetRtpTimestamp(2);
@@ -530,19 +530,19 @@
rtcp::Nack nack;
nack.SetMediaSsrc(kSsrc1);
nack.SetPacketIds(rtp_sequence_numbers);
- rtc::Buffer nack_buffer = nack.Build();
+ Buffer nack_buffer = nack.Build();
std::vector<uint16_t> retransmitted_rtp_sequence_numbers;
EXPECT_CALL(test.transport(), SendRtp)
.Times(2)
.WillRepeatedly([&retransmitted_rtp_sequence_numbers](
- rtc::ArrayView<const uint8_t> packet,
+ ArrayView<const uint8_t> packet,
const PacketOptions& options) {
RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet));
EXPECT_EQ(rtp_packet.Ssrc(), kRtxSsrc1);
// Capture the retransmitted sequence number from the RTX header.
- rtc::ArrayView<const uint8_t> payload = rtp_packet.payload();
+ ArrayView<const uint8_t> payload = rtp_packet.payload();
retransmitted_rtp_sequence_numbers.push_back(
ByteReader<uint16_t>::ReadBigEndian(payload.data()));
return true;
@@ -577,13 +577,13 @@
// still be retransmitted.
test.AdvanceTime(TimeDelta::Millis(33));
EXPECT_CALL(test.transport(), SendRtp)
- .WillOnce([&lost_packet_feedback](rtc::ArrayView<const uint8_t> packet,
+ .WillOnce([&lost_packet_feedback](ArrayView<const uint8_t> packet,
const PacketOptions& options) {
RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet));
EXPECT_EQ(rtp_packet.Ssrc(), kRtxSsrc1);
// Capture the retransmitted sequence number from the RTX header.
- rtc::ArrayView<const uint8_t> payload = rtp_packet.payload();
+ ArrayView<const uint8_t> payload = rtp_packet.payload();
EXPECT_EQ(lost_packet_feedback.rtp_sequence_number,
ByteReader<uint16_t>::ReadBigEndian(payload.data()));
return true;
@@ -680,8 +680,7 @@
EXPECT_CALL(test.transport(), SendRtp)
.WillOnce(
[&frame1_rtp_sequence_number, &frame1_transport_sequence_number](
- rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
+ ArrayView<const uint8_t> packet, const PacketOptions& options) {
RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet));
frame1_rtp_sequence_number = rtp_packet.SequenceNumber();
@@ -700,8 +699,7 @@
EXPECT_CALL(test.transport(), SendRtp)
.WillOnce(
[&frame2_rtp_sequence_number, &frame2_transport_sequence_number](
- rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
+ ArrayView<const uint8_t> packet, const PacketOptions& options) {
RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet));
frame2_rtp_sequence_number = rtp_packet.SequenceNumber();
@@ -718,20 +716,19 @@
// Inject a transport feedback where the packet for the first frame is lost,
// expect a retransmission for it.
EXPECT_CALL(test.transport(), SendRtp)
- .WillOnce(
- [&frame1_rtp_sequence_number](rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- RtpPacket rtp_packet;
- EXPECT_TRUE(rtp_packet.Parse(packet));
- EXPECT_EQ(rtp_packet.Ssrc(), kRtxSsrc1);
+ .WillOnce([&frame1_rtp_sequence_number](ArrayView<const uint8_t> packet,
+ const PacketOptions& options) {
+ RtpPacket rtp_packet;
+ EXPECT_TRUE(rtp_packet.Parse(packet));
+ EXPECT_EQ(rtp_packet.Ssrc(), kRtxSsrc1);
- // Retransmitted sequence number from the RTX header should match
- // the lost packet.
- rtc::ArrayView<const uint8_t> payload = rtp_packet.payload();
- EXPECT_EQ(ByteReader<uint16_t>::ReadBigEndian(payload.data()),
- frame1_rtp_sequence_number);
- return true;
- });
+ // Retransmitted sequence number from the RTX header should match
+ // the lost packet.
+ ArrayView<const uint8_t> payload = rtp_packet.payload();
+ EXPECT_EQ(ByteReader<uint16_t>::ReadBigEndian(payload.data()),
+ frame1_rtp_sequence_number);
+ return true;
+ });
StreamFeedbackObserver::StreamPacketInfo first_packet_feedback;
first_packet_feedback.rtp_sequence_number = frame1_rtp_sequence_number;
@@ -761,12 +758,12 @@
kDependencyDescriptorExtensionId);
std::vector<RtpPacket> sent_packets;
ON_CALL(test.transport(), SendRtp)
- .WillByDefault([&](rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- sent_packets.emplace_back(&extensions);
- EXPECT_TRUE(sent_packets.back().Parse(packet));
- return true;
- });
+ .WillByDefault(
+ [&](ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ sent_packets.emplace_back(&extensions);
+ EXPECT_TRUE(sent_packets.back().Parse(packet));
+ return true;
+ });
const uint8_t kPayload[1] = {'a'};
EncodedImage encoded_image;
@@ -826,12 +823,12 @@
kDependencyDescriptorExtensionId);
std::vector<RtpPacket> sent_packets;
ON_CALL(test.transport(), SendRtp)
- .WillByDefault([&](rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- sent_packets.emplace_back(&extensions);
- EXPECT_TRUE(sent_packets.back().Parse(packet));
- return true;
- });
+ .WillByDefault(
+ [&](ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ sent_packets.emplace_back(&extensions);
+ EXPECT_TRUE(sent_packets.back().Parse(packet));
+ return true;
+ });
const uint8_t kPayload[1] = {'a'};
EncodedImage encoded_image;
@@ -886,12 +883,12 @@
kDependencyDescriptorExtensionId);
std::vector<RtpPacket> sent_packets;
ON_CALL(test.transport(), SendRtp)
- .WillByDefault([&](rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- sent_packets.emplace_back(&extensions);
- EXPECT_TRUE(sent_packets.back().Parse(packet));
- return true;
- });
+ .WillByDefault(
+ [&](ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ sent_packets.emplace_back(&extensions);
+ EXPECT_TRUE(sent_packets.back().Parse(packet));
+ return true;
+ });
const uint8_t kPayload[1] = {'a'};
EncodedImage encoded_image;
@@ -942,7 +939,7 @@
std::vector<RtpPacket> sent_packets;
EXPECT_CALL(test.transport(), SendRtp)
.Times(3)
- .WillRepeatedly([&](rtc::ArrayView<const uint8_t> packet,
+ .WillRepeatedly([&](ArrayView<const uint8_t> packet,
const PacketOptions& options) -> bool {
RtpPacket& rtp_packet = sent_packets.emplace_back();
EXPECT_TRUE(rtp_packet.Parse(packet));
@@ -980,18 +977,18 @@
nack2.SetMediaSsrc(kSsrc2);
nack1.SetPacketIds({rtp_sequence_numbers[0], rtp_sequence_numbers[1]});
nack2.SetPacketIds({rtp_sequence_numbers[2]});
- rtc::Buffer nack_buffer1 = nack1.Build();
- rtc::Buffer nack_buffer2 = nack2.Build();
+ Buffer nack_buffer1 = nack1.Build();
+ Buffer nack_buffer2 = nack2.Build();
std::vector<RtpPacket> sent_rtx_packets;
EXPECT_CALL(test.transport(), SendRtp)
.Times(3)
- .WillRepeatedly([&](rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- RtpPacket& rtp_packet = sent_rtx_packets.emplace_back();
- EXPECT_TRUE(rtp_packet.Parse(packet));
- return true;
- });
+ .WillRepeatedly(
+ [&](ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ RtpPacket& rtp_packet = sent_rtx_packets.emplace_back();
+ EXPECT_TRUE(rtp_packet.Parse(packet));
+ return true;
+ });
test.router()->DeliverRtcp(nack_buffer1.data(), nack_buffer1.size());
test.router()->DeliverRtcp(nack_buffer2.data(), nack_buffer2.size());
@@ -1013,7 +1010,7 @@
std::vector<RtpPacket> sent_packets;
ON_CALL(test.transport(), SendRtp)
.WillByDefault(
- [&](rtc::ArrayView<const uint8_t> packet, const PacketOptions&) {
+ [&](ArrayView<const uint8_t> packet, const PacketOptions&) {
EXPECT_TRUE(sent_packets.emplace_back(&extensions).Parse(packet));
return true;
});
@@ -1058,12 +1055,12 @@
kDependencyDescriptorExtensionId);
std::vector<RtpPacket> sent_packets;
ON_CALL(test.transport(), SendRtp)
- .WillByDefault([&](rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- sent_packets.emplace_back(&extensions);
- EXPECT_TRUE(sent_packets.back().Parse(packet));
- return true;
- });
+ .WillByDefault(
+ [&](ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ sent_packets.emplace_back(&extensions);
+ EXPECT_TRUE(sent_packets.back().Parse(packet));
+ return true;
+ });
const uint8_t kPayload[1] = {'a'};
EncodedImage encoded_image;
@@ -1114,12 +1111,12 @@
kDependencyDescriptorExtensionId);
std::vector<RtpPacket> sent_packets;
ON_CALL(test.transport(), SendRtp)
- .WillByDefault([&](rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- sent_packets.emplace_back(&extensions);
- EXPECT_TRUE(sent_packets.back().Parse(packet));
- return true;
- });
+ .WillByDefault(
+ [&](ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ sent_packets.emplace_back(&extensions);
+ EXPECT_TRUE(sent_packets.back().Parse(packet));
+ return true;
+ });
const uint8_t kPayload[1] = {'a'};
EncodedImage encoded_image;
@@ -1169,7 +1166,7 @@
std::vector<RtpPacket> sent_packets;
EXPECT_CALL(test.transport(), SendRtp(_, _))
.Times(2)
- .WillRepeatedly([&](rtc::ArrayView<const uint8_t> packet,
+ .WillRepeatedly([&](ArrayView<const uint8_t> packet,
const PacketOptions& options) -> bool {
sent_packets.emplace_back(&extensions);
EXPECT_TRUE(sent_packets.back().Parse(packet));
@@ -1226,12 +1223,12 @@
kDependencyDescriptorExtensionId);
std::vector<RtpPacket> sent_packets;
ON_CALL(test.transport(), SendRtp)
- .WillByDefault([&](rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- sent_packets.emplace_back(&extensions);
- EXPECT_TRUE(sent_packets.back().Parse(packet));
- return true;
- });
+ .WillByDefault(
+ [&](ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ sent_packets.emplace_back(&extensions);
+ EXPECT_TRUE(sent_packets.back().Parse(packet));
+ return true;
+ });
const uint8_t kPayload[1] = {'a'};
EncodedImage encoded_image;
@@ -1272,12 +1269,12 @@
kDependencyDescriptorExtensionId);
std::vector<RtpPacket> sent_packets;
ON_CALL(test.transport(), SendRtp)
- .WillByDefault([&](rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- sent_packets.emplace_back(&extensions);
- EXPECT_TRUE(sent_packets.back().Parse(packet));
- return true;
- });
+ .WillByDefault(
+ [&](ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ sent_packets.emplace_back(&extensions);
+ EXPECT_TRUE(sent_packets.back().Parse(packet));
+ return true;
+ });
const uint8_t kPayload[1] = {'a'};
EncodedImage encoded_image;
@@ -1327,8 +1324,8 @@
}
TEST(RtpVideoSenderTest, SimulcastSenderRegistersFrameTransformers) {
- rtc::scoped_refptr<MockFrameTransformer> transformer =
- rtc::make_ref_counted<MockFrameTransformer>();
+ scoped_refptr<MockFrameTransformer> transformer =
+ make_ref_counted<MockFrameTransformer>();
EXPECT_CALL(*transformer, RegisterTransformedFrameSinkCallback(_, kSsrc1));
EXPECT_CALL(*transformer, RegisterTransformedFrameSinkCallback(_, kSsrc2));
@@ -1384,12 +1381,12 @@
kDependencyDescriptorExtensionId);
std::vector<RtpPacket> sent_packets;
ON_CALL(test.transport(), SendRtp)
- .WillByDefault([&](rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- sent_packets.emplace_back(&extensions);
- EXPECT_TRUE(sent_packets.back().Parse(packet));
- return true;
- });
+ .WillByDefault(
+ [&](ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ sent_packets.emplace_back(&extensions);
+ EXPECT_TRUE(sent_packets.back().Parse(packet));
+ return true;
+ });
// Set a very low bitrate.
test.router()->OnBitrateUpdated(
@@ -1462,12 +1459,12 @@
kDependencyDescriptorExtensionId);
std::vector<RtpPacket> sent_packets;
ON_CALL(test.transport(), SendRtp)
- .WillByDefault([&](rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- sent_packets.emplace_back(&extensions);
- EXPECT_TRUE(sent_packets.back().Parse(packet));
- return true;
- });
+ .WillByDefault(
+ [&](ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ sent_packets.emplace_back(&extensions);
+ EXPECT_TRUE(sent_packets.back().Parse(packet));
+ return true;
+ });
// Set a very low bitrate.
test.router()->OnBitrateUpdated(
@@ -1554,15 +1551,15 @@
std::vector<uint16_t> base_sequence_numbers;
EXPECT_CALL(test.transport(), SendRtp)
.Times(2)
- .WillRepeatedly([&rtp_sequence_numbers, &transport_sequence_numbers](
- rtc::ArrayView<const uint8_t> packet,
- const PacketOptions& options) {
- RtpPacket rtp_packet;
- EXPECT_TRUE(rtp_packet.Parse(packet));
- rtp_sequence_numbers.push_back(rtp_packet.SequenceNumber());
- transport_sequence_numbers.push_back(options.packet_id);
- return true;
- });
+ .WillRepeatedly(
+ [&rtp_sequence_numbers, &transport_sequence_numbers](
+ ArrayView<const uint8_t> packet, const PacketOptions& options) {
+ RtpPacket rtp_packet;
+ EXPECT_TRUE(rtp_packet.Parse(packet));
+ rtp_sequence_numbers.push_back(rtp_packet.SequenceNumber());
+ transport_sequence_numbers.push_back(options.packet_id);
+ return true;
+ });
CodecSpecificInfo key_codec_info;
key_codec_info.codecType = kVideoCodecVP8;
key_codec_info.codecSpecific.VP8.temporalIdx = 0;
@@ -1585,19 +1582,19 @@
rtcp::Nack nack;
nack.SetMediaSsrc(kSsrc1);
nack.SetPacketIds(rtp_sequence_numbers);
- rtc::Buffer nack_buffer = nack.Build();
+ Buffer nack_buffer = nack.Build();
std::vector<uint16_t> retransmitted_rtp_sequence_numbers;
EXPECT_CALL(test.transport(), SendRtp)
.Times(1)
.WillRepeatedly([&retransmitted_rtp_sequence_numbers](
- rtc::ArrayView<const uint8_t> packet,
+ ArrayView<const uint8_t> packet,
const PacketOptions& options) {
RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet));
EXPECT_EQ(rtp_packet.Ssrc(), kRtxSsrc1);
// Capture the retransmitted sequence number from the RTX header.
- rtc::ArrayView<const uint8_t> payload = rtp_packet.payload();
+ ArrayView<const uint8_t> payload = rtp_packet.payload();
retransmitted_rtp_sequence_numbers.push_back(
ByteReader<uint16_t>::ReadBigEndian(payload.data()));
return true;
diff --git a/call/rtx_receive_stream.cc b/call/rtx_receive_stream.cc
index c7f5c7c..1607ebb 100644
--- a/call/rtx_receive_stream.cc
+++ b/call/rtx_receive_stream.cc
@@ -56,7 +56,7 @@
if (rtp_receive_statistics_) {
rtp_receive_statistics_->OnRtpPacket(rtx_packet);
}
- rtc::ArrayView<const uint8_t> payload = rtx_packet.payload();
+ ArrayView<const uint8_t> payload = rtx_packet.payload();
if (payload.size() < kRtxHeaderSize) {
return;
@@ -79,7 +79,7 @@
media_packet.set_arrival_time(rtx_packet.arrival_time());
// Skip the RTX header.
- rtc::ArrayView<const uint8_t> rtx_payload = payload.subview(kRtxHeaderSize);
+ ArrayView<const uint8_t> rtx_payload = payload.subview(kRtxHeaderSize);
uint8_t* media_payload = media_packet.AllocatePayload(rtx_payload.size());
RTC_DCHECK(media_payload != nullptr);
diff --git a/call/rtx_receive_stream_unittest.cc b/call/rtx_receive_stream_unittest.cc
index 6a2d055..342e80f 100644
--- a/call/rtx_receive_stream_unittest.cc
+++ b/call/rtx_receive_stream_unittest.cc
@@ -113,7 +113,7 @@
}
template <typename T>
-rtc::ArrayView<T> Truncate(rtc::ArrayView<T> a, size_t drop) {
+ArrayView<T> Truncate(ArrayView<T> a, size_t drop) {
return a.subview(0, a.size() - drop);
}
@@ -123,7 +123,7 @@
StrictMock<MockRtpPacketSink> media_sink;
RtxReceiveStream rtx_sink(&media_sink, PayloadTypeMapping(), kMediaSSRC);
RtpPacketReceived rtx_packet;
- EXPECT_TRUE(rtx_packet.Parse(rtc::ArrayView<const uint8_t>(kRtxPacket)));
+ EXPECT_TRUE(rtx_packet.Parse(ArrayView<const uint8_t>(kRtxPacket)));
EXPECT_CALL(media_sink, OnRtpPacket)
.WillOnce([](const RtpPacketReceived& packet) {
@@ -140,7 +140,7 @@
StrictMock<MockRtpPacketSink> media_sink;
RtxReceiveStream rtx_sink(&media_sink, PayloadTypeMapping(), kMediaSSRC);
RtpPacketReceived rtx_packet;
- EXPECT_TRUE(rtx_packet.Parse(rtc::ArrayView<const uint8_t>(kRtxPacket)));
+ EXPECT_TRUE(rtx_packet.Parse(ArrayView<const uint8_t>(kRtxPacket)));
EXPECT_FALSE(rtx_packet.recovered());
EXPECT_CALL(media_sink, OnRtpPacket)
.WillOnce([](const RtpPacketReceived& packet) {
@@ -157,7 +157,7 @@
RtxReceiveStream rtx_sink(&media_sink, payload_type_mapping, kMediaSSRC);
RtpPacketReceived rtx_packet;
- EXPECT_TRUE(rtx_packet.Parse(rtc::ArrayView<const uint8_t>(kRtxPacket)));
+ EXPECT_TRUE(rtx_packet.Parse(ArrayView<const uint8_t>(kRtxPacket)));
rtx_sink.OnRtpPacket(rtx_packet);
}
@@ -166,7 +166,7 @@
RtxReceiveStream rtx_sink(&media_sink, PayloadTypeMapping(), kMediaSSRC);
RtpPacketReceived rtx_packet;
EXPECT_TRUE(
- rtx_packet.Parse(Truncate(rtc::ArrayView<const uint8_t>(kRtxPacket), 2)));
+ rtx_packet.Parse(Truncate(ArrayView<const uint8_t>(kRtxPacket), 2)));
rtx_sink.OnRtpPacket(rtx_packet);
}
@@ -176,8 +176,7 @@
RtpHeaderExtensionMap extension_map;
extension_map.RegisterByType(3, kRtpExtensionVideoRotation);
RtpPacketReceived rtx_packet(&extension_map);
- EXPECT_TRUE(
- rtx_packet.Parse(rtc::ArrayView<const uint8_t>(kRtxPacketWithCVO)));
+ EXPECT_TRUE(rtx_packet.Parse(ArrayView<const uint8_t>(kRtxPacketWithCVO)));
VideoRotation rotation = kVideoRotation_0;
EXPECT_TRUE(rtx_packet.GetExtension<VideoOrientation>(&rotation));
@@ -201,7 +200,7 @@
StrictMock<MockRtpPacketSink> media_sink;
RtxReceiveStream rtx_sink(&media_sink, PayloadTypeMapping(), kMediaSSRC);
RtpPacketReceived rtx_packet(nullptr);
- EXPECT_TRUE(rtx_packet.Parse(rtc::ArrayView<const uint8_t>(kRtxPacket)));
+ EXPECT_TRUE(rtx_packet.Parse(ArrayView<const uint8_t>(kRtxPacket)));
rtx_packet.set_arrival_time(Timestamp::Millis(123));
EXPECT_CALL(media_sink, OnRtpPacket(Property(&RtpPacketReceived::arrival_time,
Timestamp::Millis(123))));
@@ -216,15 +215,14 @@
constexpr int kRtxPayloadOffset = 14;
uint8_t large_rtx_packet[kRtxPacketSize];
memcpy(large_rtx_packet, kRtxPacket, sizeof(kRtxPacket));
- rtc::ArrayView<uint8_t> payload(large_rtx_packet + kRtxPayloadOffset,
- kRtxPacketSize - kRtxPayloadOffset);
+ ArrayView<uint8_t> payload(large_rtx_packet + kRtxPayloadOffset,
+ kRtxPacketSize - kRtxPayloadOffset);
// Fill payload.
for (size_t i = 0; i < payload.size(); i++) {
payload[i] = i;
}
- EXPECT_TRUE(
- rtx_packet.Parse(rtc::ArrayView<const uint8_t>(large_rtx_packet)));
+ EXPECT_TRUE(rtx_packet.Parse(ArrayView<const uint8_t>(large_rtx_packet)));
EXPECT_CALL(media_sink, OnRtpPacket)
.WillOnce([&](const RtpPacketReceived& packet) {
@@ -247,10 +245,10 @@
uint8_t large_rtx_packet[kRtxPacketSize];
memcpy(large_rtx_packet, kRtxPacketWithPadding,
sizeof(kRtxPacketWithPadding));
- rtc::ArrayView<uint8_t> payload(
+ ArrayView<uint8_t> payload(
large_rtx_packet + kRtxPayloadOffset,
kRtxPacketSize - kRtxPayloadOffset - kRtxPaddingSize);
- rtc::ArrayView<uint8_t> padding(
+ ArrayView<uint8_t> padding(
large_rtx_packet + kRtxPacketSize - kRtxPaddingSize, kRtxPaddingSize);
// Fill payload.
@@ -262,8 +260,7 @@
padding[i] = kRtxPaddingSize;
}
- EXPECT_TRUE(
- rtx_packet.Parse(rtc::ArrayView<const uint8_t>(large_rtx_packet)));
+ EXPECT_TRUE(rtx_packet.Parse(ArrayView<const uint8_t>(large_rtx_packet)));
EXPECT_CALL(media_sink, OnRtpPacket)
.WillOnce([&](const RtpPacketReceived& packet) {
diff --git a/call/test/mock_audio_receive_stream.h b/call/test/mock_audio_receive_stream.h
index d1b48ba..0d3a690 100644
--- a/call/test/mock_audio_receive_stream.h
+++ b/call/test/mock_audio_receive_stream.h
@@ -38,18 +38,18 @@
MOCK_METHOD(bool, IsRunning, (), (const override));
MOCK_METHOD(void,
SetDepacketizerToDecoderFrameTransformer,
- (rtc::scoped_refptr<webrtc::FrameTransformerInterface>),
+ (scoped_refptr<FrameTransformerInterface>),
(override));
MOCK_METHOD(void,
SetDecoderMap,
- ((std::map<int, webrtc::SdpAudioFormat>)),
+ ((std::map<int, SdpAudioFormat>)),
(override));
MOCK_METHOD(void, SetNackHistory, (int), (override));
- MOCK_METHOD(void, SetRtcpMode, (webrtc::RtcpMode), (override));
+ MOCK_METHOD(void, SetRtcpMode, (RtcpMode), (override));
MOCK_METHOD(void, SetNonSenderRttMeasurement, (bool), (override));
MOCK_METHOD(void,
SetFrameDecryptor,
- (rtc::scoped_refptr<webrtc::FrameDecryptorInterface>),
+ (scoped_refptr<FrameDecryptorInterface>),
(override));
MOCK_METHOD(webrtc::AudioReceiveStreamInterface::Stats,
diff --git a/call/test/mock_rtp_transport_controller_send.h b/call/test/mock_rtp_transport_controller_send.h
index b30cfcf..844f660 100644
--- a/call/test/mock_rtp_transport_controller_send.h
+++ b/call/test/mock_rtp_transport_controller_send.h
@@ -50,7 +50,7 @@
const RtpSenderObservers&,
std::unique_ptr<FecController>,
const RtpSenderFrameEncryptionConfig&,
- rtc::scoped_refptr<FrameTransformerInterface>),
+ scoped_refptr<FrameTransformerInterface>),
(override));
MOCK_METHOD(void,
DestroyRtpVideoSender,
@@ -97,7 +97,7 @@
(),
(const, override));
MOCK_METHOD(void, EnablePeriodicAlrProbing, (bool), (override));
- MOCK_METHOD(void, OnSentPacket, (const rtc::SentPacket&), (override));
+ MOCK_METHOD(void, OnSentPacket, (const SentPacketInfo&), (override));
MOCK_METHOD(void,
SetSdpBitrateParameters,
(const BitrateConstraints&),
diff --git a/call/video_receive_stream.h b/call/video_receive_stream.h
index 4d44c1a..e7c6c85 100644
--- a/call/video_receive_stream.h
+++ b/call/video_receive_stream.h
@@ -286,12 +286,12 @@
// An optional custom frame decryptor that allows the entire frame to be
// decrypted in whatever way the caller choses. This is not required by
// default.
- rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor;
+ scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor;
// Per PeerConnection cryptography options.
CryptoOptions crypto_options;
- rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer;
+ scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer;
};
// TODO(pbos): Add info on currently-received codec to Stats.
diff --git a/call/video_send_stream.h b/call/video_send_stream.h
index 1c0a3bc..906d795 100644
--- a/call/video_send_stream.h
+++ b/call/video_send_stream.h
@@ -202,7 +202,7 @@
// An optional custom frame encryptor that allows the entire frame to be
// encrypted in whatever way the caller chooses. This is not required by
// default.
- rtc::scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor;
+ scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor;
// An optional encoder selector provided by the user.
// Overrides VideoEncoderFactory::GetEncoderSelector().
@@ -212,7 +212,7 @@
// Per PeerConnection cryptography options.
CryptoOptions crypto_options;
- rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer;
+ scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer;
private:
// Access to the copy constructor is private to force use of the Copy()
@@ -239,9 +239,8 @@
// TODO(https://crbug.com/webrtc/11565): When the ResourceAdaptationProcessor
// is moved to Call this method could be deleted altogether in favor of
// Call-level APIs only.
- virtual void AddAdaptationResource(rtc::scoped_refptr<Resource> resource) = 0;
- virtual std::vector<rtc::scoped_refptr<Resource>>
- GetAdaptationResources() = 0;
+ virtual void AddAdaptationResource(scoped_refptr<Resource> resource) = 0;
+ virtual std::vector<scoped_refptr<Resource>> GetAdaptationResources() = 0;
virtual void SetSource(
VideoSourceInterface<webrtc::VideoFrame>* source,
