admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace new rtc::RefCountedObject with rtc::make_ref_counted in a few files

Browse Source 
Bug: webrtc:12701
Change-Id: Ie50225374f811424faf20caf4cf454b2fd1c4dc9
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/215930
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Tommi <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33818}
This commit is contained in:
Tomas Gunnarsson 2021-04-22 19:21:43 +02:00 committed by Commit Bot
parent dbcf8afbcd
commit c1d589146b
52 changed files with 215 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/audio/echo_detector_creator.cc
View File

@ -15,7 +15,7 @@
namespace webrtc { namespace webrtc {
rtc::scoped_refptr<EchoDetector> CreateEchoDetector() { rtc::scoped_refptr<EchoDetector> CreateEchoDetector() {
return new rtc::RefCountedObject<ResidualEchoDetector>(); return rtc::make_ref_counted<ResidualEchoDetector>();
} }
} // namespace webrtc } // namespace webrtc

5
api/audio_codecs/audio_decoder_factory_template.h
View File

@ -123,9 +123,8 @@ rtc::scoped_refptr<AudioDecoderFactory> CreateAudioDecoderFactory() {
static_assert(sizeof...(Ts) >= 1, static_assert(sizeof...(Ts) >= 1,
"Caller must give at least one template parameter"); "Caller must give at least one template parameter");
return rtc::scoped_refptr<AudioDecoderFactory>( return rtc::make_ref_counted<
new rtc::RefCountedObject< audio_decoder_factory_template_impl::AudioDecoderFactoryT<Ts...>>();
audio_decoder_factory_template_impl::AudioDecoderFactoryT<Ts...>>());
} }
} // namespace webrtc } // namespace webrtc

5
api/audio_codecs/audio_encoder_factory_template.h
View File

@ -142,9 +142,8 @@ rtc::scoped_refptr<AudioEncoderFactory> CreateAudioEncoderFactory() {
static_assert(sizeof...(Ts) >= 1, static_assert(sizeof...(Ts) >= 1,
"Caller must give at least one template parameter"); "Caller must give at least one template parameter");
return rtc::scoped_refptr<AudioEncoderFactory>( return rtc::make_ref_counted<
new rtc::RefCountedObject< audio_encoder_factory_template_impl::AudioEncoderFactoryT<Ts...>>();
audio_encoder_factory_template_impl::AudioEncoderFactoryT<Ts...>>());
} }
} // namespace webrtc } // namespace webrtc

2
api/audio_codecs/test/audio_decoder_factory_template_unittest.cc
View File

@ -78,7 +78,7 @@ struct AudioDecoderFakeApi {
TEST(AudioDecoderFactoryTemplateTest, NoDecoderTypes) { TEST(AudioDecoderFactoryTemplateTest, NoDecoderTypes) {
rtc::scoped_refptr<AudioDecoderFactory> factory( rtc::scoped_refptr<AudioDecoderFactory> factory(
new rtc::RefCountedObject< rtc::make_ref_counted<
audio_decoder_factory_template_impl::AudioDecoderFactoryT<>>()); audio_decoder_factory_template_impl::AudioDecoderFactoryT<>>());
EXPECT_THAT(factory->GetSupportedDecoders(), ::testing::IsEmpty()); EXPECT_THAT(factory->GetSupportedDecoders(), ::testing::IsEmpty());
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1})); EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));

2
api/audio_codecs/test/audio_encoder_factory_template_unittest.cc
View File

@ -78,7 +78,7 @@ struct AudioEncoderFakeApi {
TEST(AudioEncoderFactoryTemplateTest, NoEncoderTypes) { TEST(AudioEncoderFactoryTemplateTest, NoEncoderTypes) {
rtc::scoped_refptr<AudioEncoderFactory> factory( rtc::scoped_refptr<AudioEncoderFactory> factory(
new rtc::RefCountedObject< rtc::make_ref_counted<
audio_encoder_factory_template_impl::AudioEncoderFactoryT<>>()); audio_encoder_factory_template_impl::AudioEncoderFactoryT<>>());
EXPECT_THAT(factory->GetSupportedEncoders(), ::testing::IsEmpty()); EXPECT_THAT(factory->GetSupportedEncoders(), ::testing::IsEmpty());
EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1})); EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));

4
api/ice_transport_factory.cc
View File

@ -60,12 +60,12 @@ rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
IceTransportInit init) { IceTransportInit init) {
if (init.async_resolver_factory()) { if (init.async_resolver_factory()) {
// Backwards compatibility mode // Backwards compatibility mode
return new rtc::RefCountedObject<IceTransportWithTransportChannel>( return rtc::make_ref_counted<IceTransportWithTransportChannel>(
std::make_unique<cricket::P2PTransportChannel>( std::make_unique<cricket::P2PTransportChannel>(
"", cricket::ICE_CANDIDATE_COMPONENT_RTP, init.port_allocator(), "", cricket::ICE_CANDIDATE_COMPONENT_RTP, init.port_allocator(),
init.async_resolver_factory(), init.event_log())); init.async_resolver_factory(), init.event_log()));
} else { } else {
return new rtc::RefCountedObject<IceTransportWithTransportChannel>( return rtc::make_ref_counted<IceTransportWithTransportChannel>(
cricket::P2PTransportChannel::Create( cricket::P2PTransportChannel::Create(
"", cricket::ICE_CANDIDATE_COMPONENT_RTP, init.port_allocator(), "", cricket::ICE_CANDIDATE_COMPONENT_RTP, init.port_allocator(),
init.async_dns_resolver_factory(), init.event_log())); init.async_dns_resolver_factory(), init.event_log()));

6
api/proxy.h
View File

@ -260,7 +260,7 @@ class ConstMethodCall : public QueuedTask {
public: \ public: \
static rtc::scoped_refptr<c##ProxyWithInternal> Create( \ static rtc::scoped_refptr<c##ProxyWithInternal> Create( \
rtc::Thread* primary_thread, INTERNAL_CLASS* c) { \ rtc::Thread* primary_thread, INTERNAL_CLASS* c) { \
return new rtc::RefCountedObject<c##ProxyWithInternal>(primary_thread, c); \ return rtc::make_ref_counted<c##ProxyWithInternal>(primary_thread, c); \
} }
#define BEGIN_PROXY_MAP(c) \ #define BEGIN_PROXY_MAP(c) \
@ -271,8 +271,8 @@ class ConstMethodCall : public QueuedTask {
static rtc::scoped_refptr<c##ProxyWithInternal> Create( \ static rtc::scoped_refptr<c##ProxyWithInternal> Create( \
rtc::Thread* primary_thread, rtc::Thread* secondary_thread, \ rtc::Thread* primary_thread, rtc::Thread* secondary_thread, \
INTERNAL_CLASS* c) { \ INTERNAL_CLASS* c) { \
return new rtc::RefCountedObject<c##ProxyWithInternal>( \ return rtc::make_ref_counted<c##ProxyWithInternal>(primary_thread, \
primary_thread, secondary_thread, c); \ secondary_thread, c); \
} }
#define BEGIN_OWNED_PROXY_MAP(c) \ #define BEGIN_OWNED_PROXY_MAP(c) \

4
api/video/encoded_image.cc
View File

