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

Replace scoped_ptr with unique_ptr in webrtc/video/

Browse Source 
BUG=webrtc:5520

Review URL: https://codereview.webrtc.org/1751903002

Cr-Commit-Position: refs/heads/master@{#11833}
This commit is contained in:
kwiberg 2016-03-01 11:52:33 -08:00 committed by Commit bot
parent d802b5b7c3
commit 27f982bbcb
22 changed files with 97 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
webrtc/video/call_stats.h
View File

@ -12,10 +12,10 @@
#define WEBRTC_VIDEO_CALL_STATS_H_ #define WEBRTC_VIDEO_CALL_STATS_H_
#include <list> #include <list>
#include <memory>
#include "webrtc/base/constructormagic.h" #include "webrtc/base/constructormagic.h"
#include "webrtc/base/criticalsection.h" #include "webrtc/base/criticalsection.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/include/module.h" #include "webrtc/modules/include/module.h"
#include "webrtc/system_wrappers/include/clock.h" #include "webrtc/system_wrappers/include/clock.h"
@ -64,7 +64,7 @@ class CallStats : public Module {
// Protecting all members. // Protecting all members.
rtc::CriticalSection crit_; rtc::CriticalSection crit_;
// Observer receiving statistics updates. // Observer receiving statistics updates.
rtc::scoped_ptr<RtcpRttStats> rtcp_rtt_stats_; std::unique_ptr<RtcpRttStats> rtcp_rtt_stats_;
// The last time 'Process' resulted in statistic update. // The last time 'Process' resulted in statistic update.
int64_t last_process_time_; int64_t last_process_time_;
// The last RTT in the statistics update (zero if there is no valid estimate). // The last RTT in the statistics update (zero if there is no valid estimate).

5
webrtc/video/call_stats_unittest.cc
View File

@ -8,10 +8,11 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include <memory>
#include "testing/gmock/include/gmock/gmock.h" #include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/system_wrappers/include/metrics.h" #include "webrtc/system_wrappers/include/metrics.h"
#include "webrtc/system_wrappers/include/tick_util.h" #include "webrtc/system_wrappers/include/tick_util.h"
@ -39,7 +40,7 @@ class CallStatsTest : public ::testing::Test {
protected: protected:
virtual void SetUp() { call_stats_.reset(new CallStats(&fake_clock_)); } virtual void SetUp() { call_stats_.reset(new CallStats(&fake_clock_)); }
SimulatedClock fake_clock_; SimulatedClock fake_clock_;
rtc::scoped_ptr<CallStats> call_stats_; std::unique_ptr<CallStats> call_stats_;
}; };
TEST_F(CallStatsTest, AddAndTriggerCallback) { TEST_F(CallStatsTest, AddAndTriggerCallback) {

44
webrtc/video/end_to_end_tests.cc
View File

@ -10,6 +10,7 @@
#include <algorithm> #include <algorithm>
#include <list> #include <list>
#include <map> #include <map>
#include <memory>
#include <sstream> #include <sstream>
#include <string> #include <string>
@ -17,7 +18,6 @@
#include "webrtc/base/checks.h" #include "webrtc/base/checks.h"
#include "webrtc/base/event.h" #include "webrtc/base/event.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/timeutils.h" #include "webrtc/base/timeutils.h"
#include "webrtc/call.h" #include "webrtc/call.h"
#include "webrtc/call/transport_adapter.h" #include "webrtc/call/transport_adapter.h"
@ -173,7 +173,7 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
// Create frames that are smaller than the send width/height, this is done to // Create frames that are smaller than the send width/height, this is done to
// check that the callbacks are done after processing video. // check that the callbacks are done after processing video.
rtc::scoped_ptr<test::FrameGenerator> frame_generator( std::unique_ptr<test::FrameGenerator> frame_generator(
test::FrameGenerator::CreateChromaGenerator(kWidth, kHeight)); test::FrameGenerator::CreateChromaGenerator(kWidth, kHeight));
video_send_stream_->Input()->IncomingCapturedFrame( video_send_stream_->Input()->IncomingCapturedFrame(
*frame_generator->NextFrame()); *frame_generator->NextFrame());
@ -220,7 +220,7 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) {
CreateVideoStreams(); CreateVideoStreams();
Start(); Start();
rtc::scoped_ptr<test::FrameGenerator> frame_generator( std::unique_ptr<test::FrameGenerator> frame_generator(
test::FrameGenerator::CreateChromaGenerator( test::FrameGenerator::CreateChromaGenerator(
video_encoder_config_.streams[0].width, video_encoder_config_.streams[0].width,
video_encoder_config_.streams[0].height)); video_encoder_config_.streams[0].height));
@ -282,8 +282,8 @@ TEST_F(EndToEndTest, SendsAndReceivesVP9) {
bool IsTextureSupported() const override { return false; } bool IsTextureSupported() const override { return false; }
private: private:
rtc::scoped_ptr<webrtc::VideoEncoder> encoder_; std::unique_ptr<webrtc::VideoEncoder> encoder_;
rtc::scoped_ptr<webrtc::VideoDecoder> decoder_; std::unique_ptr<webrtc::VideoDecoder> decoder_;
int frame_counter_; int frame_counter_;
} test; } test;
@ -338,8 +338,8 @@ TEST_F(EndToEndTest, SendsAndReceivesH264) {
bool IsTextureSupported() const override { return false; } bool IsTextureSupported() const override { return false; }
private: private:
rtc::scoped_ptr<webrtc::VideoEncoder> encoder_; std::unique_ptr<webrtc::VideoEncoder> encoder_;
rtc::scoped_ptr<webrtc::VideoDecoder> decoder_; std::unique_ptr<webrtc::VideoDecoder> decoder_;
int frame_counter_; int frame_counter_;
} test; } test;
@ -816,7 +816,7 @@ void EndToEndTest::DecodesRetransmittedFrame(bool enable_rtx, bool enable_red) {
const int payload_type_; const int payload_type_;
const uint32_t retransmission_ssrc_; const uint32_t retransmission_ssrc_;
const int retransmission_payload_type_; const int retransmission_payload_type_;
rtc::scoped_ptr<VideoEncoder> encoder_; std::unique_ptr<VideoEncoder> encoder_;
const std::string payload_name_; const std::string payload_name_;
int marker_bits_observed_; int marker_bits_observed_;
uint32_t retransmitted_timestamp_ GUARDED_BY(&crit_); uint32_t retransmitted_timestamp_ GUARDED_BY(&crit_);
@ -908,7 +908,7 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
receiver_transport.SetReceiver(sender_call_->Receiver()); receiver_transport.SetReceiver(sender_call_->Receiver());
CreateSendConfig(1, 0, &sender_transport); CreateSendConfig(1, 0, &sender_transport);
rtc::scoped_ptr<VideoEncoder> encoder( std::unique_ptr<VideoEncoder> encoder(
VideoEncoder::Create(VideoEncoder::kVp8)); VideoEncoder::Create(VideoEncoder::kVp8));
video_send_config_.encoder_settings.encoder = encoder.get(); video_send_config_.encoder_settings.encoder = encoder.get();
video_send_config_.encoder_settings.payload_name = "VP8"; video_send_config_.encoder_settings.payload_name = "VP8";
@ -926,7 +926,7 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
// Create frames that are smaller than the send width/height, this is done to // Create frames that are smaller than the send width/height, this is done to
// check that the callbacks are done after processing video. // check that the callbacks are done after processing video.
rtc::scoped_ptr<test::FrameGenerator> frame_generator( std::unique_ptr<test::FrameGenerator> frame_generator(
test::FrameGenerator::CreateChromaGenerator(kWidth / 2, kHeight / 2)); test::FrameGenerator::CreateChromaGenerator(kWidth / 2, kHeight / 2));
video_send_stream_->Input()->IncomingCapturedFrame( video_send_stream_->Input()->IncomingCapturedFrame(
*frame_generator->NextFrame()); *frame_generator->NextFrame());
@ -1213,16 +1213,16 @@ class MultiStreamTest {
virtual ~MultiStreamTest() {} virtual ~MultiStreamTest() {}
void RunTest() { void RunTest() {
rtc::scoped_ptr<Call> sender_call(Call::Create(Call::Config())); std::unique_ptr<Call> sender_call(Call::Create(Call::Config()));
rtc::scoped_ptr<Call> receiver_call(Call::Create(Call::Config())); std::unique_ptr<Call> receiver_call(Call::Create(Call::Config()));
rtc::scoped_ptr<test::DirectTransport> sender_transport( std::unique_ptr<test::DirectTransport> sender_transport(
CreateSendTransport(sender_call.get())); CreateSendTransport(sender_call.get()));
rtc::scoped_ptr<test::DirectTransport> receiver_transport( std::unique_ptr<test::DirectTransport> receiver_transport(
CreateReceiveTransport(receiver_call.get())); CreateReceiveTransport(receiver_call.get()));
sender_transport->SetReceiver(receiver_call->Receiver()); sender_transport->SetReceiver(receiver_call->Receiver());
receiver_transport->SetReceiver(sender_call->Receiver()); receiver_transport->SetReceiver(sender_call->Receiver());
rtc::scoped_ptr<VideoEncoder> encoders[kNumStreams]; std::unique_ptr<VideoEncoder> encoders[kNumStreams];
for (size_t i = 0; i < kNumStreams; ++i) for (size_t i = 0; i < kNumStreams; ++i)
encoders[i].reset(VideoEncoder::Create(VideoEncoder::kVp8)); encoders[i].reset(VideoEncoder::Create(VideoEncoder::kVp8));
@ -1374,7 +1374,7 @@ TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) {
} }
private: private:
rtc::scoped_ptr<VideoOutputObserver> observers_[kNumStreams]; std::unique_ptr<VideoOutputObserver> observers_[kNumStreams];
} tester; } tester;
tester.RunTest(); tester.RunTest();
@ -1492,7 +1492,7 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
rtc::CriticalSection lock_; rtc::CriticalSection lock_;
rtc::Event done_; rtc::Event done_;
rtc::scoped_ptr<RtpHeaderParser> parser_; std::unique_ptr<RtpHeaderParser> parser_;
SequenceNumberUnwrapper unwrapper_; SequenceNumberUnwrapper unwrapper_;
std::set<int64_t> received_packed_ids_; std::set<int64_t> received_packed_ids_;
std::set<uint32_t> streams_observed_; std::set<uint32_t> streams_observed_;
@ -1706,7 +1706,7 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
} }
private: private:
rtc::scoped_ptr<uint8_t[]> buffer_; std::unique_ptr<uint8_t[]> buffer_;
size_t length_; size_t length_;
FrameType frame_type_; FrameType frame_type_;
rtc::Event called_; rtc::Event called_;
@ -1730,7 +1730,7 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
CreateVideoStreams(); CreateVideoStreams();
Start(); Start();
rtc::scoped_ptr<test::FrameGenerator> frame_generator( std::unique_ptr<test::FrameGenerator> frame_generator(
test::FrameGenerator::CreateChromaGenerator( test::FrameGenerator::CreateChromaGenerator(
video_encoder_config_.streams[0].width, video_encoder_config_.streams[0].width,
video_encoder_config_.streams[0].height)); video_encoder_config_.streams[0].height));
@ -1960,7 +1960,7 @@ TEST_F(EndToEndTest, RembWithSendSideBwe) {
Clock* const clock_; Clock* const clock_;
uint32_t sender_ssrc_; uint32_t sender_ssrc_;
int remb_bitrate_bps_; int remb_bitrate_bps_;
rtc::scoped_ptr<RtpRtcp> rtp_rtcp_; std::unique_ptr<RtpRtcp> rtp_rtcp_;
test::PacketTransport* receive_transport_; test::PacketTransport* receive_transport_;
rtc::Event event_; rtc::Event event_;
rtc::PlatformThread poller_thread_; rtc::PlatformThread poller_thread_;
@ -1986,7 +1986,7 @@ TEST_F(EndToEndTest, VerifyNackStats) {
Action OnSendRtp(const uint8_t* packet, size_t length) override { Action OnSendRtp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_); rtc::CritScope lock(&crit_);
if (++sent_rtp_packets_ == kPacketNumberToDrop) { if (++sent_rtp_packets_ == kPacketNumberToDrop) {
rtc::scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create()); std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
RTPHeader header; RTPHeader header;
EXPECT_TRUE(parser->Parse(packet, length, &header)); EXPECT_TRUE(parser->Parse(packet, length, &header));
dropped_rtp_packet_ = header.sequenceNumber; dropped_rtp_packet_ = header.sequenceNumber;
@ -2162,7 +2162,7 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx,
const bool use_rtx_; const bool use_rtx_;
const bool use_red_; const bool use_red_;
const bool screenshare_; const bool screenshare_;
const rtc::scoped_ptr<VideoEncoder> vp8_encoder_; const std::unique_ptr<VideoEncoder> vp8_encoder_;
Call* sender_call_; Call* sender_call_;
Call* receiver_call_; Call* receiver_call_;
int64_t start_runtime_ms_; int64_t start_runtime_ms_;

4
webrtc/video/overuse_frame_detector.cc
View File

@ -166,8 +166,8 @@ class OveruseFrameDetector::SendProcessingUsage {
const float kMaxSampleDiffMs; const float kMaxSampleDiffMs;
uint64_t count_; uint64_t count_;
const CpuOveruseOptions options_; const CpuOveruseOptions options_;
rtc::scoped_ptr<rtc::ExpFilter> filtered_processing_ms_; std::unique_ptr<rtc::ExpFilter> filtered_processing_ms_;
rtc::scoped_ptr<rtc::ExpFilter> filtered_frame_diff_ms_; std::unique_ptr<rtc::ExpFilter> filtered_frame_diff_ms_;
}; };
OveruseFrameDetector::OveruseFrameDetector( OveruseFrameDetector::OveruseFrameDetector(

4
webrtc/video/overuse_frame_detector.h
View File

@ -12,11 +12,11 @@
#define WEBRTC_VIDEO_OVERUSE_FRAME_DETECTOR_H_ #define WEBRTC_VIDEO_OVERUSE_FRAME_DETECTOR_H_
#include <list> #include <list>
#include <memory>
#include "webrtc/base/constructormagic.h" #include "webrtc/base/constructormagic.h"
#include "webrtc/base/criticalsection.h" #include "webrtc/base/criticalsection.h"
#include "webrtc/base/optional.h" #include "webrtc/base/optional.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/exp_filter.h" #include "webrtc/base/exp_filter.h"
#include "webrtc/base/thread_annotations.h" #include "webrtc/base/thread_annotations.h"
#include "webrtc/base/thread_checker.h" #include "webrtc/base/thread_checker.h"
@ -154,7 +154,7 @@ class OveruseFrameDetector : public Module {
// TODO(asapersson): Can these be regular members (avoid separate heap // TODO(asapersson): Can these be regular members (avoid separate heap
// allocs)? // allocs)?
const rtc::scoped_ptr<SendProcessingUsage> usage_ GUARDED_BY(crit_); const std::unique_ptr<SendProcessingUsage> usage_ GUARDED_BY(crit_);
std::list<FrameTiming> frame_timing_ GUARDED_BY(crit_); std::list<FrameTiming> frame_timing_ GUARDED_BY(crit_);
rtc::ThreadChecker processing_thread_; rtc::ThreadChecker processing_thread_;

9
webrtc/video/overuse_frame_detector_unittest.cc
View File

@ -8,12 +8,13 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include <memory>
#include "webrtc/video/overuse_frame_detector.h" #include "webrtc/video/overuse_frame_detector.h"
#include "testing/gmock/include/gmock/gmock.h" #include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/system_wrappers/include/clock.h" #include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/video_frame.h" #include "webrtc/video_frame.h"
@ -121,9 +122,9 @@ class OveruseFrameDetectorTest : public ::testing::Test,
int UsagePercent() { return metrics_.encode_usage_percent; } int UsagePercent() { return metrics_.encode_usage_percent; }
CpuOveruseOptions options_; CpuOveruseOptions options_;
rtc::scoped_ptr<SimulatedClock> clock_; std::unique_ptr<SimulatedClock> clock_;
rtc::scoped_ptr<MockCpuOveruseObserver> observer_; std::unique_ptr<MockCpuOveruseObserver> observer_;
rtc::scoped_ptr<OveruseFrameDetector> overuse_detector_; std::unique_ptr<OveruseFrameDetector> overuse_detector_;
CpuOveruseMetrics metrics_; CpuOveruseMetrics metrics_;
}; };

1
webrtc/video/payload_router.h
View File

@ -15,7 +15,6 @@
#include "webrtc/base/constructormagic.h" #include "webrtc/base/constructormagic.h"
#include "webrtc/base/criticalsection.h" #include "webrtc/base/criticalsection.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/thread_annotations.h" #include "webrtc/base/thread_annotations.h"
#include "webrtc/common_types.h" #include "webrtc/common_types.h"
#include "webrtc/system_wrappers/include/atomic32.h" #include "webrtc/system_wrappers/include/atomic32.h"

5
webrtc/video/payload_router_unittest.cc
View File

@ -8,9 +8,10 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include <memory>
#include "testing/gmock/include/gmock/gmock.h" #include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
#include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
#include "webrtc/video/payload_router.h" #include "webrtc/video/payload_router.h"
@ -27,7 +28,7 @@ class PayloadRouterTest : public ::testing::Test {
virtual void SetUp() { virtual void SetUp() {
payload_router_.reset(new PayloadRouter()); payload_router_.reset(new PayloadRouter());
} }
rtc::scoped_ptr<PayloadRouter> payload_router_; std::unique_ptr<PayloadRouter> payload_router_;
}; };
TEST_F(PayloadRouterTest, SendOnOneModule) { TEST_F(PayloadRouterTest, SendOnOneModule) {

12
webrtc/video/replay.cc
View File

@ -11,13 +11,13 @@
#include <stdio.h> #include <stdio.h>
#include <map> #include <map>
#include <memory>
#include <sstream> #include <sstream>
#include "gflags/gflags.h" #include "gflags/gflags.h"
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/checks.h" #include "webrtc/base/checks.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/call.h" #include "webrtc/call.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
@ -209,12 +209,12 @@ class DecoderBitstreamFileWriter : public EncodedFrameObserver {
}; };
void RtpReplay() { void RtpReplay() {
rtc::scoped_ptr<test::VideoRenderer> playback_video( std::unique_ptr<test::VideoRenderer> playback_video(
test::VideoRenderer::Create("Playback Video", 640, 480)); test::VideoRenderer::Create("Playback Video", 640, 480));
FileRenderPassthrough file_passthrough(flags::OutBase(), FileRenderPassthrough file_passthrough(flags::OutBase(),
playback_video.get()); playback_video.get());
rtc::scoped_ptr<Call> call(Call::Create(Call::Config())); std::unique_ptr<Call> call(Call::Create(Call::Config()));
test::NullTransport transport; test::NullTransport transport;
VideoReceiveStream::Config receive_config(&transport); VideoReceiveStream::Config receive_config(&transport);
@ -237,7 +237,7 @@ void RtpReplay() {
encoder_settings.payload_name = flags::Codec(); encoder_settings.payload_name = flags::Codec();
encoder_settings.payload_type = flags::PayloadType(); encoder_settings.payload_type = flags::PayloadType();
VideoReceiveStream::Decoder decoder; VideoReceiveStream::Decoder decoder;
rtc::scoped_ptr<DecoderBitstreamFileWriter> bitstream_writer; std::unique_ptr<DecoderBitstreamFileWriter> bitstream_writer;
if (!flags::DecoderBitstreamFilename().empty()) { if (!flags::DecoderBitstreamFilename().empty()) {
bitstream_writer.reset(new DecoderBitstreamFileWriter( bitstream_writer.reset(new DecoderBitstreamFileWriter(
flags::DecoderBitstreamFilename().c_str())); flags::DecoderBitstreamFilename().c_str()));
@ -255,7 +255,7 @@ void RtpReplay() {
VideoReceiveStream* receive_stream = VideoReceiveStream* receive_stream =
call->CreateVideoReceiveStream(receive_config); call->CreateVideoReceiveStream(receive_config);
rtc::scoped_ptr<test::RtpFileReader> rtp_reader(test::RtpFileReader::Create( std::unique_ptr<test::RtpFileReader> rtp_reader(test::RtpFileReader::Create(
test::RtpFileReader::kRtpDump, flags::InputFile())); test::RtpFileReader::kRtpDump, flags::InputFile()));
if (rtp_reader.get() == nullptr) { if (rtp_reader.get() == nullptr) {
rtp_reader.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap, rtp_reader.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap,
@ -290,7 +290,7 @@ void RtpReplay() {
break; break;
case PacketReceiver::DELIVERY_UNKNOWN_SSRC: { case PacketReceiver::DELIVERY_UNKNOWN_SSRC: {
RTPHeader header; RTPHeader header;
rtc::scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create()); std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
parser->Parse(packet.data, packet.length, &header); parser->Parse(packet.data, packet.length, &header);
if (unknown_packets[header.ssrc] == 0) if (unknown_packets[header.ssrc] == 0)
fprintf(stderr, "Unknown SSRC: %u!\n", header.ssrc); fprintf(stderr, "Unknown SSRC: %u!\n", header.ssrc);

4
webrtc/video/send_statistics_proxy.h
View File

@ -12,12 +12,12 @@
#define WEBRTC_VIDEO_SEND_STATISTICS_PROXY_H_ #define WEBRTC_VIDEO_SEND_STATISTICS_PROXY_H_
#include <map> #include <map>
#include <memory>
#include <string> #include <string>
#include "webrtc/base/criticalsection.h" #include "webrtc/base/criticalsection.h"
#include "webrtc/base/exp_filter.h" #include "webrtc/base/exp_filter.h"
#include "webrtc/base/ratetracker.h" #include "webrtc/base/ratetracker.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/thread_annotations.h" #include "webrtc/base/thread_annotations.h"
#include "webrtc/common_types.h" #include "webrtc/common_types.h"
#include "webrtc/modules/video_coding/include/video_codec_interface.h" #include "webrtc/modules/video_coding/include/video_codec_interface.h"
@ -174,7 +174,7 @@ class SendStatisticsProxy : public CpuOveruseMetricsObserver,
const VideoSendStream::Stats start_stats_; const VideoSendStream::Stats start_stats_;
}; };
rtc::scoped_ptr<UmaSamplesContainer> uma_container_ GUARDED_BY(crit_); std::unique_ptr<UmaSamplesContainer> uma_container_ GUARDED_BY(crit_);
}; };
} // namespace webrtc } // namespace webrtc

3
webrtc/video/send_statistics_proxy_unittest.cc
View File

@ -12,6 +12,7 @@
#include "webrtc/video/send_statistics_proxy.h" #include "webrtc/video/send_statistics_proxy.h"
#include <map> #include <map>
#include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
@ -94,7 +95,7 @@ class SendStatisticsProxyTest : public ::testing::Test {
} }
SimulatedClock fake_clock_; SimulatedClock fake_clock_;
rtc::scoped_ptr<SendStatisticsProxy> statistics_proxy_; std::unique_ptr<SendStatisticsProxy> statistics_proxy_;
VideoSendStream::Config config_; VideoSendStream::Config config_;
int avg_delay_ms_; int avg_delay_ms_;
int max_delay_ms_; int max_delay_ms_;

8
webrtc/video/video_capture_input_unittest.cc
View File

@ -9,12 +9,12 @@
*/ */
#include "webrtc/video/video_capture_input.h" #include "webrtc/video/video_capture_input.h"
#include <memory>
#include <vector> #include <vector>
#include "testing/gmock/include/gmock/gmock.h" #include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/event.h" #include "webrtc/base/event.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/system_wrappers/include/ref_count.h" #include "webrtc/system_wrappers/include/ref_count.h"
#include "webrtc/system_wrappers/include/scoped_vector.h" #include "webrtc/system_wrappers/include/scoped_vector.h"
#include "webrtc/test/fake_texture_frame.h" #include "webrtc/test/fake_texture_frame.h"
@ -82,12 +82,12 @@ class VideoCaptureInputTest : public ::testing::Test {
SendStatisticsProxy stats_proxy_; SendStatisticsProxy stats_proxy_;
rtc::scoped_ptr<MockVideoCaptureCallback> mock_frame_callback_; std::unique_ptr<MockVideoCaptureCallback> mock_frame_callback_;
rtc::scoped_ptr<OveruseFrameDetector> overuse_detector_; std::unique_ptr<OveruseFrameDetector> overuse_detector_;
// Used to send input capture frames to VideoCaptureInput. // Used to send input capture frames to VideoCaptureInput.
rtc::scoped_ptr<internal::VideoCaptureInput> input_; std::unique_ptr<internal::VideoCaptureInput> input_;
// Input capture frames of VideoCaptureInput. // Input capture frames of VideoCaptureInput.
ScopedVector<VideoFrame> input_frames_; ScopedVector<VideoFrame> input_frames_;

7
webrtc/video/video_quality_test.cc
View File

@ -21,7 +21,6 @@
#include "webrtc/base/checks.h" #include "webrtc/base/checks.h"
#include "webrtc/base/event.h" #include "webrtc/base/event.h"
#include "webrtc/base/format_macros.h" #include "webrtc/base/format_macros.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/timeutils.h" #include "webrtc/base/timeutils.h"
#include "webrtc/call.h" #include "webrtc/call.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
@ -1039,7 +1038,7 @@ void VideoQualityTest::RunWithVideoRenderer(const Params& params) {
params_ = params; params_ = params;
CheckParams(); CheckParams();
rtc::scoped_ptr<test::VideoRenderer> local_preview( std::unique_ptr<test::VideoRenderer> local_preview(
test::VideoRenderer::Create("Local Preview", params_.common.width, test::VideoRenderer::Create("Local Preview", params_.common.width,
params_.common.height)); params_.common.height));
size_t stream_id = params_.ss.selected_stream; size_t stream_id = params_.ss.selected_stream;
@ -1050,7 +1049,7 @@ void VideoQualityTest::RunWithVideoRenderer(const Params& params) {
title += " - Stream #" + s.str(); title += " - Stream #" + s.str();
} }
rtc::scoped_ptr<test::VideoRenderer> loopback_video( std::unique_ptr<test::VideoRenderer> loopback_video(
test::VideoRenderer::Create(title.c_str(), test::VideoRenderer::Create(title.c_str(),
params_.ss.streams[stream_id].width, params_.ss.streams[stream_id].width,
params_.ss.streams[stream_id].height)); params_.ss.streams[stream_id].height));
@ -1059,7 +1058,7 @@ void VideoQualityTest::RunWithVideoRenderer(const Params& params) {
// match the full stack tests. // match the full stack tests.
Call::Config call_config; Call::Config call_config;
call_config.bitrate_config = params_.common.call_bitrate_config; call_config.bitrate_config = params_.common.call_bitrate_config;
rtc::scoped_ptr<Call> call(Call::Create(call_config)); std::unique_ptr<Call> call(Call::Create(call_config));
test::LayerFilteringTransport transport( test::LayerFilteringTransport transport(
params.pipe, call.get(), kPayloadTypeVP8, kPayloadTypeVP9, params.pipe, call.get(), kPayloadTypeVP8, kPayloadTypeVP9,

9
webrtc/video/video_quality_test.h
View File

@ -10,6 +10,7 @@
#ifndef WEBRTC_VIDEO_VIDEO_QUALITY_TEST_H_ #ifndef WEBRTC_VIDEO_VIDEO_QUALITY_TEST_H_
#define WEBRTC_VIDEO_VIDEO_QUALITY_TEST_H_ #define WEBRTC_VIDEO_VIDEO_QUALITY_TEST_H_
#include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
@ -103,10 +104,10 @@ class VideoQualityTest : public test::CallTest {
void SetupScreenshare(); void SetupScreenshare();
// We need a more general capturer than the FrameGeneratorCapturer. // We need a more general capturer than the FrameGeneratorCapturer.
rtc::scoped_ptr<test::VideoCapturer> capturer_; std::unique_ptr<test::VideoCapturer> capturer_;
rtc::scoped_ptr<test::TraceToStderr> trace_to_stderr_; std::unique_ptr<test::TraceToStderr> trace_to_stderr_;
rtc::scoped_ptr<test::FrameGenerator> frame_generator_; std::unique_ptr<test::FrameGenerator> frame_generator_;
rtc::scoped_ptr<VideoEncoder> encoder_; std::unique_ptr<VideoEncoder> encoder_;
VideoCodecUnion codec_settings_; VideoCodecUnion codec_settings_;
Clock* const clock_; Clock* const clock_;

4
webrtc/video/video_receive_stream.h
View File

@ -11,9 +11,9 @@
#ifndef WEBRTC_VIDEO_VIDEO_RECEIVE_STREAM_H_ #ifndef WEBRTC_VIDEO_VIDEO_RECEIVE_STREAM_H_
#define WEBRTC_VIDEO_VIDEO_RECEIVE_STREAM_H_ #define WEBRTC_VIDEO_VIDEO_RECEIVE_STREAM_H_
#include <memory>
#include <vector> #include <vector>
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/call.h" #include "webrtc/call.h"
#include "webrtc/call/transport_adapter.h" #include "webrtc/call/transport_adapter.h"
#include "webrtc/common_video/include/incoming_video_stream.h" #include "webrtc/common_video/include/incoming_video_stream.h"
@ -95,7 +95,7 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
CallStats* const call_stats_; CallStats* const call_stats_;
VieRemb* const remb_; VieRemb* const remb_;
rtc::scoped_ptr<VideoCodingModule> vcm_; std::unique_ptr<VideoCodingModule> vcm_;
IncomingVideoStream incoming_video_stream_; IncomingVideoStream incoming_video_stream_;
ReceiveStatisticsProxy stats_proxy_; ReceiveStatisticsProxy stats_proxy_;
ViEChannel vie_channel_; ViEChannel vie_channel_;

24
webrtc/video/video_send_stream_tests.cc
View File

@ -8,6 +8,7 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include <algorithm> // max #include <algorithm> // max
#include <memory>
#include <vector> #include <vector>
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
@ -18,7 +19,6 @@
#include "webrtc/base/event.h" #include "webrtc/base/event.h"
#include "webrtc/base/logging.h" #include "webrtc/base/logging.h"
#include "webrtc/base/platform_thread.h" #include "webrtc/base/platform_thread.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/call.h" #include "webrtc/call.h"
#include "webrtc/call/transport_adapter.h" #include "webrtc/call/transport_adapter.h"
#include "webrtc/frame_callback.h" #include "webrtc/frame_callback.h"
@ -304,7 +304,7 @@ class FakeReceiveStatistics : public NullReceiveStatistics {
RtcpStatistics stats_; RtcpStatistics stats_;
}; };
rtc::scoped_ptr<LossyStatistician> lossy_stats_; std::unique_ptr<LossyStatistician> lossy_stats_;
StatisticianMap stats_map_; StatisticianMap stats_map_;
}; };
@ -442,8 +442,8 @@ class FecObserver : public test::EndToEndTest {
EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets."; EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets.";
} }
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_; std::unique_ptr<internal::TransportAdapter> transport_adapter_;
rtc::scoped_ptr<VideoEncoder> encoder_; std::unique_ptr<VideoEncoder> encoder_;
const std::string payload_name_; const std::string payload_name_;
const bool use_nack_; const bool use_nack_;
const bool expect_red_; const bool expect_red_;
@ -562,7 +562,7 @@ void VideoSendStreamTest::TestNackRetransmission(
EXPECT_TRUE(Wait()) << "Timed out while waiting for NACK retransmission."; EXPECT_TRUE(Wait()) << "Timed out while waiting for NACK retransmission.";
} }
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_; std::unique_ptr<internal::TransportAdapter> transport_adapter_;
int send_count_; int send_count_;
uint32_t retransmit_ssrc_; uint32_t retransmit_ssrc_;
uint8_t retransmit_payload_type_; uint8_t retransmit_payload_type_;
@ -758,7 +758,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
EXPECT_TRUE(Wait()) << "Timed out while observing incoming RTP packets."; EXPECT_TRUE(Wait()) << "Timed out while observing incoming RTP packets.";
} }
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_; std::unique_ptr<internal::TransportAdapter> transport_adapter_;
test::ConfigurableFrameSizeEncoder encoder_; test::ConfigurableFrameSizeEncoder encoder_;
const size_t max_packet_size_; const size_t max_packet_size_;
@ -937,7 +937,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr)); EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
} }
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_; std::unique_ptr<internal::TransportAdapter> transport_adapter_;
Clock* const clock_; Clock* const clock_;
VideoSendStream* stream_; VideoSendStream* stream_;
@ -1015,7 +1015,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
} }
Clock* const clock_; Clock* const clock_;
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_; std::unique_ptr<internal::TransportAdapter> transport_adapter_;
rtc::CriticalSection crit_; rtc::CriticalSection crit_;
int64_t last_packet_time_ms_ GUARDED_BY(crit_); int64_t last_packet_time_ms_ GUARDED_BY(crit_);
test::FrameGeneratorCapturer* capturer_ GUARDED_BY(crit_); test::FrameGeneratorCapturer* capturer_ GUARDED_BY(crit_);
@ -1103,8 +1103,8 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
<< "Timeout while waiting for low bitrate stats after REMB."; << "Timeout while waiting for low bitrate stats after REMB.";
} }
rtc::scoped_ptr<RtpRtcp> rtp_rtcp_; std::unique_ptr<RtpRtcp> rtp_rtcp_;
rtc::scoped_ptr<internal::TransportAdapter> feedback_transport_; std::unique_ptr<internal::TransportAdapter> feedback_transport_;
VideoSendStream* stream_; VideoSendStream* stream_;
bool bitrate_capped_; bool bitrate_capped_;
} test; } test;
@ -1292,7 +1292,7 @@ void ExpectEqualFramesVector(const std::vector<VideoFrame>& frames1,
VideoFrame CreateVideoFrame(int width, int height, uint8_t data) { VideoFrame CreateVideoFrame(int width, int height, uint8_t data) {
const int kSizeY = width * height * 2; const int kSizeY = width * height * 2;
rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[kSizeY]); std::unique_ptr<uint8_t[]> buffer(new uint8_t[kSizeY]);
memset(buffer.get(), data, kSizeY); memset(buffer.get(), data, kSizeY);
VideoFrame frame; VideoFrame frame;
frame.CreateFrame(buffer.get(), buffer.get(), buffer.get(), width, height, frame.CreateFrame(buffer.get(), buffer.get(), buffer.get(), width, height,
@ -2168,7 +2168,7 @@ class Vp9HeaderObserver : public test::SendTest {
VerifyTl0Idx(vp9); VerifyTl0Idx(vp9);
} }
rtc::scoped_ptr<VP9Encoder> vp9_encoder_; std::unique_ptr<VP9Encoder> vp9_encoder_;
VideoCodecVP9 vp9_settings_; VideoCodecVP9 vp9_settings_;
webrtc::VideoEncoderConfig encoder_config_; webrtc::VideoEncoderConfig encoder_config_;
RTPHeader last_header_; RTPHeader last_header_;

8
webrtc/video/vie_channel.h
View File

@ -13,11 +13,11 @@
#include <list> #include <list>
#include <map> #include <map>
#include <memory>
#include <vector> #include <vector>
#include "webrtc/base/criticalsection.h" #include "webrtc/base/criticalsection.h"
#include "webrtc/base/platform_thread.h" #include "webrtc/base/platform_thread.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/scoped_ref_ptr.h" #include "webrtc/base/scoped_ref_ptr.h"
#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
@ -284,13 +284,13 @@ class ViEChannel : public VCMFrameTypeCallback,
rtc::CriticalSection crit_; rtc::CriticalSection crit_;
// Owned modules/classes. // Owned modules/classes.
rtc::scoped_ptr<ViEChannelProtectionCallback> vcm_protection_callback_; std::unique_ptr<ViEChannelProtectionCallback> vcm_protection_callback_;
VideoCodingModule* const vcm_; VideoCodingModule* const vcm_;
ViEReceiver vie_receiver_; ViEReceiver vie_receiver_;
// Helper to report call statistics. // Helper to report call statistics.
rtc::scoped_ptr<ChannelStatsObserver> stats_observer_; std::unique_ptr<ChannelStatsObserver> stats_observer_;
// Not owned. // Not owned.
ReceiveStatisticsProxy* receive_stats_callback_ GUARDED_BY(crit_); ReceiveStatisticsProxy* receive_stats_callback_ GUARDED_BY(crit_);
@ -301,7 +301,7 @@ class ViEChannel : public VCMFrameTypeCallback,
PacedSender* const paced_sender_; PacedSender* const paced_sender_;
PacketRouter* const packet_router_; PacketRouter* const packet_router_;
const rtc::scoped_ptr<RtcpBandwidthObserver> bandwidth_observer_; const std::unique_ptr<RtcpBandwidthObserver> bandwidth_observer_;
TransportFeedbackObserver* const transport_feedback_observer_; TransportFeedbackObserver* const transport_feedback_observer_;
int max_nack_reordering_threshold_; int max_nack_reordering_threshold_;

10
webrtc/video/vie_encoder.h
View File

@ -11,10 +11,10 @@
#ifndef WEBRTC_VIDEO_VIE_ENCODER_H_ #ifndef WEBRTC_VIDEO_VIE_ENCODER_H_
#define WEBRTC_VIDEO_VIE_ENCODER_H_ #define WEBRTC_VIDEO_VIE_ENCODER_H_
#include <memory>
#include <vector> #include <vector>
#include "webrtc/base/criticalsection.h" #include "webrtc/base/criticalsection.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/scoped_ref_ptr.h" #include "webrtc/base/scoped_ref_ptr.h"
#include "webrtc/base/thread_annotations.h" #include "webrtc/base/thread_annotations.h"
#include "webrtc/call/bitrate_allocator.h" #include "webrtc/call/bitrate_allocator.h"
@ -139,12 +139,12 @@ class ViEEncoder : public VideoEncoderRateObserver,
const uint32_t number_of_cores_; const uint32_t number_of_cores_;
const std::vector<uint32_t> ssrcs_; const std::vector<uint32_t> ssrcs_;
const rtc::scoped_ptr<VideoProcessing> vp_; const std::unique_ptr<VideoProcessing> vp_;
const rtc::scoped_ptr<QMVideoSettingsCallback> qm_callback_; const std::unique_ptr<QMVideoSettingsCallback> qm_callback_;
const rtc::scoped_ptr<VideoCodingModule> vcm_; const std::unique_ptr<VideoCodingModule> vcm_;
rtc::CriticalSection data_cs_; rtc::CriticalSection data_cs_;
rtc::scoped_ptr<BitrateObserver> bitrate_observer_; std::unique_ptr<BitrateObserver> bitrate_observer_;
SendStatisticsProxy* const stats_proxy_; SendStatisticsProxy* const stats_proxy_;
I420FrameCallback* const pre_encode_callback_; I420FrameCallback* const pre_encode_callback_;

14
webrtc/video/vie_receiver.h
View File

@ -12,10 +12,10 @@
#define WEBRTC_VIDEO_VIE_RECEIVER_H_ #define WEBRTC_VIDEO_VIE_RECEIVER_H_
#include <list> #include <list>
#include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/criticalsection.h" #include "webrtc/base/criticalsection.h"
#include "webrtc/engine_configurations.h" #include "webrtc/engine_configurations.h"
#include "webrtc/modules/rtp_rtcp/include/receive_statistics.h" #include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
@ -100,17 +100,17 @@ class ViEReceiver : public RtpData {
rtc::CriticalSection receive_cs_; rtc::CriticalSection receive_cs_;
Clock* clock_; Clock* clock_;
rtc::scoped_ptr<RtpHeaderParser> rtp_header_parser_; std::unique_ptr<RtpHeaderParser> rtp_header_parser_;
rtc::scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_; std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry_;
rtc::scoped_ptr<RtpReceiver> rtp_receiver_; std::unique_ptr<RtpReceiver> rtp_receiver_;
const rtc::scoped_ptr<ReceiveStatistics> rtp_receive_statistics_; const std::unique_ptr<ReceiveStatistics> rtp_receive_statistics_;
rtc::scoped_ptr<FecReceiver> fec_receiver_; std::unique_ptr<FecReceiver> fec_receiver_;
RtpRtcp* rtp_rtcp_; RtpRtcp* rtp_rtcp_;
std::vector<RtpRtcp*> rtp_rtcp_simulcast_; std::vector<RtpRtcp*> rtp_rtcp_simulcast_;
VideoCodingModule* vcm_; VideoCodingModule* vcm_;
RemoteBitrateEstimator* remote_bitrate_estimator_; RemoteBitrateEstimator* remote_bitrate_estimator_;
rtc::scoped_ptr<RemoteNtpTimeEstimator> ntp_estimator_; std::unique_ptr<RemoteNtpTimeEstimator> ntp_estimator_;
bool receiving_; bool receiving_;
uint8_t restored_packet_[IP_PACKET_SIZE]; uint8_t restored_packet_[IP_PACKET_SIZE];

1
webrtc/video/vie_remb.h
View File

@ -16,7 +16,6 @@
#include <vector> #include <vector>
#include "webrtc/base/criticalsection.h" #include "webrtc/base/criticalsection.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/include/module.h" #include "webrtc/modules/include/module.h"
#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"

6
webrtc/video/vie_remb_unittest.cc
View File

@ -11,11 +11,11 @@
// This file includes unit tests for ViERemb. // This file includes unit tests for ViERemb.
#include <memory>
#include <vector> #include <vector>
#include "testing/gmock/include/gmock/gmock.h" #include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
#include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
#include "webrtc/modules/utility/include/mock/mock_process_thread.h" #include "webrtc/modules/utility/include/mock/mock_process_thread.h"
@ -39,8 +39,8 @@ class ViERembTest : public ::testing::Test {
vie_remb_.reset(new VieRemb(&fake_clock_)); vie_remb_.reset(new VieRemb(&fake_clock_));
} }
SimulatedClock fake_clock_; SimulatedClock fake_clock_;
rtc::scoped_ptr<MockProcessThread> process_thread_; std::unique_ptr<MockProcessThread> process_thread_;
rtc::scoped_ptr<VieRemb> vie_remb_; std::unique_ptr<VieRemb> vie_remb_;
}; };
TEST_F(ViERembTest, OneModuleTestForSendingRemb) { TEST_F(ViERembTest, OneModuleTestForSendingRemb) {

5
webrtc/video/vie_sync_module.h
View File

@ -14,8 +14,9 @@
#ifndef WEBRTC_VIDEO_VIE_SYNC_MODULE_H_ #ifndef WEBRTC_VIDEO_VIE_SYNC_MODULE_H_
#define WEBRTC_VIDEO_VIE_SYNC_MODULE_H_ #define WEBRTC_VIDEO_VIE_SYNC_MODULE_H_
#include <memory>
#include "webrtc/base/criticalsection.h" #include "webrtc/base/criticalsection.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/include/module.h" #include "webrtc/modules/include/module.h"
#include "webrtc/system_wrappers/include/tick_util.h" #include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/video/stream_synchronization.h" #include "webrtc/video/stream_synchronization.h"
@ -50,7 +51,7 @@ class ViESyncModule : public Module {
int voe_channel_id_; int voe_channel_id_;
VoEVideoSync* voe_sync_interface_; VoEVideoSync* voe_sync_interface_;
TickTime last_sync_time_; TickTime last_sync_time_;
rtc::scoped_ptr<StreamSynchronization> sync_; std::unique_ptr<StreamSynchronization> sync_;
StreamSynchronization::Measurements audio_measurement_; StreamSynchronization::Measurements audio_measurement_;
StreamSynchronization::Measurements video_measurement_; StreamSynchronization::Measurements video_measurement_;
}; };