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_
#include <list>
#include <memory>
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/criticalsection.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/include/module.h"
#include "webrtc/system_wrappers/include/clock.h"
@ -64,7 +64,7 @@ class CallStats : public Module {
// Protecting all members.
rtc::CriticalSection crit_;
// 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.
int64_t last_process_time_;
// 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.
*/
#include <memory>
#include "testing/gmock/include/gmock/gmock.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/system_wrappers/include/metrics.h"
#include "webrtc/system_wrappers/include/tick_util.h"
@ -39,7 +40,7 @@ class CallStatsTest : public ::testing::Test {
protected:
virtual void SetUp() { call_stats_.reset(new CallStats(&fake_clock_)); }
SimulatedClock fake_clock_;
rtc::scoped_ptr<CallStats> call_stats_;
std::unique_ptr<CallStats> call_stats_;
};
TEST_F(CallStatsTest, AddAndTriggerCallback) {

44
webrtc/video/end_to_end_tests.cc
View File

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

4
webrtc/video/overuse_frame_detector.cc
View File

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

4
webrtc/video/overuse_frame_detector.h
View File

@ -12,11 +12,11 @@
#define WEBRTC_VIDEO_OVERUSE_FRAME_DETECTOR_H_
#include <list>
#include <memory>
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/criticalsection.h"
#include "webrtc/base/optional.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/exp_filter.h"
#include "webrtc/base/thread_annotations.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
// 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_);
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.
*/
#include <memory>
#include "webrtc/video/overuse_frame_detector.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/video_frame.h"
@ -121,9 +122,9 @@ class OveruseFrameDetectorTest : public ::testing::Test,
int UsagePercent() { return metrics_.encode_usage_percent; }
CpuOveruseOptions options_;
rtc::scoped_ptr<SimulatedClock> clock_;
rtc::scoped_ptr<MockCpuOveruseObserver> observer_;
rtc::scoped_ptr<OveruseFrameDetector> overuse_detector_;
std::unique_ptr<SimulatedClock> clock_;
std::unique_ptr<MockCpuOveruseObserver> observer_;
std::unique_ptr<OveruseFrameDetector> overuse_detector_;
CpuOveruseMetrics metrics_;
};

1
webrtc/video/payload_router.h
View File

@ -15,7 +15,6 @@
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/criticalsection.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/thread_annotations.h"
#include "webrtc/common_types.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.
*/
#include <memory>
#include "testing/gmock/include/gmock/gmock.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/mocks/mock_rtp_rtcp.h"
#include "webrtc/video/payload_router.h"
@ -27,7 +28,7 @@ class PayloadRouterTest : public ::testing::Test {
virtual void SetUp() {
payload_router_.reset(new PayloadRouter());
}
rtc::scoped_ptr<PayloadRouter> payload_router_;
std::unique_ptr<PayloadRouter> payload_router_;
};
TEST_F(PayloadRouterTest, SendOnOneModule) {

12
webrtc/video/replay.cc
View File

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

3
webrtc/video/send_statistics_proxy_unittest.cc
View File

@ -12,6 +12,7 @@
#include "webrtc/video/send_statistics_proxy.h"
#include <map>
#include <memory>
#include <string>
#include <vector>
@ -94,7 +95,7 @@ class SendStatisticsProxyTest : public ::testing::Test {
}
SimulatedClock fake_clock_;
rtc::scoped_ptr<SendStatisticsProxy> statistics_proxy_;
std::unique_ptr<SendStatisticsProxy> statistics_proxy_;
VideoSendStream::Config config_;
int avg_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 <memory>
#include <vector>
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.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/scoped_vector.h"
#include "webrtc/test/fake_texture_frame.h"
@ -82,12 +82,12 @@ class VideoCaptureInputTest : public ::testing::Test {
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.
rtc::scoped_ptr<internal::VideoCaptureInput> input_;
std::unique_ptr<internal::VideoCaptureInput> input_;
// Input capture frames of VideoCaptureInput.
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/event.h"
#include "webrtc/base/format_macros.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/call.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
@ -1039,7 +1038,7 @@ void VideoQualityTest::RunWithVideoRenderer(const Params& params) {
params_ = params;
CheckParams();
rtc::scoped_ptr<test::VideoRenderer> local_preview(
std::unique_ptr<test::VideoRenderer> local_preview(
test::VideoRenderer::Create("Local Preview", params_.common.width,
params_.common.height));
size_t stream_id = params_.ss.selected_stream;
@ -1050,7 +1049,7 @@ void VideoQualityTest::RunWithVideoRenderer(const Params& params) {
title += " - Stream #" + s.str();
}
rtc::scoped_ptr<test::VideoRenderer> loopback_video(
std::unique_ptr<test::VideoRenderer> loopback_video(
test::VideoRenderer::Create(title.c_str(),
params_.ss.streams[stream_id].width,
params_.ss.streams[stream_id].height));
@ -1059,7 +1058,7 @@ void VideoQualityTest::RunWithVideoRenderer(const Params& params) {
// match the full stack tests.
Call::Config call_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(
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_
#define WEBRTC_VIDEO_VIDEO_QUALITY_TEST_H_
#include <memory>
#include <string>
#include <vector>
@ -103,10 +104,10 @@ class VideoQualityTest : public test::CallTest {
void SetupScreenshare();
// We need a more general capturer than the FrameGeneratorCapturer.
rtc::scoped_ptr<test::VideoCapturer> capturer_;
rtc::scoped_ptr<test::TraceToStderr> trace_to_stderr_;
rtc::scoped_ptr<test::FrameGenerator> frame_generator_;
rtc::scoped_ptr<VideoEncoder> encoder_;
std::unique_ptr<test::VideoCapturer> capturer_;
std::unique_ptr<test::TraceToStderr> trace_to_stderr_;
std::unique_ptr<test::FrameGenerator> frame_generator_;
std::unique_ptr<VideoEncoder> encoder_;
VideoCodecUnion codec_settings_;
Clock* const clock_;

4
webrtc/video/video_receive_stream.h
View File

@ -11,9 +11,9 @@
#ifndef WEBRTC_VIDEO_VIDEO_RECEIVE_STREAM_H_
#define WEBRTC_VIDEO_VIDEO_RECEIVE_STREAM_H_
#include <memory>
#include <vector>
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/call.h"
#include "webrtc/call/transport_adapter.h"
#include "webrtc/common_video/include/incoming_video_stream.h"
@ -95,7 +95,7 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
CallStats* const call_stats_;
VieRemb* const remb_;
rtc::scoped_ptr<VideoCodingModule> vcm_;
std::unique_ptr<VideoCodingModule> vcm_;
IncomingVideoStream incoming_video_stream_;
ReceiveStatisticsProxy stats_proxy_;
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.
*/
#include <algorithm> // max
#include <memory>
#include <vector>
#include "testing/gtest/include/gtest/gtest.h"
@ -18,7 +19,6 @@
#include "webrtc/base/event.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/platform_thread.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/call.h"
#include "webrtc/call/transport_adapter.h"
#include "webrtc/frame_callback.h"
@ -304,7 +304,7 @@ class FakeReceiveStatistics : public NullReceiveStatistics {
RtcpStatistics stats_;
};
rtc::scoped_ptr<LossyStatistician> lossy_stats_;
std::unique_ptr<LossyStatistician> lossy_stats_;
StatisticianMap stats_map_;
};
@ -442,8 +442,8 @@ class FecObserver : public test::EndToEndTest {
EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets.";
}
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
rtc::scoped_ptr<VideoEncoder> encoder_;
std::unique_ptr<internal::TransportAdapter> transport_adapter_;
std::unique_ptr<VideoEncoder> encoder_;
const std::string payload_name_;
const bool use_nack_;
const bool expect_red_;
@ -562,7 +562,7 @@ void VideoSendStreamTest::TestNackRetransmission(
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_;
uint32_t retransmit_ssrc_;
uint8_t retransmit_payload_type_;
@ -758,7 +758,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
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_;
const size_t max_packet_size_;
@ -937,7 +937,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
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_;
VideoSendStream* stream_;
@ -1015,7 +1015,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
}
Clock* const clock_;
rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
std::unique_ptr<internal::TransportAdapter> transport_adapter_;
rtc::CriticalSection crit_;
int64_t last_packet_time_ms_ 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.";
}
rtc::scoped_ptr<RtpRtcp> rtp_rtcp_;
rtc::scoped_ptr<internal::TransportAdapter> feedback_transport_;
std::unique_ptr<RtpRtcp> rtp_rtcp_;
std::unique_ptr<internal::TransportAdapter> feedback_transport_;
VideoSendStream* stream_;
bool bitrate_capped_;
} test;
@ -1292,7 +1292,7 @@ void ExpectEqualFramesVector(const std::vector<VideoFrame>& frames1,
VideoFrame CreateVideoFrame(int width, int height, uint8_t data) {
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);
VideoFrame frame;
frame.CreateFrame(buffer.get(), buffer.get(), buffer.get(), width, height,
@ -2168,7 +2168,7 @@ class Vp9HeaderObserver : public test::SendTest {
VerifyTl0Idx(vp9);
}
rtc::scoped_ptr<VP9Encoder> vp9_encoder_;
std::unique_ptr<VP9Encoder> vp9_encoder_;
VideoCodecVP9 vp9_settings_;
webrtc::VideoEncoderConfig encoder_config_;
RTPHeader last_header_;

8
webrtc/video/vie_channel.h
View File

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

10
webrtc/video/vie_encoder.h
View File

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

14
webrtc/video/vie_receiver.h
View File

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

1
webrtc/video/vie_remb.h
View File

@ -16,7 +16,6 @@
#include <vector>
#include "webrtc/base/criticalsection.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/include/module.h"
#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.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.
#include <memory>
#include <vector>
#include "testing/gmock/include/gmock/gmock.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/mocks/mock_rtp_rtcp.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_));
}
SimulatedClock fake_clock_;
rtc::scoped_ptr<MockProcessThread> process_thread_;
rtc::scoped_ptr<VieRemb> vie_remb_;
std::unique_ptr<MockProcessThread> process_thread_;
std::unique_ptr<VieRemb> vie_remb_;
};
TEST_F(ViERembTest, OneModuleTestForSendingRemb) {

5
webrtc/video/vie_sync_module.h
View File

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