@ -32,13 +32,13 @@ EncodedImageBuffer::~EncodedImageBuffer() {
// static // static
rtc::scoped_refptr<EncodedImageBuffer> EncodedImageBuffer::Create(size_t size) { rtc::scoped_refptr<EncodedImageBuffer> EncodedImageBuffer::Create(size_t size) {
return new rtc::RefCountedObject<EncodedImageBuffer>(size); return rtc::make_ref_counted<EncodedImageBuffer>(size);
} }
// static // static
rtc::scoped_refptr<EncodedImageBuffer> EncodedImageBuffer::Create( rtc::scoped_refptr<EncodedImageBuffer> EncodedImageBuffer::Create(
const uint8_t* data, const uint8_t* data,
size_t size) { size_t size) {
return new rtc::RefCountedObject<EncodedImageBuffer>(data, size); return rtc::make_ref_counted<EncodedImageBuffer>(data, size);
} }
const uint8_t* EncodedImageBuffer::data() const { const uint8_t* EncodedImageBuffer::data() const {

4
api/video/i010_buffer.cc
View File

@ -56,8 +56,8 @@ I010Buffer::~I010Buffer() {}
// static // static
rtc::scoped_refptr<I010Buffer> I010Buffer::Create(int width, int height) { rtc::scoped_refptr<I010Buffer> I010Buffer::Create(int width, int height) {
return new rtc::RefCountedObject<I010Buffer>( return rtc::make_ref_counted<I010Buffer>(width, height, width,
width, height, width, (width + 1) / 2, (width + 1) / 2); (width + 1) / 2, (width + 1) / 2);
} }
// static // static

6
api/video/i420_buffer.cc
View File

@ -60,7 +60,7 @@ I420Buffer::~I420Buffer() {}
// static // static
rtc::scoped_refptr<I420Buffer> I420Buffer::Create(int width, int height) { rtc::scoped_refptr<I420Buffer> I420Buffer::Create(int width, int height) {
return new rtc::RefCountedObject<I420Buffer>(width, height); return rtc::make_ref_counted<I420Buffer>(width, height);
} }
// static // static
@ -69,8 +69,8 @@ rtc::scoped_refptr<I420Buffer> I420Buffer::Create(int width,
int stride_y, int stride_y,
int stride_u, int stride_u,
int stride_v) { int stride_v) {
return new rtc::RefCountedObject<I420Buffer>(width, height, stride_y, return rtc::make_ref_counted<I420Buffer>(width, height, stride_y, stride_u,
stride_u, stride_v); stride_v);
} }
// static // static

5
api/video/nv12_buffer.cc
View File

@ -49,7 +49,7 @@ NV12Buffer::~NV12Buffer() = default;
// static // static
rtc::scoped_refptr<NV12Buffer> NV12Buffer::Create(int width, int height) { rtc::scoped_refptr<NV12Buffer> NV12Buffer::Create(int width, int height) {
return new rtc::RefCountedObject<NV12Buffer>(width, height); return rtc::make_ref_counted<NV12Buffer>(width, height);
} }
// static // static
@ -57,8 +57,7 @@ rtc::scoped_refptr<NV12Buffer> NV12Buffer::Create(int width,
int height, int height,
int stride_y, int stride_y,
int stride_uv) { int stride_uv) {
return new rtc::RefCountedObject<NV12Buffer>(width, height, stride_y, return rtc::make_ref_counted<NV12Buffer>(width, height, stride_y, stride_uv);
stride_uv);
} }
// static // static

10
api/voip/test/voip_engine_factory_unittest.cc
View File

@ -24,11 +24,11 @@ namespace {
// Create voip engine with mock modules as normal use case. // Create voip engine with mock modules as normal use case.
TEST(VoipEngineFactoryTest, CreateEngineWithMockModules) { TEST(VoipEngineFactoryTest, CreateEngineWithMockModules) {
VoipEngineConfig config; VoipEngineConfig config;
config.encoder_factory = new rtc::RefCountedObject<MockAudioEncoderFactory>(); config.encoder_factory = rtc::make_ref_counted<MockAudioEncoderFactory>();
config.decoder_factory = new rtc::RefCountedObject<MockAudioDecoderFactory>(); config.decoder_factory = rtc::make_ref_counted<MockAudioDecoderFactory>();
config.task_queue_factory = CreateDefaultTaskQueueFactory(); config.task_queue_factory = CreateDefaultTaskQueueFactory();
config.audio_processing = config.audio_processing =
new rtc::RefCountedObject<testing::NiceMock<test::MockAudioProcessing>>(); rtc::make_ref_counted<testing::NiceMock<test::MockAudioProcessing>>();
config.audio_device_module = test::MockAudioDeviceModule::CreateNice(); config.audio_device_module = test::MockAudioDeviceModule::CreateNice();
auto voip_engine = CreateVoipEngine(std::move(config)); auto voip_engine = CreateVoipEngine(std::move(config));
@ -38,8 +38,8 @@ TEST(VoipEngineFactoryTest, CreateEngineWithMockModules) {
// Create voip engine without setting audio processing as optional component. // Create voip engine without setting audio processing as optional component.
TEST(VoipEngineFactoryTest, UseNoAudioProcessing) { TEST(VoipEngineFactoryTest, UseNoAudioProcessing) {
VoipEngineConfig config; VoipEngineConfig config;
config.encoder_factory = new rtc::RefCountedObject<MockAudioEncoderFactory>(); config.encoder_factory = rtc::make_ref_counted<MockAudioEncoderFactory>();
config.decoder_factory = new rtc::RefCountedObject<MockAudioDecoderFactory>(); config.decoder_factory = rtc::make_ref_counted<MockAudioDecoderFactory>();
config.task_queue_factory = CreateDefaultTaskQueueFactory(); config.task_queue_factory = CreateDefaultTaskQueueFactory();
config.audio_device_module = test::MockAudioDeviceModule::CreateNice(); config.audio_device_module = test::MockAudioDeviceModule::CreateNice();

12
audio/audio_receive_stream_unittest.cc
View File

@ -74,7 +74,7 @@ const AudioDecodingCallStats kAudioDecodeStats = MakeAudioDecodeStatsForTest();
struct ConfigHelper { struct ConfigHelper {
explicit ConfigHelper(bool use_null_audio_processing) explicit ConfigHelper(bool use_null_audio_processing)
: ConfigHelper(new rtc::RefCountedObject<MockAudioMixer>(), : ConfigHelper(rtc::make_ref_counted<MockAudioMixer>(),
use_null_audio_processing) {} use_null_audio_processing) {}
ConfigHelper(rtc::scoped_refptr<MockAudioMixer> audio_mixer, ConfigHelper(rtc::scoped_refptr<MockAudioMixer> audio_mixer,
@ -87,9 +87,9 @@ struct ConfigHelper {
config.audio_processing = config.audio_processing =
use_null_audio_processing use_null_audio_processing
? nullptr ? nullptr
: new rtc::RefCountedObject<NiceMock<MockAudioProcessing>>(); : rtc::make_ref_counted<NiceMock<MockAudioProcessing>>();
config.audio_device_module = config.audio_device_module =
new rtc::RefCountedObject<testing::NiceMock<MockAudioDeviceModule>>(); rtc::make_ref_counted<testing::NiceMock<MockAudioDeviceModule>>();
audio_state_ = AudioState::Create(config); audio_state_ = AudioState::Create(config);
channel_receive_ = new ::testing::StrictMock<MockChannelReceive>(); channel_receive_ = new ::testing::StrictMock<MockChannelReceive>();
@ -117,7 +117,7 @@ struct ConfigHelper {
RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberId)); RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberId));
stream_config_.rtcp_send_transport = &rtcp_send_transport_; stream_config_.rtcp_send_transport = &rtcp_send_transport_;
stream_config_.decoder_factory = stream_config_.decoder_factory =
new rtc::RefCountedObject<MockAudioDecoderFactory>; rtc::make_ref_counted<MockAudioDecoderFactory>();
} }
std::unique_ptr<internal::AudioReceiveStream> CreateAudioReceiveStream() { std::unique_ptr<internal::AudioReceiveStream> CreateAudioReceiveStream() {
@ -358,14 +358,14 @@ TEST(AudioReceiveStreamTest, ReconfigureWithFrameDecryptor) {
auto new_config_0 = helper.config(); auto new_config_0 = helper.config();
rtc::scoped_refptr<FrameDecryptorInterface> mock_frame_decryptor_0( rtc::scoped_refptr<FrameDecryptorInterface> mock_frame_decryptor_0(
new rtc::RefCountedObject<MockFrameDecryptor>()); rtc::make_ref_counted<MockFrameDecryptor>());
new_config_0.frame_decryptor = mock_frame_decryptor_0; new_config_0.frame_decryptor = mock_frame_decryptor_0;
recv_stream->Reconfigure(new_config_0); recv_stream->Reconfigure(new_config_0);
auto new_config_1 = helper.config(); auto new_config_1 = helper.config();
rtc::scoped_refptr<FrameDecryptorInterface> mock_frame_decryptor_1( rtc::scoped_refptr<FrameDecryptorInterface> mock_frame_decryptor_1(
new rtc::RefCountedObject<MockFrameDecryptor>()); rtc::make_ref_counted<MockFrameDecryptor>());
new_config_1.frame_decryptor = mock_frame_decryptor_1; new_config_1.frame_decryptor = mock_frame_decryptor_1;
new_config_1.crypto_options.sframe.require_frame_encryption = true; new_config_1.crypto_options.sframe.require_frame_encryption = true;
recv_stream->Reconfigure(new_config_1); recv_stream->Reconfigure(new_config_1);

11
audio/audio_send_stream_unittest.cc
View File

@ -121,7 +121,7 @@ std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock(
rtc::scoped_refptr<MockAudioEncoderFactory> SetupEncoderFactoryMock() { rtc::scoped_refptr<MockAudioEncoderFactory> SetupEncoderFactoryMock() {
rtc::scoped_refptr<MockAudioEncoderFactory> factory = rtc::scoped_refptr<MockAudioEncoderFactory> factory =
new rtc::RefCountedObject<MockAudioEncoderFactory>(); rtc::make_ref_counted<MockAudioEncoderFactory>();
ON_CALL(*factory.get(), GetSupportedEncoders()) ON_CALL(*factory.get(), GetSupportedEncoders())
.WillByDefault(Return(std::vector<AudioCodecSpec>( .WillByDefault(Return(std::vector<AudioCodecSpec>(
std::begin(kCodecSpecs), std::end(kCodecSpecs)))); std::begin(kCodecSpecs), std::end(kCodecSpecs))));
@ -154,7 +154,7 @@ struct ConfigHelper {
audio_processing_( audio_processing_(
use_null_audio_processing use_null_audio_processing
? nullptr ? nullptr
: new rtc::RefCountedObject<NiceMock<MockAudioProcessing>>()), : rtc::make_ref_counted<NiceMock<MockAudioProcessing>>()),
bitrate_allocator_(&limit_observer_), bitrate_allocator_(&limit_observer_),
worker_queue_(task_queue_factory_->CreateTaskQueue( worker_queue_(task_queue_factory_->CreateTaskQueue(
"ConfigHelper_worker_queue", "ConfigHelper_worker_queue",
@ -165,8 +165,7 @@ struct ConfigHelper {
AudioState::Config config; AudioState::Config config;
config.audio_mixer = AudioMixerImpl::Create(); config.audio_mixer = AudioMixerImpl::Create();
config.audio_processing = audio_processing_; config.audio_processing = audio_processing_;
config.audio_device_module = config.audio_device_module = rtc::make_ref_counted<MockAudioDeviceModule>();
new rtc::RefCountedObject<MockAudioDeviceModule>();
audio_state_ = AudioState::Create(config); audio_state_ = AudioState::Create(config);
SetupDefaultChannelSend(audio_bwe_enabled); SetupDefaultChannelSend(audio_bwe_enabled);
@ -923,7 +922,7 @@ TEST(AudioSendStreamTest, ReconfigureWithFrameEncryptor) {
auto new_config = helper.config(); auto new_config = helper.config();
rtc::scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_0( rtc::scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_0(
new rtc::RefCountedObject<MockFrameEncryptor>()); rtc::make_ref_counted<MockFrameEncryptor>());
new_config.frame_encryptor = mock_frame_encryptor_0; new_config.frame_encryptor = mock_frame_encryptor_0;
EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(Ne(nullptr))) EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(Ne(nullptr)))
.Times(1); .Times(1);
@ -936,7 +935,7 @@ TEST(AudioSendStreamTest, ReconfigureWithFrameEncryptor) {
// Updating frame encryptor to a new object should force a call to the // Updating frame encryptor to a new object should force a call to the
// proxy. // proxy.
rtc::scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_1( rtc::scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_1(
new rtc::RefCountedObject<MockFrameEncryptor>()); rtc::make_ref_counted<MockFrameEncryptor>());
new_config.frame_encryptor = mock_frame_encryptor_1; new_config.frame_encryptor = mock_frame_encryptor_1;
new_config.crypto_options.sframe.require_frame_encryption = true; new_config.crypto_options.sframe.require_frame_encryption = true;
EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(Ne(nullptr))) EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(Ne(nullptr)))

2
audio/audio_state.cc
View File

@ -187,6 +187,6 @@ void AudioState::UpdateNullAudioPollerState() {
rtc::scoped_refptr<AudioState> AudioState::Create( rtc::scoped_refptr<AudioState> AudioState::Create(
const AudioState::Config& config) { const AudioState::Config& config) {
return new rtc::RefCountedObject<internal::AudioState>(config); return rtc::make_ref_counted<internal::AudioState>(config);
} }
} // namespace webrtc } // namespace webrtc

15
audio/audio_state_unittest.cc
View File

@ -90,7 +90,7 @@ struct FakeAsyncAudioProcessingHelper {
FakeTaskQueueFactory task_queue_factory_; FakeTaskQueueFactory task_queue_factory_;
rtc::scoped_refptr<AsyncAudioProcessing::Factory> CreateFactory() { rtc::scoped_refptr<AsyncAudioProcessing::Factory> CreateFactory() {
return new rtc::RefCountedObject<AsyncAudioProcessing::Factory>( return rtc::make_ref_counted<AsyncAudioProcessing::Factory>(
audio_frame_processor_, task_queue_factory_); audio_frame_processor_, task_queue_factory_);
} }
}; };
@ -107,10 +107,9 @@ struct ConfigHelper {
audio_state_config.audio_processing = audio_state_config.audio_processing =
params.use_null_audio_processing params.use_null_audio_processing
? nullptr ? nullptr
: new rtc::RefCountedObject< : rtc::make_ref_counted<testing::NiceMock<MockAudioProcessing>>();
testing::NiceMock<MockAudioProcessing>>();
audio_state_config.audio_device_module = audio_state_config.audio_device_module =
new rtc::RefCountedObject<NiceMock<MockAudioDeviceModule>>(); rtc::make_ref_counted<NiceMock<MockAudioDeviceModule>>();
if (params.use_async_audio_processing) { if (params.use_async_audio_processing) {
audio_state_config.async_audio_processing_factory = audio_state_config.async_audio_processing_factory =
async_audio_processing_helper_.CreateFactory(); async_audio_processing_helper_.CreateFactory();
@ -183,7 +182,7 @@ TEST_P(AudioStateTest, Create) {
TEST_P(AudioStateTest, ConstructDestruct) { TEST_P(AudioStateTest, ConstructDestruct) {
ConfigHelper helper(GetParam()); ConfigHelper helper(GetParam());
rtc::scoped_refptr<internal::AudioState> audio_state( rtc::scoped_refptr<internal::AudioState> audio_state(
new rtc::RefCountedObject<internal::AudioState>(helper.config())); rtc::make_ref_counted<internal::AudioState>(helper.config()));
} }
TEST_P(AudioStateTest, RecordedAudioArrivesAtSingleStream) { TEST_P(AudioStateTest, RecordedAudioArrivesAtSingleStream) {
@ -196,7 +195,7 @@ TEST_P(AudioStateTest, RecordedAudioArrivesAtSingleStream) {
} }
rtc::scoped_refptr<internal::AudioState> audio_state( rtc::scoped_refptr<internal::AudioState> audio_state(
new rtc::RefCountedObject<internal::AudioState>(helper.config())); rtc::make_ref_counted<internal::AudioState>(helper.config()));
MockAudioSendStream stream; MockAudioSendStream stream;
audio_state->AddSendingStream(&stream, 8000, 2); audio_state->AddSendingStream(&stream, 8000, 2);
@ -245,7 +244,7 @@ TEST_P(AudioStateTest, RecordedAudioArrivesAtMultipleStreams) {
} }
rtc::scoped_refptr<internal::AudioState> audio_state( rtc::scoped_refptr<internal::AudioState> audio_state(
new rtc::RefCountedObject<internal::AudioState>(helper.config())); rtc::make_ref_counted<internal::AudioState>(helper.config()));
MockAudioSendStream stream_1; MockAudioSendStream stream_1;
MockAudioSendStream stream_2; MockAudioSendStream stream_2;
@ -308,7 +307,7 @@ TEST_P(AudioStateTest, EnableChannelSwap) {
} }
rtc::scoped_refptr<internal::AudioState> audio_state( rtc::scoped_refptr<internal::AudioState> audio_state(
new rtc::RefCountedObject<internal::AudioState>(helper.config())); rtc::make_ref_counted<internal::AudioState>(helper.config()));
audio_state->SetStereoChannelSwapping(true); audio_state->SetStereoChannelSwapping(true);

2
audio/channel_receive.cc
View File

@ -337,7 +337,7 @@ void ChannelReceive::InitFrameTransformerDelegate(
OnReceivedPayloadData(packet, header); OnReceivedPayloadData(packet, header);
}; };
frame_transformer_delegate_ = frame_transformer_delegate_ =
new rtc::RefCountedObject<ChannelReceiveFrameTransformerDelegate>( rtc::make_ref_counted<ChannelReceiveFrameTransformerDelegate>(
std::move(receive_audio_callback), std::move(frame_transformer), std::move(receive_audio_callback), std::move(frame_transformer),
rtc::Thread::Current()); rtc::Thread::Current());
frame_transformer_delegate_->Init(); frame_transformer_delegate_->Init();

16
audio/channel_receive_frame_transformer_delegate_unittest.cc
View File

@ -41,9 +41,9 @@ class MockChannelReceive {
TEST(ChannelReceiveFrameTransformerDelegateTest, TEST(ChannelReceiveFrameTransformerDelegateTest,
RegisterTransformedFrameCallbackOnInit) { RegisterTransformedFrameCallbackOnInit) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer = rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
new rtc::RefCountedObject<MockFrameTransformer>(); rtc::make_ref_counted<MockFrameTransformer>();
rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate = rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate =
new rtc::RefCountedObject<ChannelReceiveFrameTransformerDelegate>( rtc::make_ref_counted<ChannelReceiveFrameTransformerDelegate>(
ChannelReceiveFrameTransformerDelegate::ReceiveFrameCallback(), ChannelReceiveFrameTransformerDelegate::ReceiveFrameCallback(),
mock_frame_transformer, nullptr); mock_frame_transformer, nullptr);
EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameCallback); EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameCallback);
@ -55,9 +55,9 @@ TEST(ChannelReceiveFrameTransformerDelegateTest,
TEST(ChannelReceiveFrameTransformerDelegateTest, TEST(ChannelReceiveFrameTransformerDelegateTest,
UnregisterTransformedFrameCallbackOnReset) { UnregisterTransformedFrameCallbackOnReset) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer = rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
new rtc::RefCountedObject<MockFrameTransformer>(); rtc::make_ref_counted<MockFrameTransformer>();
rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate = rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate =
new rtc::RefCountedObject<ChannelReceiveFrameTransformerDelegate>( rtc::make_ref_counted<ChannelReceiveFrameTransformerDelegate>(
ChannelReceiveFrameTransformerDelegate::ReceiveFrameCallback(), ChannelReceiveFrameTransformerDelegate::ReceiveFrameCallback(),
mock_frame_transformer, nullptr); mock_frame_transformer, nullptr);
EXPECT_CALL(*mock_frame_transformer, UnregisterTransformedFrameCallback); EXPECT_CALL(*mock_frame_transformer, UnregisterTransformedFrameCallback);
@ -69,10 +69,10 @@ TEST(ChannelReceiveFrameTransformerDelegateTest,
TEST(ChannelReceiveFrameTransformerDelegateTest, TEST(ChannelReceiveFrameTransformerDelegateTest,
TransformRunsChannelReceiveCallback) { TransformRunsChannelReceiveCallback) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer = rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
new rtc::RefCountedObject<NiceMock<MockFrameTransformer>>(); rtc::make_ref_counted<NiceMock<MockFrameTransformer>>();
MockChannelReceive mock_channel; MockChannelReceive mock_channel;
rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate = rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate =
new rtc::RefCountedObject<ChannelReceiveFrameTransformerDelegate>( rtc::make_ref_counted<ChannelReceiveFrameTransformerDelegate>(
mock_channel.callback(), mock_frame_transformer, mock_channel.callback(), mock_frame_transformer,
rtc::Thread::Current()); rtc::Thread::Current());
rtc::scoped_refptr<TransformedFrameCallback> callback; rtc::scoped_refptr<TransformedFrameCallback> callback;
@ -100,10 +100,10 @@ TEST(ChannelReceiveFrameTransformerDelegateTest,
TEST(ChannelReceiveFrameTransformerDelegateTest, TEST(ChannelReceiveFrameTransformerDelegateTest,
OnTransformedDoesNotRunChannelReceiveCallbackAfterReset) { OnTransformedDoesNotRunChannelReceiveCallbackAfterReset) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer = rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
new rtc::RefCountedObject<testing::NiceMock<MockFrameTransformer>>(); rtc::make_ref_counted<testing::NiceMock<MockFrameTransformer>>();
MockChannelReceive mock_channel; MockChannelReceive mock_channel;
rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate = rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate =
new rtc::RefCountedObject<ChannelReceiveFrameTransformerDelegate>( rtc::make_ref_counted<ChannelReceiveFrameTransformerDelegate>(
mock_channel.callback(), mock_frame_transformer, mock_channel.callback(), mock_frame_transformer,
rtc::Thread::Current()); rtc::Thread::Current());

2
audio/channel_send.cc
View File

@ -919,7 +919,7 @@ void ChannelSend::InitFrameTransformerDelegate(
absolute_capture_timestamp_ms); absolute_capture_timestamp_ms);
}; };
frame_transformer_delegate_ = frame_transformer_delegate_ =
new rtc::RefCountedObject<ChannelSendFrameTransformerDelegate>( rtc::make_ref_counted<ChannelSendFrameTransformerDelegate>(
std::move(send_audio_callback), std::move(frame_transformer), std::move(send_audio_callback), std::move(frame_transformer),
&encoder_queue_); &encoder_queue_);
frame_transformer_delegate_->Init(); frame_transformer_delegate_->Init();

16
audio/channel_send_frame_transformer_delegate_unittest.cc
View File

@ -53,9 +53,9 @@ class MockChannelSend {
TEST(ChannelSendFrameTransformerDelegateTest, TEST(ChannelSendFrameTransformerDelegateTest,
RegisterTransformedFrameCallbackOnInit) { RegisterTransformedFrameCallbackOnInit) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer = rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
new rtc::RefCountedObject<MockFrameTransformer>(); rtc::make_ref_counted<MockFrameTransformer>();
rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate = rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate =
new rtc::RefCountedObject<ChannelSendFrameTransformerDelegate>( rtc::make_ref_counted<ChannelSendFrameTransformerDelegate>(
ChannelSendFrameTransformerDelegate::SendFrameCallback(), ChannelSendFrameTransformerDelegate::SendFrameCallback(),
mock_frame_transformer, nullptr); mock_frame_transformer, nullptr);
EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameCallback); EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameCallback);
@ -67,9 +67,9 @@ TEST(ChannelSendFrameTransformerDelegateTest,
TEST(ChannelSendFrameTransformerDelegateTest, TEST(ChannelSendFrameTransformerDelegateTest,
UnregisterTransformedFrameCallbackOnReset) { UnregisterTransformedFrameCallbackOnReset) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer = rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
new rtc::RefCountedObject<MockFrameTransformer>(); rtc::make_ref_counted<MockFrameTransformer>();
rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate = rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate =
new rtc::RefCountedObject<ChannelSendFrameTransformerDelegate>( rtc::make_ref_counted<ChannelSendFrameTransformerDelegate>(
ChannelSendFrameTransformerDelegate::SendFrameCallback(), ChannelSendFrameTransformerDelegate::SendFrameCallback(),
mock_frame_transformer, nullptr); mock_frame_transformer, nullptr);
EXPECT_CALL(*mock_frame_transformer, UnregisterTransformedFrameCallback); EXPECT_CALL(*mock_frame_transformer, UnregisterTransformedFrameCallback);
@ -82,10 +82,10 @@ TEST(ChannelSendFrameTransformerDelegateTest,
TransformRunsChannelSendCallback) { TransformRunsChannelSendCallback) {
TaskQueueForTest channel_queue("channel_queue"); TaskQueueForTest channel_queue("channel_queue");
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer = rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
new rtc::RefCountedObject<NiceMock<MockFrameTransformer>>(); rtc::make_ref_counted<NiceMock<MockFrameTransformer>>();
MockChannelSend mock_channel; MockChannelSend mock_channel;
rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate = rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate =
new rtc::RefCountedObject<ChannelSendFrameTransformerDelegate>( rtc::make_ref_counted<ChannelSendFrameTransformerDelegate>(
mock_channel.callback(), mock_frame_transformer, &channel_queue); mock_channel.callback(), mock_frame_transformer, &channel_queue);
rtc::scoped_refptr<TransformedFrameCallback> callback; rtc::scoped_refptr<TransformedFrameCallback> callback;
EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameCallback) EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameCallback)
@ -112,10 +112,10 @@ TEST(ChannelSendFrameTransformerDelegateTest,
OnTransformedDoesNotRunChannelSendCallbackAfterReset) { OnTransformedDoesNotRunChannelSendCallbackAfterReset) {
TaskQueueForTest channel_queue("channel_queue"); TaskQueueForTest channel_queue("channel_queue");
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer = rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
new rtc::RefCountedObject<testing::NiceMock<MockFrameTransformer>>(); rtc::make_ref_counted<testing::NiceMock<MockFrameTransformer>>();
MockChannelSend mock_channel; MockChannelSend mock_channel;
rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate = rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate =
new rtc::RefCountedObject<ChannelSendFrameTransformerDelegate>( rtc::make_ref_counted<ChannelSendFrameTransformerDelegate>(
mock_channel.callback(), mock_frame_transformer, &channel_queue); mock_channel.callback(), mock_frame_transformer, &channel_queue);
delegate->Reset(); delegate->Reset();

2
audio/voip/test/audio_channel_unittest.cc
View File

@ -65,7 +65,7 @@ class AudioChannelTest : public ::testing::Test {
// Also this uses the same transport object for different audio channel to // Also this uses the same transport object for different audio channel to
// simplify network routing logic. // simplify network routing logic.
rtc::scoped_refptr<AudioChannel> audio_channel = rtc::scoped_refptr<AudioChannel> audio_channel =
new rtc::RefCountedObject<AudioChannel>( rtc::make_ref_counted<AudioChannel>(
&transport_, ssrc, task_queue_factory_.get(), process_thread_.get(), &transport_, ssrc, task_queue_factory_.get(), process_thread_.get(),
audio_mixer_.get(), decoder_factory_); audio_mixer_.get(), decoder_factory_);
audio_channel->SetEncoder(kPcmuPayload, kPcmuFormat, audio_channel->SetEncoder(kPcmuPayload, kPcmuFormat,

2
audio/voip/test/voip_core_unittest.cc
View File

@ -39,7 +39,7 @@ class VoipCoreTest : public ::testing::Test {
auto encoder_factory = CreateBuiltinAudioEncoderFactory(); auto encoder_factory = CreateBuiltinAudioEncoderFactory();
auto decoder_factory = CreateBuiltinAudioDecoderFactory(); auto decoder_factory = CreateBuiltinAudioDecoderFactory();
rtc::scoped_refptr<AudioProcessing> audio_processing = rtc::scoped_refptr<AudioProcessing> audio_processing =
new rtc::RefCountedObject<NiceMock<test::MockAudioProcessing>>(); rtc::make_ref_counted<NiceMock<test::MockAudioProcessing>>();
auto process_thread = std::make_unique<NiceMock<MockProcessThread>>(); auto process_thread = std::make_unique<NiceMock<MockProcessThread>>();
// Hold the pointer to use for testing. // Hold the pointer to use for testing.

2
audio/voip/voip_core.cc
View File

@ -138,7 +138,7 @@ ChannelId VoipCore::CreateChannel(Transport* transport,
} }
rtc::scoped_refptr<AudioChannel> channel = rtc::scoped_refptr<AudioChannel> channel =
new rtc::RefCountedObject<AudioChannel>( rtc::make_ref_counted<AudioChannel>(
transport, local_ssrc.value(), task_queue_factory_.get(), transport, local_ssrc.value(), task_queue_factory_.get(),
process_thread_.get(), audio_mixer_.get(), decoder_factory_); process_thread_.get(), audio_mixer_.get(), decoder_factory_);

2
call/adaptation/broadcast_resource_listener.cc
View File

@ -83,7 +83,7 @@ BroadcastResourceListener::CreateAdapterResource() {
MutexLock lock(&lock_); MutexLock lock(&lock_);
RTC_DCHECK(is_listening_); RTC_DCHECK(is_listening_);
rtc::scoped_refptr<AdapterResource> adapter = rtc::scoped_refptr<AdapterResource> adapter =
new rtc::RefCountedObject<AdapterResource>(source_resource_->Name() + rtc::make_ref_counted<AdapterResource>(source_resource_->Name() +
"Adapter"); "Adapter");
adapters_.push_back(adapter); adapters_.push_back(adapter);
return adapter; return adapter;

2
call/adaptation/resource_adaptation_processor.cc
View File

@ -72,7 +72,7 @@ ResourceAdaptationProcessor::ResourceAdaptationProcessor(
VideoStreamAdapter* stream_adapter) VideoStreamAdapter* stream_adapter)
: task_queue_(nullptr), : task_queue_(nullptr),
resource_listener_delegate_( resource_listener_delegate_(
new rtc::RefCountedObject<ResourceListenerDelegate>(this)), rtc::make_ref_counted<ResourceListenerDelegate>(this)),
resources_(), resources_(),
stream_adapter_(stream_adapter), stream_adapter_(stream_adapter),
last_reported_source_restrictions_(), last_reported_source_restrictions_(),

2
call/adaptation/test/fake_resource.cc
View File

@ -19,7 +19,7 @@ namespace webrtc {
// static // static
rtc::scoped_refptr<FakeResource> FakeResource::Create(std::string name) { rtc::scoped_refptr<FakeResource> FakeResource::Create(std::string name) {
return new rtc::RefCountedObject<FakeResource>(name); return rtc::make_ref_counted<FakeResource>(name);
} }
FakeResource::FakeResource(std::string name) FakeResource::FakeResource(std::string name)

2
call/call_perf_tests.cc
View File

@ -834,7 +834,7 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
bitrate_allocator_factory_.get(); bitrate_allocator_factory_.get();
encoder_config->max_bitrate_bps = 2 * kReconfigureThresholdKbps * 1000; encoder_config->max_bitrate_bps = 2 * kReconfigureThresholdKbps * 1000;
encoder_config->video_stream_factory = encoder_config->video_stream_factory =
new rtc::RefCountedObject<VideoStreamFactory>(); rtc::make_ref_counted<VideoStreamFactory>();
encoder_config_ = encoder_config->Copy(); encoder_config_ = encoder_config->Copy();
} }

14
call/call_unittest.cc
View File

@ -50,14 +50,14 @@ struct CallHelper {
task_queue_factory_ = webrtc::CreateDefaultTaskQueueFactory(); task_queue_factory_ = webrtc::CreateDefaultTaskQueueFactory();
webrtc::AudioState::Config audio_state_config; webrtc::AudioState::Config audio_state_config;
audio_state_config.audio_mixer = audio_state_config.audio_mixer =
new rtc::RefCountedObject<webrtc::test::MockAudioMixer>(); rtc::make_ref_counted<webrtc::test::MockAudioMixer>();
audio_state_config.audio_processing = audio_state_config.audio_processing =
use_null_audio_processing use_null_audio_processing
? nullptr ? nullptr
: new rtc::RefCountedObject< : rtc::make_ref_counted<
NiceMock<webrtc::test::MockAudioProcessing>>(); NiceMock<webrtc::test::MockAudioProcessing>>();
audio_state_config.audio_device_module = audio_state_config.audio_device_module =
new rtc::RefCountedObject<webrtc::test::MockAudioDeviceModule>(); rtc::make_ref_counted<webrtc::test::MockAudioDeviceModule>();
webrtc::Call::Config config(&event_log_); webrtc::Call::Config config(&event_log_);
config.audio_state = webrtc::AudioState::Create(audio_state_config); config.audio_state = webrtc::AudioState::Create(audio_state_config);
config.task_queue_factory = task_queue_factory_.get(); config.task_queue_factory = task_queue_factory_.get();
@ -118,7 +118,7 @@ TEST(CallTest, CreateDestroy_AudioReceiveStream) {
config.rtp.remote_ssrc = 42; config.rtp.remote_ssrc = 42;
config.rtcp_send_transport = &rtcp_send_transport; config.rtcp_send_transport = &rtcp_send_transport;
config.decoder_factory = config.decoder_factory =
new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>(); rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>();
AudioReceiveStream* stream = call->CreateAudioReceiveStream(config); AudioReceiveStream* stream = call->CreateAudioReceiveStream(config);
EXPECT_NE(stream, nullptr); EXPECT_NE(stream, nullptr);
call->DestroyAudioReceiveStream(stream); call->DestroyAudioReceiveStream(stream);
@ -157,7 +157,7 @@ TEST(CallTest, CreateDestroy_AudioReceiveStreams) {
MockTransport rtcp_send_transport; MockTransport rtcp_send_transport;
config.rtcp_send_transport = &rtcp_send_transport; config.rtcp_send_transport = &rtcp_send_transport;
config.decoder_factory = config.decoder_factory =
new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>(); rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>();
std::list<AudioReceiveStream*> streams; std::list<AudioReceiveStream*> streams;
for (int i = 0; i < 2; ++i) { for (int i = 0; i < 2; ++i) {
for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) {
@ -187,7 +187,7 @@ TEST(CallTest, CreateDestroy_AssociateAudioSendReceiveStreams_RecvFirst) {
recv_config.rtp.local_ssrc = 777; recv_config.rtp.local_ssrc = 777;
recv_config.rtcp_send_transport = &rtcp_send_transport; recv_config.rtcp_send_transport = &rtcp_send_transport;
recv_config.decoder_factory = recv_config.decoder_factory =
new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>(); rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>();
AudioReceiveStream* recv_stream = AudioReceiveStream* recv_stream =
call->CreateAudioReceiveStream(recv_config); call->CreateAudioReceiveStream(recv_config);
EXPECT_NE(recv_stream, nullptr); EXPECT_NE(recv_stream, nullptr);
@ -226,7 +226,7 @@ TEST(CallTest, CreateDestroy_AssociateAudioSendReceiveStreams_SendFirst) {
recv_config.rtp.local_ssrc = 777; recv_config.rtp.local_ssrc = 777;
recv_config.rtcp_send_transport = &rtcp_send_transport; recv_config.rtcp_send_transport = &rtcp_send_transport;
recv_config.decoder_factory = recv_config.decoder_factory =
new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>(); rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>();
AudioReceiveStream* recv_stream = AudioReceiveStream* recv_stream =
call->CreateAudioReceiveStream(recv_config); call->CreateAudioReceiveStream(recv_config);
EXPECT_NE(recv_stream, nullptr); EXPECT_NE(recv_stream, nullptr);

2
call/rampup_tests.cc
View File

@ -160,7 +160,7 @@ void RampUpTester::ModifyVideoConfigs(
encoder_config->number_of_streams = num_video_streams_; encoder_config->number_of_streams = num_video_streams_;
encoder_config->max_bitrate_bps = 2000000; encoder_config->max_bitrate_bps = 2000000;
encoder_config->video_stream_factory = encoder_config->video_stream_factory =
new rtc::RefCountedObject<RampUpTester::VideoStreamFactory>(); rtc::make_ref_counted<RampUpTester::VideoStreamFactory>();
if (num_video_streams_ == 1) { if (num_video_streams_ == 1) {
// For single stream rampup until 1mbps // For single stream rampup until 1mbps
expected_bitrate_bps_ = kSingleStreamTargetBps; expected_bitrate_bps_ = kSingleStreamTargetBps;

2
call/rtp_video_sender_unittest.cc
View File

@ -891,7 +891,7 @@ TEST(RtpVideoSenderTest, CanSetZeroBitrate) {
TEST(RtpVideoSenderTest, SimulcastSenderRegistersFrameTransformers) { TEST(RtpVideoSenderTest, SimulcastSenderRegistersFrameTransformers) {
rtc::scoped_refptr<MockFrameTransformer> transformer = rtc::scoped_refptr<MockFrameTransformer> transformer =
new rtc::RefCountedObject<MockFrameTransformer>(); rtc::make_ref_counted<MockFrameTransformer>();
EXPECT_CALL(*transformer, RegisterTransformedFrameSinkCallback(_, kSsrc1)); EXPECT_CALL(*transformer, RegisterTransformedFrameSinkCallback(_, kSsrc1));
EXPECT_CALL(*transformer, RegisterTransformedFrameSinkCallback(_, kSsrc2)); EXPECT_CALL(*transformer, RegisterTransformedFrameSinkCallback(_, kSsrc2));

8
common_video/video_frame_buffer.cc
View File

@ -208,7 +208,7 @@ rtc::scoped_refptr<I420BufferInterface> WrapI420Buffer(
int v_stride, int v_stride,
std::function<void()> no_longer_used) { std::function<void()> no_longer_used) {
return rtc::scoped_refptr<I420BufferInterface>( return rtc::scoped_refptr<I420BufferInterface>(
new rtc::RefCountedObject<WrappedYuvBuffer<I420BufferInterface>>( rtc::make_ref_counted<WrappedYuvBuffer<I420BufferInterface>>(
width, height, y_plane, y_stride, u_plane, u_stride, v_plane, width, height, y_plane, y_stride, u_plane, u_stride, v_plane,
v_stride, no_longer_used)); v_stride, no_longer_used));
} }
@ -226,7 +226,7 @@ rtc::scoped_refptr<I420ABufferInterface> WrapI420ABuffer(
int a_stride, int a_stride,
std::function<void()> no_longer_used) { std::function<void()> no_longer_used) {
return rtc::scoped_refptr<I420ABufferInterface>( return rtc::scoped_refptr<I420ABufferInterface>(
new rtc::RefCountedObject<WrappedYuvaBuffer<I420ABufferInterface>>( rtc::make_ref_counted<WrappedYuvaBuffer<I420ABufferInterface>>(
width, height, y_plane, y_stride, u_plane, u_stride, v_plane, width, height, y_plane, y_stride, u_plane, u_stride, v_plane,
v_stride, a_plane, a_stride, no_longer_used)); v_stride, a_plane, a_stride, no_longer_used));
} }
@ -242,7 +242,7 @@ rtc::scoped_refptr<I444BufferInterface> WrapI444Buffer(
int v_stride, int v_stride,
std::function<void()> no_longer_used) { std::function<void()> no_longer_used) {
return rtc::scoped_refptr<I444BufferInterface>( return rtc::scoped_refptr<I444BufferInterface>(
new rtc::RefCountedObject<WrappedYuvBuffer<I444BufferBase>>( rtc::make_ref_counted<WrappedYuvBuffer<I444BufferBase>>(
width, height, y_plane, y_stride, u_plane, u_stride, v_plane, width, height, y_plane, y_stride, u_plane, u_stride, v_plane,
v_stride, no_longer_used)); v_stride, no_longer_used));
} }
@ -281,7 +281,7 @@ rtc::scoped_refptr<I010BufferInterface> WrapI010Buffer(
int v_stride, int v_stride,
std::function<void()> no_longer_used) { std::function<void()> no_longer_used) {
return rtc::scoped_refptr<I010BufferInterface>( return rtc::scoped_refptr<I010BufferInterface>(
new rtc::RefCountedObject<WrappedYuv16BBuffer<I010BufferBase>>( rtc::make_ref_counted<WrappedYuv16BBuffer<I010BufferBase>>(
width, height, y_plane, y_stride, u_plane, u_stride, v_plane, width, height, y_plane, y_stride, u_plane, u_stride, v_plane,
v_stride, no_longer_used)); v_stride, no_longer_used));
} }

4
common_video/video_frame_buffer_pool.cc
View File

@ -107,7 +107,7 @@ rtc::scoped_refptr<I420Buffer> VideoFrameBufferPool::CreateI420Buffer(
return nullptr; return nullptr;
// Allocate new buffer. // Allocate new buffer.
rtc::scoped_refptr<I420Buffer> buffer = rtc::scoped_refptr<I420Buffer> buffer =
new rtc::RefCountedObject<I420Buffer>(width, height); rtc::make_ref_counted<I420Buffer>(width, height);
if (zero_initialize_) if (zero_initialize_)
buffer->InitializeData(); buffer->InitializeData();
@ -138,7 +138,7 @@ rtc::scoped_refptr<NV12Buffer> VideoFrameBufferPool::CreateNV12Buffer(
return nullptr; return nullptr;
// Allocate new buffer. // Allocate new buffer.
rtc::scoped_refptr<NV12Buffer> buffer = rtc::scoped_refptr<NV12Buffer> buffer =
new rtc::RefCountedObject<NV12Buffer>(width, height); rtc::make_ref_counted<NV12Buffer>(width, height);
if (zero_initialize_) if (zero_initialize_)
buffer->InitializeData(); buffer->InitializeData();

4
media/engine/simulcast_encoder_adapter_unittest.cc
View File

@ -1006,7 +1006,7 @@ TEST_F(TestSimulcastEncoderAdapterFake,
EXPECT_TRUE(adapter_->GetEncoderInfo().supports_native_handle); EXPECT_TRUE(adapter_->GetEncoderInfo().supports_native_handle);
rtc::scoped_refptr<VideoFrameBuffer> buffer( rtc::scoped_refptr<VideoFrameBuffer> buffer(
new rtc::RefCountedObject<FakeNativeBufferI420>(1280, 720, rtc::make_ref_counted<FakeNativeBufferI420>(1280, 720,
/*allow_to_i420=*/false)); /*allow_to_i420=*/false));
VideoFrame input_frame = VideoFrame::Builder() VideoFrame input_frame = VideoFrame::Builder()
.set_video_frame_buffer(buffer) .set_video_frame_buffer(buffer)
@ -1043,7 +1043,7 @@ TEST_F(TestSimulcastEncoderAdapterFake, NativeHandleForwardingOnlyIfSupported) {
EXPECT_TRUE(adapter_->GetEncoderInfo().supports_native_handle); EXPECT_TRUE(adapter_->GetEncoderInfo().supports_native_handle);
rtc::scoped_refptr<VideoFrameBuffer> buffer( rtc::scoped_refptr<VideoFrameBuffer> buffer(
new rtc::RefCountedObject<FakeNativeBufferI420>(1280, 720, rtc::make_ref_counted<FakeNativeBufferI420>(1280, 720,
/*allow_to_i420=*/true)); /*allow_to_i420=*/true));
VideoFrame input_frame = VideoFrame::Builder() VideoFrame input_frame = VideoFrame::Builder()
.set_video_frame_buffer(buffer) .set_video_frame_buffer(buffer)

8
media/engine/webrtc_video_engine.cc
View File

@ -502,7 +502,7 @@ WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
webrtc::VideoCodecH264 h264_settings = webrtc::VideoCodecH264 h264_settings =
webrtc::VideoEncoder::GetDefaultH264Settings(); webrtc::VideoEncoder::GetDefaultH264Settings();
h264_settings.frameDroppingOn = frame_dropping; h264_settings.frameDroppingOn = frame_dropping;
return new rtc::RefCountedObject< return rtc::make_ref_counted<
webrtc::VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings); webrtc::VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings);
} }
if (absl::EqualsIgnoreCase(codec.name, kVp8CodecName)) { if (absl::EqualsIgnoreCase(codec.name, kVp8CodecName)) {
@ -512,7 +512,7 @@ WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
// VP8 denoising is enabled by default. // VP8 denoising is enabled by default.
vp8_settings.denoisingOn = codec_default_denoising ? true : denoising; vp8_settings.denoisingOn = codec_default_denoising ? true : denoising;
vp8_settings.frameDroppingOn = frame_dropping; vp8_settings.frameDroppingOn = frame_dropping;
return new rtc::RefCountedObject< return rtc::make_ref_counted<
webrtc::VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings); webrtc::VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
} }
if (absl::EqualsIgnoreCase(codec.name, kVp9CodecName)) { if (absl::EqualsIgnoreCase(codec.name, kVp9CodecName)) {
@ -562,7 +562,7 @@ WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
vp9_settings.flexibleMode = vp9_settings.numberOfSpatialLayers > 1; vp9_settings.flexibleMode = vp9_settings.numberOfSpatialLayers > 1;
vp9_settings.interLayerPred = webrtc::InterLayerPredMode::kOn; vp9_settings.interLayerPred = webrtc::InterLayerPredMode::kOn;
} }
return new rtc::RefCountedObject< return rtc::make_ref_counted<
webrtc::VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings); webrtc::VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
} }
return nullptr; return nullptr;
@ -2546,7 +2546,7 @@ WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig(
int max_qp = kDefaultQpMax; int max_qp = kDefaultQpMax;
codec.GetParam(kCodecParamMaxQuantization, &max_qp); codec.GetParam(kCodecParamMaxQuantization, &max_qp);
encoder_config.video_stream_factory = encoder_config.video_stream_factory =
new rtc::RefCountedObject<EncoderStreamFactory>( rtc::make_ref_counted<EncoderStreamFactory>(
codec.name, max_qp, is_screencast, parameters_.conference_mode); codec.name, max_qp, is_screencast, parameters_.conference_mode);
return encoder_config; return encoder_config;

2
media/engine/webrtc_voice_engine.cc
View File

@ -330,7 +330,7 @@ void WebRtcVoiceEngine::Init() {
config.audio_device_module = adm_; config.audio_device_module = adm_;
if (audio_frame_processor_) if (audio_frame_processor_)
config.async_audio_processing_factory = config.async_audio_processing_factory =
new rtc::RefCountedObject<webrtc::AsyncAudioProcessing::Factory>( rtc::make_ref_counted<webrtc::AsyncAudioProcessing::Factory>(
*audio_frame_processor_, *task_queue_factory_); *audio_frame_processor_, *task_queue_factory_);
audio_state_ = webrtc::AudioState::Create(config); audio_state_ = webrtc::AudioState::Create(config);
} }

2
p2p/base/default_ice_transport_factory.cc
View File

@ -44,7 +44,7 @@ DefaultIceTransportFactory::CreateIceTransport(
int component, int component,
IceTransportInit init) { IceTransportInit init) {
BasicIceControllerFactory factory; BasicIceControllerFactory factory;
return new rtc::RefCountedObject<DefaultIceTransport>( return rtc::make_ref_counted<DefaultIceTransport>(
cricket::P2PTransportChannel::Create( cricket::P2PTransportChannel::Create(
transport_name, component, init.port_allocator(), transport_name, component, init.port_allocator(),
init.async_dns_resolver_factory(), init.event_log(), &factory)); init.async_dns_resolver_factory(), init.event_log(), &factory));

2
video/adaptation/encode_usage_resource.cc
View File

@ -21,7 +21,7 @@ namespace webrtc {
// static // static
rtc::scoped_refptr<EncodeUsageResource> EncodeUsageResource::Create( rtc::scoped_refptr<EncodeUsageResource> EncodeUsageResource::Create(
std::unique_ptr<OveruseFrameDetector> overuse_detector) { std::unique_ptr<OveruseFrameDetector> overuse_detector) {
return new rtc::RefCountedObject<EncodeUsageResource>( return rtc::make_ref_counted<EncodeUsageResource>(
std::move(overuse_detector)); std::move(overuse_detector));
} }

2
video/adaptation/pixel_limit_resource.cc
View File

@ -28,7 +28,7 @@ constexpr TimeDelta kResourceUsageCheckIntervalMs = TimeDelta::Seconds(5);
rtc::scoped_refptr<PixelLimitResource> PixelLimitResource::Create( rtc::scoped_refptr<PixelLimitResource> PixelLimitResource::Create(
TaskQueueBase* task_queue, TaskQueueBase* task_queue,
VideoStreamInputStateProvider* input_state_provider) { VideoStreamInputStateProvider* input_state_provider) {
return new rtc::RefCountedObject<PixelLimitResource>(task_queue, return rtc::make_ref_counted<PixelLimitResource>(task_queue,
input_state_provider); input_state_provider);
} }

2
video/adaptation/quality_scaler_resource.cc
View File

@ -22,7 +22,7 @@ namespace webrtc {
// static // static
rtc::scoped_refptr<QualityScalerResource> QualityScalerResource::Create() { rtc::scoped_refptr<QualityScalerResource> QualityScalerResource::Create() {
return new rtc::RefCountedObject<QualityScalerResource>(); return rtc::make_ref_counted<QualityScalerResource>();
} }
QualityScalerResource::QualityScalerResource() QualityScalerResource::QualityScalerResource()

2
video/buffered_frame_decryptor_unittest.cc
View File

@ -86,7 +86,7 @@ class BufferedFrameDecryptorTest : public ::testing::Test,
decrypted_frame_call_count_ = 0; decrypted_frame_call_count_ = 0;
decryption_status_change_count_ = 0; decryption_status_change_count_ = 0;
seq_num_ = 0; seq_num_ = 0;
mock_frame_decryptor_ = new rtc::RefCountedObject<MockFrameDecryptor>(); mock_frame_decryptor_ = rtc::make_ref_counted<MockFrameDecryptor>();
buffered_frame_decryptor_ = buffered_frame_decryptor_ =
std::make_unique<BufferedFrameDecryptor>(this, this); std::make_unique<BufferedFrameDecryptor>(this, this);
buffered_frame_decryptor_->SetFrameDecryptor(mock_frame_decryptor_.get()); buffered_frame_decryptor_->SetFrameDecryptor(mock_frame_decryptor_.get());

7
video/end_to_end_tests/resolution_bitrate_limits_tests.cc
View File

@ -27,8 +27,9 @@ void SetEncoderSpecific(VideoEncoderConfig* encoder_config,
if (type == kVideoCodecVP9) { if (type == kVideoCodecVP9) {
VideoCodecVP9 vp9 = VideoEncoder::GetDefaultVp9Settings(); VideoCodecVP9 vp9 = VideoEncoder::GetDefaultVp9Settings();
vp9.numberOfSpatialLayers = num_spatial_layers; vp9.numberOfSpatialLayers = num_spatial_layers;
encoder_config->encoder_specific_settings = new rtc::RefCountedObject< encoder_config->encoder_specific_settings =
VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9); rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9);
} }
} }
@ -119,7 +120,7 @@ class InitEncodeTest : public test::EndToEndTest,
const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_); const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->codec_type = codec_type; encoder_config->codec_type = codec_type;
encoder_config->video_stream_factory = encoder_config->video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
payload_name_, /*max qp*/ 0, /*screencast*/ false, payload_name_, /*max qp*/ 0, /*screencast*/ false,
/*screenshare enabled*/ false); /*screenshare enabled*/ false);
encoder_config->max_bitrate_bps = -1; encoder_config->max_bitrate_bps = -1;

2
video/end_to_end_tests/rtp_rtcp_tests.cc
View File

@ -316,7 +316,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
} }
GetVideoEncoderConfig()->video_stream_factory = GetVideoEncoderConfig()->video_stream_factory =
new rtc::RefCountedObject<VideoStreamFactory>(); rtc::make_ref_counted<VideoStreamFactory>();
// Use the same total bitrates when sending a single stream to avoid // Use the same total bitrates when sending a single stream to avoid
// lowering the bitrate estimate and requiring a subsequent rampup. // lowering the bitrate estimate and requiring a subsequent rampup.
one_stream = GetVideoEncoderConfig()->Copy(); one_stream = GetVideoEncoderConfig()->Copy();

2
video/frame_encode_metadata_writer.cc
View File

@ -217,7 +217,7 @@ void FrameEncodeMetadataWriter::UpdateBitstream(
buffer, encoded_image->ColorSpace()); buffer, encoded_image->ColorSpace());
encoded_image->SetEncodedData( encoded_image->SetEncodedData(
new rtc::RefCountedObject<EncodedImageBufferWrapper>( rtc::make_ref_counted<EncodedImageBufferWrapper>(
std::move(modified_buffer))); std::move(modified_buffer)));
} }

10
video/quality_scaling_tests.cc
View File

@ -35,14 +35,16 @@ void SetEncoderSpecific(VideoEncoderConfig* encoder_config,
if (type == kVideoCodecVP8) { if (type == kVideoCodecVP8) {
VideoCodecVP8 vp8 = VideoEncoder::GetDefaultVp8Settings(); VideoCodecVP8 vp8 = VideoEncoder::GetDefaultVp8Settings();
vp8.automaticResizeOn = automatic_resize; vp8.automaticResizeOn = automatic_resize;
encoder_config->encoder_specific_settings = new rtc::RefCountedObject< encoder_config->encoder_specific_settings =
VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8); rtc::make_ref_counted<VideoEncoderConfig::Vp8EncoderSpecificSettings>(
vp8);
} else if (type == kVideoCodecVP9) { } else if (type == kVideoCodecVP9) {
VideoCodecVP9 vp9 = VideoEncoder::GetDefaultVp9Settings(); VideoCodecVP9 vp9 = VideoEncoder::GetDefaultVp9Settings();
vp9.automaticResizeOn = automatic_resize; vp9.automaticResizeOn = automatic_resize;
vp9.numberOfSpatialLayers = num_spatial_layers; vp9.numberOfSpatialLayers = num_spatial_layers;
encoder_config->encoder_specific_settings = new rtc::RefCountedObject< encoder_config->encoder_specific_settings =
VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9); rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9);
} }
} }
} // namespace } // namespace

6
video/rtp_video_stream_receiver.cc
View File

@ -333,8 +333,8 @@ RtpVideoStreamReceiver::RtpVideoStreamReceiver(
} }
if (frame_transformer) { if (frame_transformer) {
frame_transformer_delegate_ = new rtc::RefCountedObject< frame_transformer_delegate_ =
RtpVideoStreamReceiverFrameTransformerDelegate>( rtc::make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
this, std::move(frame_transformer), rtc::Thread::Current(), this, std::move(frame_transformer), rtc::Thread::Current(),
config_.rtp.remote_ssrc); config_.rtp.remote_ssrc);
frame_transformer_delegate_->Init(); frame_transformer_delegate_->Init();
@ -919,7 +919,7 @@ void RtpVideoStreamReceiver::SetDepacketizerToDecoderFrameTransformer(
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) { rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
RTC_DCHECK_RUN_ON(&network_tc_); RTC_DCHECK_RUN_ON(&network_tc_);
frame_transformer_delegate_ = frame_transformer_delegate_ =
new rtc::RefCountedObject<RtpVideoStreamReceiverFrameTransformerDelegate>( rtc::make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
this, std::move(frame_transformer), rtc::Thread::Current(), this, std::move(frame_transformer), rtc::Thread::Current(),
config_.rtp.remote_ssrc); config_.rtp.remote_ssrc);
frame_transformer_delegate_->Init(); frame_transformer_delegate_->Init();

6
video/rtp_video_stream_receiver2.cc
View File

@ -307,8 +307,8 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2(
} }
if (frame_transformer) { if (frame_transformer) {
frame_transformer_delegate_ = new rtc::RefCountedObject< frame_transformer_delegate_ =
RtpVideoStreamReceiverFrameTransformerDelegate>( rtc::make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
this, std::move(frame_transformer), rtc::Thread::Current(), this, std::move(frame_transformer), rtc::Thread::Current(),
config_.rtp.remote_ssrc); config_.rtp.remote_ssrc);
frame_transformer_delegate_->Init(); frame_transformer_delegate_->Init();
@ -882,7 +882,7 @@ void RtpVideoStreamReceiver2::SetDepacketizerToDecoderFrameTransformer(
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) { rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK_RUN_ON(&worker_task_checker_);
frame_transformer_delegate_ = frame_transformer_delegate_ =
new rtc::RefCountedObject<RtpVideoStreamReceiverFrameTransformerDelegate>( rtc::make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
this, std::move(frame_transformer), rtc::Thread::Current(), this, std::move(frame_transformer), rtc::Thread::Current(),
config_.rtp.remote_ssrc); config_.rtp.remote_ssrc);
frame_transformer_delegate_->Init(); frame_transformer_delegate_->Init();

2
video/rtp_video_stream_receiver2_unittest.cc
View File

@ -1120,7 +1120,7 @@ TEST_F(RtpVideoStreamReceiver2DependencyDescriptorTest,
TEST_F(RtpVideoStreamReceiver2Test, TransformFrame) { TEST_F(RtpVideoStreamReceiver2Test, TransformFrame) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer = rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
new rtc::RefCountedObject<testing::NiceMock<MockFrameTransformer>>(); rtc::make_ref_counted<testing::NiceMock<MockFrameTransformer>>();
EXPECT_CALL(*mock_frame_transformer, EXPECT_CALL(*mock_frame_transformer,
RegisterTransformedFrameSinkCallback(_, config_.rtp.remote_ssrc)); RegisterTransformedFrameSinkCallback(_, config_.rtp.remote_ssrc));
auto receiver = std::make_unique<RtpVideoStreamReceiver2>( auto receiver = std::make_unique<RtpVideoStreamReceiver2>(

38
video/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc
View File

@ -61,10 +61,9 @@ class TestRtpVideoFrameReceiver : public RtpVideoFrameReceiver {
TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest, TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
RegisterTransformedFrameCallbackSinkOnInit) { RegisterTransformedFrameCallbackSinkOnInit) {
TestRtpVideoFrameReceiver receiver; TestRtpVideoFrameReceiver receiver;
rtc::scoped_refptr<MockFrameTransformer> frame_transformer( auto frame_transformer(rtc::make_ref_counted<MockFrameTransformer>());
new rtc::RefCountedObject<MockFrameTransformer>()); auto delegate(
rtc::scoped_refptr<RtpVideoStreamReceiverFrameTransformerDelegate> delegate( rtc::make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
new rtc::RefCountedObject<RtpVideoStreamReceiverFrameTransformerDelegate>(
&receiver, frame_transformer, rtc::Thread::Current(), &receiver, frame_transformer, rtc::Thread::Current(),
/*remote_ssrc*/ 1111)); /*remote_ssrc*/ 1111));
EXPECT_CALL(*frame_transformer, EXPECT_CALL(*frame_transformer,
@ -75,10 +74,9 @@ TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest, TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
UnregisterTransformedFrameSinkCallbackOnReset) { UnregisterTransformedFrameSinkCallbackOnReset) {
TestRtpVideoFrameReceiver receiver; TestRtpVideoFrameReceiver receiver;
rtc::scoped_refptr<MockFrameTransformer> frame_transformer( auto frame_transformer(rtc::make_ref_counted<MockFrameTransformer>());
new rtc::RefCountedObject<MockFrameTransformer>()); auto delegate(
rtc::scoped_refptr<RtpVideoStreamReceiverFrameTransformerDelegate> delegate( rtc::make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
new rtc::RefCountedObject<RtpVideoStreamReceiverFrameTransformerDelegate>(
&receiver, frame_transformer, rtc::Thread::Current(), &receiver, frame_transformer, rtc::Thread::Current(),
/*remote_ssrc*/ 1111)); /*remote_ssrc*/ 1111));
EXPECT_CALL(*frame_transformer, UnregisterTransformedFrameSinkCallback(1111)); EXPECT_CALL(*frame_transformer, UnregisterTransformedFrameSinkCallback(1111));
@ -87,10 +85,10 @@ TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest, TransformFrame) { TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest, TransformFrame) {
TestRtpVideoFrameReceiver receiver; TestRtpVideoFrameReceiver receiver;
rtc::scoped_refptr<MockFrameTransformer> frame_transformer( auto frame_transformer(
new rtc::RefCountedObject<testing::NiceMock<MockFrameTransformer>>()); rtc::make_ref_counted<testing::NiceMock<MockFrameTransformer>>());
rtc::scoped_refptr<RtpVideoStreamReceiverFrameTransformerDelegate> delegate( auto delegate(
new rtc::RefCountedObject<RtpVideoStreamReceiverFrameTransformerDelegate>( rtc::make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
&receiver, frame_transformer, rtc::Thread::Current(), &receiver, frame_transformer, rtc::Thread::Current(),
/*remote_ssrc*/ 1111)); /*remote_ssrc*/ 1111));
auto frame = CreateRtpFrameObject(); auto frame = CreateRtpFrameObject();
@ -101,10 +99,10 @@ TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest, TransformFrame) {
TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest, TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
ManageFrameOnTransformedFrame) { ManageFrameOnTransformedFrame) {
TestRtpVideoFrameReceiver receiver; TestRtpVideoFrameReceiver receiver;
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer( auto mock_frame_transformer(
new rtc::RefCountedObject<NiceMock<MockFrameTransformer>>()); rtc::make_ref_counted<NiceMock<MockFrameTransformer>>());
rtc::scoped_refptr<RtpVideoStreamReceiverFrameTransformerDelegate> delegate = auto delegate =
new rtc::RefCountedObject<RtpVideoStreamReceiverFrameTransformerDelegate>( rtc::make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
&receiver, mock_frame_transformer, rtc::Thread::Current(), &receiver, mock_frame_transformer, rtc::Thread::Current(),
/*remote_ssrc*/ 1111); /*remote_ssrc*/ 1111);
@ -127,10 +125,10 @@ TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest, TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
TransformableFrameMetadataHasCorrectValue) { TransformableFrameMetadataHasCorrectValue) {
TestRtpVideoFrameReceiver receiver; TestRtpVideoFrameReceiver receiver;
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer = auto mock_frame_transformer =
new rtc::RefCountedObject<NiceMock<MockFrameTransformer>>(); rtc::make_ref_counted<NiceMock<MockFrameTransformer>>();
rtc::scoped_refptr<RtpVideoStreamReceiverFrameTransformerDelegate> delegate = auto delegate =
new rtc::RefCountedObject<RtpVideoStreamReceiverFrameTransformerDelegate>( rtc::make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
&receiver, mock_frame_transformer, rtc::Thread::Current(), 1111); &receiver, mock_frame_transformer, rtc::Thread::Current(), 1111);
delegate->Init(); delegate->Init();
RTPVideoHeader video_header; RTPVideoHeader video_header;

4
video/rtp_video_stream_receiver_unittest.cc
View File

@ -1165,8 +1165,8 @@ TEST_F(RtpVideoStreamReceiverDeathTest, RepeatedSecondarySinkDisallowed) {
#endif #endif
TEST_F(RtpVideoStreamReceiverTest, TransformFrame) { TEST_F(RtpVideoStreamReceiverTest, TransformFrame) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer = auto mock_frame_transformer =
new rtc::RefCountedObject<testing::NiceMock<MockFrameTransformer>>(); rtc::make_ref_counted<testing::NiceMock<MockFrameTransformer>>();
EXPECT_CALL(*mock_frame_transformer, EXPECT_CALL(*mock_frame_transformer,
RegisterTransformedFrameSinkCallback(_, config_.rtp.remote_ssrc)); RegisterTransformedFrameSinkCallback(_, config_.rtp.remote_ssrc));
auto receiver = std::make_unique<RtpVideoStreamReceiver>( auto receiver = std::make_unique<RtpVideoStreamReceiver>(

24
video/video_quality_test.cc
View File

@ -626,7 +626,7 @@ void VideoQualityTest::FillScalabilitySettings(
encoder_config.spatial_layers = params->ss[video_idx].spatial_layers; encoder_config.spatial_layers = params->ss[video_idx].spatial_layers;
encoder_config.simulcast_layers = std::vector<VideoStream>(num_streams); encoder_config.simulcast_layers = std::vector<VideoStream>(num_streams);
encoder_config.video_stream_factory = encoder_config.video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
params->video[video_idx].codec, kDefaultMaxQp, params->video[video_idx].codec, kDefaultMaxQp,
params->screenshare[video_idx].enabled, true); params->screenshare[video_idx].enabled, true);
params->ss[video_idx].streams = params->ss[video_idx].streams =
@ -800,7 +800,7 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
params_.ss[video_idx].streams; params_.ss[video_idx].streams;
} }
video_encoder_configs_[video_idx].video_stream_factory = video_encoder_configs_[video_idx].video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
params_.video[video_idx].codec, params_.video[video_idx].codec,
params_.ss[video_idx].streams[0].max_qp, params_.ss[video_idx].streams[0].max_qp,
params_.screenshare[video_idx].enabled, true); params_.screenshare[video_idx].enabled, true);
@ -829,7 +829,7 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
vp8_settings.numberOfTemporalLayers = static_cast<unsigned char>( vp8_settings.numberOfTemporalLayers = static_cast<unsigned char>(
params_.video[video_idx].num_temporal_layers); params_.video[video_idx].num_temporal_layers);
video_encoder_configs_[video_idx].encoder_specific_settings = video_encoder_configs_[video_idx].encoder_specific_settings =
new rtc::RefCountedObject< rtc::make_ref_counted<
VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings); VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
} else if (params_.video[video_idx].codec == "VP9") { } else if (params_.video[video_idx].codec == "VP9") {
VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings(); VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
@ -846,7 +846,7 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
vp9_settings.flexibleMode = true; vp9_settings.flexibleMode = true;
} }
video_encoder_configs_[video_idx].encoder_specific_settings = video_encoder_configs_[video_idx].encoder_specific_settings =
new rtc::RefCountedObject< rtc::make_ref_counted<
VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings); VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
} }
} else if (params_.ss[video_idx].num_spatial_layers > 1) { } else if (params_.ss[video_idx].num_spatial_layers > 1) {
@ -860,8 +860,8 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
vp9_settings.interLayerPred = params_.ss[video_idx].inter_layer_pred; vp9_settings.interLayerPred = params_.ss[video_idx].inter_layer_pred;
vp9_settings.automaticResizeOn = false; vp9_settings.automaticResizeOn = false;
video_encoder_configs_[video_idx].encoder_specific_settings = video_encoder_configs_[video_idx].encoder_specific_settings =
new rtc::RefCountedObject< rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings); vp9_settings);
RTC_DCHECK_EQ(video_encoder_configs_[video_idx].simulcast_layers.size(), RTC_DCHECK_EQ(video_encoder_configs_[video_idx].simulcast_layers.size(),
1); 1);
// Min bitrate will be enforced by spatial layer config instead. // Min bitrate will be enforced by spatial layer config instead.
@ -871,7 +871,7 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings(); VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
vp8_settings.automaticResizeOn = true; vp8_settings.automaticResizeOn = true;
video_encoder_configs_[video_idx].encoder_specific_settings = video_encoder_configs_[video_idx].encoder_specific_settings =
new rtc::RefCountedObject< rtc::make_ref_counted<
VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings); VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
} else if (params_.video[video_idx].codec == "VP9") { } else if (params_.video[video_idx].codec == "VP9") {
VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings(); VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
@ -879,7 +879,7 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
vp9_settings.automaticResizeOn = vp9_settings.automaticResizeOn =
params_.ss[video_idx].num_spatial_layers == 1; params_.ss[video_idx].num_spatial_layers == 1;
video_encoder_configs_[video_idx].encoder_specific_settings = video_encoder_configs_[video_idx].encoder_specific_settings =
new rtc::RefCountedObject< rtc::make_ref_counted<
VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings); VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
} else if (params_.video[video_idx].codec == "H264") { } else if (params_.video[video_idx].codec == "H264") {
// Quality scaling is always on for H.264. // Quality scaling is always on for H.264.
@ -898,18 +898,18 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings(); VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
vp8_settings.automaticResizeOn = false; vp8_settings.automaticResizeOn = false;
video_encoder_configs_[video_idx].encoder_specific_settings = video_encoder_configs_[video_idx].encoder_specific_settings =
new rtc::RefCountedObject< rtc::make_ref_counted<
VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings); VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
} else if (params_.video[video_idx].codec == "VP9") { } else if (params_.video[video_idx].codec == "VP9") {
VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings(); VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
vp9_settings.automaticResizeOn = false; vp9_settings.automaticResizeOn = false;
video_encoder_configs_[video_idx].encoder_specific_settings = video_encoder_configs_[video_idx].encoder_specific_settings =
new rtc::RefCountedObject< rtc::make_ref_counted<
VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings); VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
} else if (params_.video[video_idx].codec == "H264") { } else if (params_.video[video_idx].codec == "H264") {
VideoCodecH264 h264_settings = VideoEncoder::GetDefaultH264Settings(); VideoCodecH264 h264_settings = VideoEncoder::GetDefaultH264Settings();
video_encoder_configs_[video_idx].encoder_specific_settings = video_encoder_configs_[video_idx].encoder_specific_settings =
new rtc::RefCountedObject< rtc::make_ref_counted<
VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings); VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings);
} }
} }
@ -986,7 +986,7 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
thumbnail_encoder_config.max_bitrate_bps = 50000; thumbnail_encoder_config.max_bitrate_bps = 50000;
std::vector<VideoStream> streams{params_.ss[0].streams[0]}; std::vector<VideoStream> streams{params_.ss[0].streams[0]};
thumbnail_encoder_config.video_stream_factory = thumbnail_encoder_config.video_stream_factory =
new rtc::RefCountedObject<VideoStreamFactory>(streams); rtc::make_ref_counted<VideoStreamFactory>(streams);
thumbnail_encoder_config.spatial_layers = params_.ss[0].spatial_layers; thumbnail_encoder_config.spatial_layers = params_.ss[0].spatial_layers;
thumbnail_encoder_configs_.push_back(thumbnail_encoder_config.Copy()); thumbnail_encoder_configs_.push_back(thumbnail_encoder_config.Copy());

19
video/video_send_stream_tests.cc
View File

@ -2531,8 +2531,8 @@ void VideoCodecConfigObserver<VideoCodecH264>::VerifyCodecSpecifics(
template <> template <>
rtc::scoped_refptr<VideoEncoderConfig::EncoderSpecificSettings> rtc::scoped_refptr<VideoEncoderConfig::EncoderSpecificSettings>
VideoCodecConfigObserver<VideoCodecH264>::GetEncoderSpecificSettings() const { VideoCodecConfigObserver<VideoCodecH264>::GetEncoderSpecificSettings() const {
return new rtc::RefCountedObject< return rtc::make_ref_counted<VideoEncoderConfig::H264EncoderSpecificSettings>(
VideoEncoderConfig::H264EncoderSpecificSettings>(encoder_settings_); encoder_settings_);
} }
template <> template <>
@ -2565,8 +2565,8 @@ void VideoCodecConfigObserver<VideoCodecVP8>::VerifyCodecSpecifics(
template <> template <>
rtc::scoped_refptr<VideoEncoderConfig::EncoderSpecificSettings> rtc::scoped_refptr<VideoEncoderConfig::EncoderSpecificSettings>
VideoCodecConfigObserver<VideoCodecVP8>::GetEncoderSpecificSettings() const { VideoCodecConfigObserver<VideoCodecVP8>::GetEncoderSpecificSettings() const {
return new rtc::RefCountedObject< return rtc::make_ref_counted<VideoEncoderConfig::Vp8EncoderSpecificSettings>(
VideoEncoderConfig::Vp8EncoderSpecificSettings>(encoder_settings_); encoder_settings_);
} }
template <> template <>
@ -2599,8 +2599,8 @@ void VideoCodecConfigObserver<VideoCodecVP9>::VerifyCodecSpecifics(
template <> template <>
rtc::scoped_refptr<VideoEncoderConfig::EncoderSpecificSettings> rtc::scoped_refptr<VideoEncoderConfig::EncoderSpecificSettings>
VideoCodecConfigObserver<VideoCodecVP9>::GetEncoderSpecificSettings() const { VideoCodecConfigObserver<VideoCodecVP9>::GetEncoderSpecificSettings() const {
return new rtc::RefCountedObject< return rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
VideoEncoderConfig::Vp9EncoderSpecificSettings>(encoder_settings_); encoder_settings_);
} }
TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) { TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
@ -2726,7 +2726,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
send_config->encoder_settings.encoder_factory = &encoder_factory_; send_config->encoder_settings.encoder_factory = &encoder_factory_;
EXPECT_EQ(1u, encoder_config->number_of_streams); EXPECT_EQ(1u, encoder_config->number_of_streams);
encoder_config->video_stream_factory = encoder_config->video_stream_factory =
new rtc::RefCountedObject<VideoStreamFactory>(); rtc::make_ref_counted<VideoStreamFactory>();
EXPECT_EQ(1u, encoder_config->simulcast_layers.size()); EXPECT_EQ(1u, encoder_config->simulcast_layers.size());
encoder_config->simulcast_layers[0].num_temporal_layers = 2; encoder_config->simulcast_layers[0].num_temporal_layers = 2;
encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen; encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
@ -3064,8 +3064,9 @@ class Vp9HeaderObserver : public test::SendTest {
send_config->rtp.payload_name = "VP9"; send_config->rtp.payload_name = "VP9";
send_config->rtp.payload_type = kVp9PayloadType; send_config->rtp.payload_type = kVp9PayloadType;
ModifyVideoConfigsHook(send_config, receive_configs, encoder_config); ModifyVideoConfigsHook(send_config, receive_configs, encoder_config);
encoder_config->encoder_specific_settings = new rtc::RefCountedObject< encoder_config->encoder_specific_settings =
VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings_); rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings_);
EXPECT_EQ(1u, encoder_config->number_of_streams); EXPECT_EQ(1u, encoder_config->number_of_streams);
EXPECT_EQ(1u, encoder_config->simulcast_layers.size()); EXPECT_EQ(1u, encoder_config->simulcast_layers.size());
encoder_config->simulcast_layers[0].num_temporal_layers = encoder_config->simulcast_layers[0].num_temporal_layers =

66
video/video_stream_encoder_unittest.cc
View File

@ -144,7 +144,7 @@ class FakeNativeBuffer : public webrtc::VideoFrameBuffer {
int crop_height, int crop_height,
int scaled_width, int scaled_width,
int scaled_height) override { int scaled_height) override {
return new rtc::RefCountedObject<FakeNativeBuffer>(nullptr, scaled_width, return rtc::make_ref_counted<FakeNativeBuffer>(nullptr, scaled_width,
scaled_height); scaled_height);
} }
@ -517,7 +517,7 @@ class AdaptingFrameForwarder : public test::FrameForwarder {
&cropped_height, &out_width, &out_height)) { &cropped_height, &out_width, &out_height)) {
VideoFrame adapted_frame = VideoFrame adapted_frame =
VideoFrame::Builder() VideoFrame::Builder()
.set_video_frame_buffer(new rtc::RefCountedObject<TestBuffer>( .set_video_frame_buffer(rtc::make_ref_counted<TestBuffer>(
nullptr, out_width, out_height)) nullptr, out_width, out_height))
.set_ntp_time_ms(video_frame.ntp_time_ms()) .set_ntp_time_ms(video_frame.ntp_time_ms())
.set_timestamp_ms(99) .set_timestamp_ms(99)
@ -715,8 +715,8 @@ class VideoStreamEncoderTest : public ::testing::Test {
vp9_settings.numberOfSpatialLayers = num_spatial_layers; vp9_settings.numberOfSpatialLayers = num_spatial_layers;
vp9_settings.automaticResizeOn = num_spatial_layers <= 1; vp9_settings.automaticResizeOn = num_spatial_layers <= 1;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject< rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings); vp9_settings);
} }
ConfigureEncoder(std::move(video_encoder_config), allocation_callback_type); ConfigureEncoder(std::move(video_encoder_config), allocation_callback_type);
} }
@ -724,7 +724,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
VideoFrame CreateFrame(int64_t ntp_time_ms, VideoFrame CreateFrame(int64_t ntp_time_ms,
rtc::Event* destruction_event) const { rtc::Event* destruction_event) const {
return VideoFrame::Builder() return VideoFrame::Builder()
.set_video_frame_buffer(new rtc::RefCountedObject<TestBuffer>( .set_video_frame_buffer(rtc::make_ref_counted<TestBuffer>(
destruction_event, codec_width_, codec_height_)) destruction_event, codec_width_, codec_height_))
.set_ntp_time_ms(ntp_time_ms) .set_ntp_time_ms(ntp_time_ms)
.set_timestamp_ms(99) .set_timestamp_ms(99)
@ -736,7 +736,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
rtc::Event* destruction_event, rtc::Event* destruction_event,
int offset_x) const { int offset_x) const {
return VideoFrame::Builder() return VideoFrame::Builder()
.set_video_frame_buffer(new rtc::RefCountedObject<TestBuffer>( .set_video_frame_buffer(rtc::make_ref_counted<TestBuffer>(
destruction_event, codec_width_, codec_height_)) destruction_event, codec_width_, codec_height_))
.set_ntp_time_ms(ntp_time_ms) .set_ntp_time_ms(ntp_time_ms)
.set_timestamp_ms(99) .set_timestamp_ms(99)
@ -748,7 +748,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
VideoFrame CreateFrame(int64_t ntp_time_ms, int width, int height) const { VideoFrame CreateFrame(int64_t ntp_time_ms, int width, int height) const {
return VideoFrame::Builder() return VideoFrame::Builder()
.set_video_frame_buffer( .set_video_frame_buffer(
new rtc::RefCountedObject<TestBuffer>(nullptr, width, height)) rtc::make_ref_counted<TestBuffer>(nullptr, width, height))
.set_ntp_time_ms(ntp_time_ms) .set_ntp_time_ms(ntp_time_ms)
.set_timestamp_ms(ntp_time_ms) .set_timestamp_ms(ntp_time_ms)
.set_rotation(kVideoRotation_0) .set_rotation(kVideoRotation_0)
@ -769,7 +769,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
int width, int width,
int height) const { int height) const {
return VideoFrame::Builder() return VideoFrame::Builder()
.set_video_frame_buffer(new rtc::RefCountedObject<FakeNativeBuffer>( .set_video_frame_buffer(rtc::make_ref_counted<FakeNativeBuffer>(
destruction_event, width, height)) destruction_event, width, height))
.set_ntp_time_ms(ntp_time_ms) .set_ntp_time_ms(ntp_time_ms)
.set_timestamp_ms(99) .set_timestamp_ms(99)
@ -782,7 +782,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
int width, int width,
int height) const { int height) const {
return VideoFrame::Builder() return VideoFrame::Builder()
.set_video_frame_buffer(new rtc::RefCountedObject<FakeNV12NativeBuffer>( .set_video_frame_buffer(rtc::make_ref_counted<FakeNV12NativeBuffer>(
destruction_event, width, height)) destruction_event, width, height))
.set_ntp_time_ms(ntp_time_ms) .set_ntp_time_ms(ntp_time_ms)
.set_timestamp_ms(99) .set_timestamp_ms(99)
@ -1587,7 +1587,7 @@ TEST_F(VideoStreamEncoderTest,
NativeFrameWithoutI420SupportGetsCroppedIfNecessary) { NativeFrameWithoutI420SupportGetsCroppedIfNecessary) {
// Use the cropping factory. // Use the cropping factory.
video_encoder_config_.video_stream_factory = video_encoder_config_.video_stream_factory =
new rtc::RefCountedObject<CroppingVideoStreamFactory>(); rtc::make_ref_counted<CroppingVideoStreamFactory>();
video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config_), video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config_),
kMaxPayloadLength); kMaxPayloadLength);
video_stream_encoder_->WaitUntilTaskQueueIsIdle(); video_stream_encoder_->WaitUntilTaskQueueIsIdle();
@ -2071,7 +2071,7 @@ TEST_F(VideoStreamEncoderTest,
config.simulcast_layers[0].active = false; config.simulcast_layers[0].active = false;
config.simulcast_layers[1].active = true; config.simulcast_layers[1].active = true;
config.video_stream_factory = config.video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
"VP8", /*max qp*/ 56, /*screencast*/ false, "VP8", /*max qp*/ 56, /*screencast*/ false,
/*screenshare enabled*/ false); /*screenshare enabled*/ false);
video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength); video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
@ -2135,7 +2135,7 @@ TEST_F(VideoStreamEncoderTest,
config.simulcast_layers[0].active = false; config.simulcast_layers[0].active = false;
config.simulcast_layers[1].active = true; config.simulcast_layers[1].active = true;
config.video_stream_factory = config.video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
"VP8", /*max qp*/ 56, /*screencast*/ false, "VP8", /*max qp*/ 56, /*screencast*/ false,
/*screenshare enabled*/ false); /*screenshare enabled*/ false);
video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength); video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
@ -2208,7 +2208,7 @@ TEST_F(VideoStreamEncoderTest,
config.simulcast_layers[1].active = true; config.simulcast_layers[1].active = true;
config.simulcast_layers[2].active = false; config.simulcast_layers[2].active = false;
config.video_stream_factory = config.video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
"VP8", /*max qp*/ 56, /*screencast*/ false, "VP8", /*max qp*/ 56, /*screencast*/ false,
/*screenshare enabled*/ false); /*screenshare enabled*/ false);
video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength); video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
@ -2252,7 +2252,7 @@ TEST_F(VideoStreamEncoderTest,
config.simulcast_layers[1].active = false; config.simulcast_layers[1].active = false;
config.simulcast_layers[2].active = false; config.simulcast_layers[2].active = false;
config.video_stream_factory = config.video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
"VP8", /*max qp*/ 56, /*screencast*/ false, "VP8", /*max qp*/ 56, /*screencast*/ false,
/*screenshare enabled*/ false); /*screenshare enabled*/ false);
video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength); video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
@ -2288,7 +2288,7 @@ TEST_F(VideoStreamEncoderTest,
config.simulcast_layers[1].active = true; config.simulcast_layers[1].active = true;
config.simulcast_layers[1].max_bitrate_bps = kMaxBitrateBps; config.simulcast_layers[1].max_bitrate_bps = kMaxBitrateBps;
config.video_stream_factory = config.video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
"VP8", /*max qp*/ 56, /*screencast*/ false, "VP8", /*max qp*/ 56, /*screencast*/ false,
/*screenshare enabled*/ false); /*screenshare enabled*/ false);
video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength); video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
@ -2376,7 +2376,7 @@ TEST_P(ResolutionAlignmentTest, SinkWantsAlignmentApplied) {
config.simulcast_layers[i].scale_resolution_down_by = scale_factors_[i]; config.simulcast_layers[i].scale_resolution_down_by = scale_factors_[i];
} }
config.video_stream_factory = config.video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
"VP8", /*max qp*/ 56, /*screencast*/ false, "VP8", /*max qp*/ 56, /*screencast*/ false,
/*screenshare enabled*/ false); /*screenshare enabled*/ false);
video_stream_encoder_->ConfigureEncoder(std::move(config), kMaxPayloadLength); video_stream_encoder_->ConfigureEncoder(std::move(config), kMaxPayloadLength);
@ -4406,7 +4406,7 @@ TEST_F(VideoStreamEncoderTest,
video_encoder_config.content_type = video_encoder_config.content_type =
VideoEncoderConfig::ContentType::kRealtimeVideo; VideoEncoderConfig::ContentType::kRealtimeVideo;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp8EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp8EncoderSpecificSettings>(
VideoEncoder::GetDefaultVp8Settings()); VideoEncoder::GetDefaultVp8Settings());
for (auto& layer : video_encoder_config.simulcast_layers) { for (auto& layer : video_encoder_config.simulcast_layers) {
layer.num_temporal_layers = 2; layer.num_temporal_layers = 2;
@ -4451,7 +4451,7 @@ TEST_F(VideoStreamEncoderTest,
video_encoder_config.content_type = video_encoder_config.content_type =
VideoEncoderConfig::ContentType::kRealtimeVideo; VideoEncoderConfig::ContentType::kRealtimeVideo;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp8EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp8EncoderSpecificSettings>(
VideoEncoder::GetDefaultVp8Settings()); VideoEncoder::GetDefaultVp8Settings());
for (auto& layer : video_encoder_config.simulcast_layers) { for (auto& layer : video_encoder_config.simulcast_layers) {
layer.num_temporal_layers = 2; layer.num_temporal_layers = 2;
@ -4500,7 +4500,7 @@ TEST_F(VideoStreamEncoderTest,
vp9_settings.interLayerPred = InterLayerPredMode::kOn; vp9_settings.interLayerPred = InterLayerPredMode::kOn;
vp9_settings.automaticResizeOn = false; vp9_settings.automaticResizeOn = false;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp9EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings); vp9_settings);
ConfigureEncoder(std::move(video_encoder_config), ConfigureEncoder(std::move(video_encoder_config),
VideoStreamEncoder::BitrateAllocationCallbackType:: VideoStreamEncoder::BitrateAllocationCallbackType::
@ -4555,7 +4555,7 @@ TEST_F(VideoStreamEncoderTest,
vp9_settings.interLayerPred = InterLayerPredMode::kOn; vp9_settings.interLayerPred = InterLayerPredMode::kOn;
vp9_settings.automaticResizeOn = false; vp9_settings.automaticResizeOn = false;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp9EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings); vp9_settings);
ConfigureEncoder(std::move(video_encoder_config), ConfigureEncoder(std::move(video_encoder_config),
VideoStreamEncoder::BitrateAllocationCallbackType:: VideoStreamEncoder::BitrateAllocationCallbackType::
@ -4603,7 +4603,7 @@ TEST_F(VideoStreamEncoderTest,
vp9_settings.interLayerPred = InterLayerPredMode::kOnKeyPic; vp9_settings.interLayerPred = InterLayerPredMode::kOnKeyPic;
vp9_settings.automaticResizeOn = false; vp9_settings.automaticResizeOn = false;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp9EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings); vp9_settings);
ConfigureEncoder(std::move(video_encoder_config), ConfigureEncoder(std::move(video_encoder_config),
VideoStreamEncoder::BitrateAllocationCallbackType:: VideoStreamEncoder::BitrateAllocationCallbackType::
@ -4651,7 +4651,7 @@ TEST_F(VideoStreamEncoderTest,
vp9_settings.interLayerPred = InterLayerPredMode::kOn; vp9_settings.interLayerPred = InterLayerPredMode::kOn;
vp9_settings.automaticResizeOn = false; vp9_settings.automaticResizeOn = false;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp9EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings); vp9_settings);
// Simulcast layers are used for enabling/disabling streams. // Simulcast layers are used for enabling/disabling streams.
video_encoder_config.simulcast_layers.resize(3); video_encoder_config.simulcast_layers.resize(3);
@ -4710,7 +4710,7 @@ TEST_F(VideoStreamEncoderTest,
vp9_settings.interLayerPred = InterLayerPredMode::kOn; vp9_settings.interLayerPred = InterLayerPredMode::kOn;
vp9_settings.automaticResizeOn = false; vp9_settings.automaticResizeOn = false;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp9EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings); vp9_settings);
// Simulcast layers are used for enabling/disabling streams. // Simulcast layers are used for enabling/disabling streams.
video_encoder_config.simulcast_layers.resize(3); video_encoder_config.simulcast_layers.resize(3);
@ -4762,7 +4762,7 @@ TEST_F(VideoStreamEncoderTest,
vp9_settings.interLayerPred = InterLayerPredMode::kOn; vp9_settings.interLayerPred = InterLayerPredMode::kOn;
vp9_settings.automaticResizeOn = false; vp9_settings.automaticResizeOn = false;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp9EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings); vp9_settings);
// Simulcast layers are used for enabling/disabling streams. // Simulcast layers are used for enabling/disabling streams.
video_encoder_config.simulcast_layers.resize(3); video_encoder_config.simulcast_layers.resize(3);
@ -5362,7 +5362,7 @@ TEST_F(VideoStreamEncoderTest, InitialFrameDropActivatesWhenLayersChange) {
test::FillEncoderConfiguration(PayloadStringToCodecType("VP8"), 3, test::FillEncoderConfiguration(PayloadStringToCodecType("VP8"), 3,
&video_encoder_config); &video_encoder_config);
video_encoder_config.video_stream_factory = video_encoder_config.video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
"VP8", /*max qp*/ 56, /*screencast*/ false, "VP8", /*max qp*/ 56, /*screencast*/ false,
/*screenshare enabled*/ false); /*screenshare enabled*/ false);
for (auto& layer : video_encoder_config.simulcast_layers) { for (auto& layer : video_encoder_config.simulcast_layers) {
@ -5429,7 +5429,7 @@ TEST_F(VideoStreamEncoderTest, InitialFrameDropActivatesWhenSVCLayersChange) {
// Since only one layer is active - automatic resize should be enabled. // Since only one layer is active - automatic resize should be enabled.
vp9_settings.automaticResizeOn = true; vp9_settings.automaticResizeOn = true;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp9EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings); vp9_settings);
video_encoder_config.max_bitrate_bps = kSimulcastTargetBitrateBps; video_encoder_config.max_bitrate_bps = kSimulcastTargetBitrateBps;
video_encoder_config.content_type = video_encoder_config.content_type =
@ -5488,7 +5488,7 @@ TEST_F(VideoStreamEncoderTest,
// Since only one layer is active - automatic resize should be enabled. // Since only one layer is active - automatic resize should be enabled.
vp9_settings.automaticResizeOn = true; vp9_settings.automaticResizeOn = true;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp9EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings); vp9_settings);
video_encoder_config.max_bitrate_bps = kSimulcastTargetBitrateBps; video_encoder_config.max_bitrate_bps = kSimulcastTargetBitrateBps;
video_encoder_config.content_type = video_encoder_config.content_type =
@ -5546,7 +5546,7 @@ TEST_F(VideoStreamEncoderTest,
// Since only one layer is active - automatic resize should be enabled. // Since only one layer is active - automatic resize should be enabled.
vp9_settings.automaticResizeOn = true; vp9_settings.automaticResizeOn = true;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp9EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings); vp9_settings);
video_encoder_config.max_bitrate_bps = kSimulcastTargetBitrateBps; video_encoder_config.max_bitrate_bps = kSimulcastTargetBitrateBps;
video_encoder_config.content_type = video_encoder_config.content_type =
@ -5611,7 +5611,7 @@ TEST_F(VideoStreamEncoderTest, DefaultMaxAndMinBitratesNotUsedIfDisabled) {
// Since only one layer is active - automatic resize should be enabled. // Since only one layer is active - automatic resize should be enabled.
vp9_settings.automaticResizeOn = true; vp9_settings.automaticResizeOn = true;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp9EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings); vp9_settings);
video_encoder_config.max_bitrate_bps = kSimulcastTargetBitrateBps; video_encoder_config.max_bitrate_bps = kSimulcastTargetBitrateBps;
video_encoder_config.content_type = video_encoder_config.content_type =
@ -5687,7 +5687,7 @@ TEST_F(VideoStreamEncoderTest,
// Since only one layer is active - automatic resize should be enabled. // Since only one layer is active - automatic resize should be enabled.
vp9_settings.automaticResizeOn = true; vp9_settings.automaticResizeOn = true;
video_encoder_config.encoder_specific_settings = video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<VideoEncoderConfig::Vp9EncoderSpecificSettings>( rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
vp9_settings); vp9_settings);
video_encoder_config.max_bitrate_bps = kSimulcastTargetBitrateBps; video_encoder_config.max_bitrate_bps = kSimulcastTargetBitrateBps;
video_encoder_config.content_type = video_encoder_config.content_type =
@ -6685,7 +6685,7 @@ TEST_F(VideoStreamEncoderTest, AcceptsFullHdAdaptedDownSimulcastFrames) {
video_encoder_config.simulcast_layers[0].max_framerate = kFramerate; video_encoder_config.simulcast_layers[0].max_framerate = kFramerate;
video_encoder_config.max_bitrate_bps = kTargetBitrateBps; video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
video_encoder_config.video_stream_factory = video_encoder_config.video_stream_factory =
new rtc::RefCountedObject<CroppingVideoStreamFactory>(); rtc::make_ref_counted<CroppingVideoStreamFactory>();
video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config), video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
kMaxPayloadLength); kMaxPayloadLength);
video_stream_encoder_->WaitUntilTaskQueueIsIdle(); video_stream_encoder_->WaitUntilTaskQueueIsIdle();
@ -7650,7 +7650,7 @@ TEST_F(VideoStreamEncoderTest, EncoderResetAccordingToParameterChange) {
config.simulcast_layers[i].active = true; config.simulcast_layers[i].active = true;
} }
config.video_stream_factory = config.video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
"VP8", /*max qp*/ 56, /*screencast*/ false, "VP8", /*max qp*/ 56, /*screencast*/ false,
/*screenshare enabled*/ false); /*screenshare enabled*/ false);
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
@ -7778,7 +7778,7 @@ TEST_F(VideoStreamEncoderTest, EncoderResolutionsExposedInSimulcast) {
config.simulcast_layers[i].active = true; config.simulcast_layers[i].active = true;
} }
config.video_stream_factory = config.video_stream_factory =
new rtc::RefCountedObject<cricket::EncoderStreamFactory>( rtc::make_ref_counted<cricket::EncoderStreamFactory>(
"VP8", /*max qp*/ 56, /*screencast*/ false, "VP8", /*max qp*/ 56, /*screencast*/ false,
/*screenshare enabled*/ false); /*screenshare enabled*/ false);
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(