diff --git a/DEPS b/DEPS index acd57192a..6a678d961 100644 --- a/DEPS +++ b/DEPS @@ -6,7 +6,7 @@ vars = { 'extra_gyp_flag': '-Dextra_gyp_flag=0', 'chromium_git': 'https://chromium.googlesource.com', - 'chromium_revision': 'e144d30232209034b82d544926070bb8dc62f6ec', + 'chromium_revision': '6fdb1425edf17f7b3d55626927d4fddb076a8e31', } # NOTE: Prefer revision numbers to tags for svn deps. Use http rather than diff --git a/talk/app/webrtc/audiotrack.h b/talk/app/webrtc/audiotrack.h index d351b2af3..750f272ba 100644 --- a/talk/app/webrtc/audiotrack.h +++ b/talk/app/webrtc/audiotrack.h @@ -42,21 +42,20 @@ class AudioTrack : public MediaStreamTrack { const std::string& id, AudioSourceInterface* source); // AudioTrackInterface implementation. - virtual AudioSourceInterface* GetSource() const OVERRIDE { + AudioSourceInterface* GetSource() const override { return audio_source_.get(); } // TODO(xians): Implement these methods. - virtual void AddSink(AudioTrackSinkInterface* sink) OVERRIDE {} - virtual void RemoveSink(AudioTrackSinkInterface* sink) OVERRIDE {} - virtual bool GetSignalLevel(int* level) OVERRIDE { return false; } - virtual rtc::scoped_refptr GetAudioProcessor() - OVERRIDE { return NULL; } - virtual cricket::AudioRenderer* GetRenderer() OVERRIDE { + void AddSink(AudioTrackSinkInterface* sink) override {} + void RemoveSink(AudioTrackSinkInterface* sink) override {} + bool GetSignalLevel(int* level) override { return false; } + rtc::scoped_refptr GetAudioProcessor() override { return NULL; } + cricket::AudioRenderer* GetRenderer() override { return NULL; } // MediaStreamTrack implementation. - virtual std::string kind() const OVERRIDE; + std::string kind() const override; protected: AudioTrack(const std::string& label, AudioSourceInterface* audio_source); diff --git a/talk/app/webrtc/audiotrackrenderer.h b/talk/app/webrtc/audiotrackrenderer.h index 8227272f3..e22805fe1 100644 --- a/talk/app/webrtc/audiotrackrenderer.h +++ b/talk/app/webrtc/audiotrackrenderer.h @@ -47,8 +47,8 @@ class AudioTrackRenderer : public cricket::AudioRenderer { ~AudioTrackRenderer(); // Implements cricket::AudioRenderer. - virtual void AddChannel(int channel_id) OVERRIDE; - virtual void RemoveChannel(int channel_id) OVERRIDE; + void AddChannel(int channel_id) override; + void RemoveChannel(int channel_id) override; private: int channel_id_; diff --git a/talk/app/webrtc/dtmfsender.h b/talk/app/webrtc/dtmfsender.h index 188b0e351..ec9a36ef2 100644 --- a/talk/app/webrtc/dtmfsender.h +++ b/talk/app/webrtc/dtmfsender.h @@ -78,15 +78,16 @@ class DtmfSender DtmfProviderInterface* provider); // Implements DtmfSenderInterface. - virtual void RegisterObserver(DtmfSenderObserverInterface* observer) OVERRIDE; - virtual void UnregisterObserver() OVERRIDE; - virtual bool CanInsertDtmf() OVERRIDE; - virtual bool InsertDtmf(const std::string& tones, int duration, - int inter_tone_gap) OVERRIDE; - virtual const AudioTrackInterface* track() const OVERRIDE; - virtual std::string tones() const OVERRIDE; - virtual int duration() const OVERRIDE; - virtual int inter_tone_gap() const OVERRIDE; + void RegisterObserver(DtmfSenderObserverInterface* observer) override; + void UnregisterObserver() override; + bool CanInsertDtmf() override; + bool InsertDtmf(const std::string& tones, + int duration, + int inter_tone_gap) override; + const AudioTrackInterface* track() const override; + std::string tones() const override; + int duration() const override; + int inter_tone_gap() const override; protected: DtmfSender(AudioTrackInterface* track, diff --git a/talk/app/webrtc/dtmfsender_unittest.cc b/talk/app/webrtc/dtmfsender_unittest.cc index 861a69574..64f43e412 100644 --- a/talk/app/webrtc/dtmfsender_unittest.cc +++ b/talk/app/webrtc/dtmfsender_unittest.cc @@ -50,7 +50,7 @@ class FakeDtmfObserver : public DtmfSenderObserverInterface { FakeDtmfObserver() : completed_(false) {} // Implements DtmfSenderObserverInterface. - virtual void OnToneChange(const std::string& tone) OVERRIDE { + void OnToneChange(const std::string& tone) override { LOG(LS_VERBOSE) << "FakeDtmfObserver::OnToneChange '" << tone << "'."; tones_.push_back(tone); if (tone.empty()) { @@ -90,12 +90,13 @@ class FakeDtmfProvider : public DtmfProviderInterface { } // Implements DtmfProviderInterface. - virtual bool CanInsertDtmf(const std::string& track_label) OVERRIDE { + bool CanInsertDtmf(const std::string& track_label) override { return (can_insert_dtmf_tracks_.count(track_label) != 0); } - virtual bool InsertDtmf(const std::string& track_label, - int code, int duration) OVERRIDE { + bool InsertDtmf(const std::string& track_label, + int code, + int duration) override { int gap = 0; // TODO(ronghuawu): Make the timer (basically the rtc::TimeNanos) // mockable and use a fake timer in the unit tests. diff --git a/talk/app/webrtc/java/jni/androidvideocapturer_jni.h b/talk/app/webrtc/java/jni/androidvideocapturer_jni.h index 9149f2c38..e6717dbb1 100644 --- a/talk/app/webrtc/java/jni/androidvideocapturer_jni.h +++ b/talk/app/webrtc/java/jni/androidvideocapturer_jni.h @@ -57,7 +57,7 @@ class AndroidVideoCapturerJni : public webrtc::AndroidVideoCapturerDelegate { webrtc::AndroidVideoCapturer* capturer) override; void Stop() override; - virtual void ReturnBuffer(int64 time_stamp) override; + void ReturnBuffer(int64 time_stamp) override; std::string GetSupportedFormats() override; diff --git a/talk/app/webrtc/java/jni/peerconnection_jni.cc b/talk/app/webrtc/java/jni/peerconnection_jni.cc index 8f5e7f2d1..f26985848 100644 --- a/talk/app/webrtc/java/jni/peerconnection_jni.cc +++ b/talk/app/webrtc/java/jni/peerconnection_jni.cc @@ -212,7 +212,7 @@ class PCOJava : public PeerConnectionObserver { virtual ~PCOJava() {} - virtual void OnIceCandidate(const IceCandidateInterface* candidate) OVERRIDE { + void OnIceCandidate(const IceCandidateInterface* candidate) override { ScopedLocalRefFrame local_ref_frame(jni()); std::string sdp; CHECK(candidate->ToString(&sdp)) << "got so far: " << sdp; @@ -230,8 +230,8 @@ class PCOJava : public PeerConnectionObserver { CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; } - virtual void OnSignalingChange( - PeerConnectionInterface::SignalingState new_state) OVERRIDE { + void OnSignalingChange( + PeerConnectionInterface::SignalingState new_state) override { ScopedLocalRefFrame local_ref_frame(jni()); jmethodID m = GetMethodID( jni(), *j_observer_class_, "onSignalingChange", @@ -242,8 +242,8 @@ class PCOJava : public PeerConnectionObserver { CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; } - virtual void OnIceConnectionChange( - PeerConnectionInterface::IceConnectionState new_state) OVERRIDE { + void OnIceConnectionChange( + PeerConnectionInterface::IceConnectionState new_state) override { ScopedLocalRefFrame local_ref_frame(jni()); jmethodID m = GetMethodID( jni(), *j_observer_class_, "onIceConnectionChange", @@ -254,8 +254,8 @@ class PCOJava : public PeerConnectionObserver { CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; } - virtual void OnIceGatheringChange( - PeerConnectionInterface::IceGatheringState new_state) OVERRIDE { + void OnIceGatheringChange( + PeerConnectionInterface::IceGatheringState new_state) override { ScopedLocalRefFrame local_ref_frame(jni()); jmethodID m = GetMethodID( jni(), *j_observer_class_, "onIceGatheringChange", @@ -266,7 +266,7 @@ class PCOJava : public PeerConnectionObserver { CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; } - virtual void OnAddStream(MediaStreamInterface* stream) OVERRIDE { + void OnAddStream(MediaStreamInterface* stream) override { ScopedLocalRefFrame local_ref_frame(jni()); jobject j_stream = jni()->NewObject( *j_media_stream_class_, j_media_stream_ctor_, (jlong)stream); @@ -322,7 +322,7 @@ class PCOJava : public PeerConnectionObserver { CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; } - virtual void OnRemoveStream(MediaStreamInterface* stream) OVERRIDE { + void OnRemoveStream(MediaStreamInterface* stream) override { ScopedLocalRefFrame local_ref_frame(jni()); NativeToJavaStreamsMap::iterator it = streams_.find(stream); CHECK(it != streams_.end()) << "unexpected stream: " << std::hex << stream; @@ -338,7 +338,7 @@ class PCOJava : public PeerConnectionObserver { CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; } - virtual void OnDataChannel(DataChannelInterface* channel) OVERRIDE { + void OnDataChannel(DataChannelInterface* channel) override { ScopedLocalRefFrame local_ref_frame(jni()); jobject j_channel = jni()->NewObject( *j_data_channel_class_, j_data_channel_ctor_, (jlong)channel); @@ -358,7 +358,7 @@ class PCOJava : public PeerConnectionObserver { CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; } - virtual void OnRenegotiationNeeded() OVERRIDE { + void OnRenegotiationNeeded() override { ScopedLocalRefFrame local_ref_frame(jni()); jmethodID m = GetMethodID(jni(), *j_observer_class_, "onRenegotiationNeeded", "()V"); @@ -407,13 +407,9 @@ class ConstraintsWrapper : public MediaConstraintsInterface { virtual ~ConstraintsWrapper() {} // MediaConstraintsInterface. - virtual const Constraints& GetMandatory() const OVERRIDE { - return mandatory_; - } + const Constraints& GetMandatory() const override { return mandatory_; } - virtual const Constraints& GetOptional() const OVERRIDE { - return optional_; - } + const Constraints& GetOptional() const override { return optional_; } private: // Helper for translating a List> to a Constraints. @@ -493,7 +489,7 @@ class SdpObserverWrapper : public T { virtual ~SdpObserverWrapper() {} - // Can't mark OVERRIDE because of templating. + // Can't mark override because of templating. virtual void OnSuccess() { ScopedLocalRefFrame local_ref_frame(jni()); jmethodID m = GetMethodID(jni(), *j_observer_class_, "onSetSuccess", "()V"); @@ -501,7 +497,7 @@ class SdpObserverWrapper : public T { CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; } - // Can't mark OVERRIDE because of templating. + // Can't mark override because of templating. virtual void OnSuccess(SessionDescriptionInterface* desc) { ScopedLocalRefFrame local_ref_frame(jni()); jmethodID m = GetMethodID( @@ -540,7 +536,7 @@ class CreateSdpObserverWrapper ConstraintsWrapper* constraints) : SdpObserverWrapper(jni, j_observer, constraints) {} - virtual void OnFailure(const std::string& error) OVERRIDE { + void OnFailure(const std::string& error) override { ScopedLocalRefFrame local_ref_frame(jni()); SdpObserverWrapper::OnFailure(std::string("Create"), error); } @@ -553,7 +549,7 @@ class SetSdpObserverWrapper ConstraintsWrapper* constraints) : SdpObserverWrapper(jni, j_observer, constraints) {} - virtual void OnFailure(const std::string& error) OVERRIDE { + void OnFailure(const std::string& error) override { ScopedLocalRefFrame local_ref_frame(jni()); SdpObserverWrapper::OnFailure(std::string("Set"), error); } @@ -577,13 +573,13 @@ class DataChannelObserverWrapper : public DataChannelObserver { virtual ~DataChannelObserverWrapper() {} - virtual void OnStateChange() OVERRIDE { + void OnStateChange() override { ScopedLocalRefFrame local_ref_frame(jni()); jni()->CallVoidMethod(*j_observer_global_, j_on_state_change_mid_); CHECK_EXCEPTION(jni()) << "error during CallVoidMethod"; } - virtual void OnMessage(const DataBuffer& buffer) OVERRIDE { + void OnMessage(const DataBuffer& buffer) override { ScopedLocalRefFrame local_ref_frame(jni()); jobject byte_buffer = jni()->NewDirectByteBuffer(const_cast(buffer.data.data()), @@ -628,7 +624,7 @@ class StatsObserverWrapper : public StatsObserver { virtual ~StatsObserverWrapper() {} - virtual void OnComplete(const StatsReports& reports) OVERRIDE { + void OnComplete(const StatsReports& reports) override { ScopedLocalRefFrame local_ref_frame(jni()); jobjectArray j_reports = ReportsToJava(jni(), reports); jmethodID m = GetMethodID(jni(), *j_observer_class_, "onComplete", @@ -700,13 +696,13 @@ class VideoRendererWrapper : public VideoRendererInterface { virtual ~VideoRendererWrapper() {} - virtual void SetSize(int width, int height) OVERRIDE { + void SetSize(int width, int height) override { ScopedLocalRefFrame local_ref_frame(AttachCurrentThreadIfNeeded()); const bool kNotReserved = false; // What does this param mean?? renderer_->SetSize(width, height, kNotReserved); } - virtual void RenderFrame(const cricket::VideoFrame* frame) OVERRIDE { + void RenderFrame(const cricket::VideoFrame* frame) override { ScopedLocalRefFrame local_ref_frame(AttachCurrentThreadIfNeeded()); renderer_->RenderFrame(frame); } @@ -742,13 +738,13 @@ class JavaVideoRendererWrapper : public VideoRendererInterface { virtual ~JavaVideoRendererWrapper() {} - virtual void SetSize(int width, int height) OVERRIDE { + void SetSize(int width, int height) override { ScopedLocalRefFrame local_ref_frame(jni()); jni()->CallVoidMethod(*j_callbacks_, j_set_size_id_, width, height); CHECK_EXCEPTION(jni()); } - virtual void RenderFrame(const cricket::VideoFrame* frame) OVERRIDE { + void RenderFrame(const cricket::VideoFrame* frame) override { ScopedLocalRefFrame local_ref_frame(jni()); if (frame->GetNativeHandle() != NULL) { jobject j_frame = CricketToJavaTextureFrame(frame); diff --git a/talk/app/webrtc/mediastream.h b/talk/app/webrtc/mediastream.h index cbe67129c..240512d9c 100644 --- a/talk/app/webrtc/mediastream.h +++ b/talk/app/webrtc/mediastream.h @@ -42,19 +42,19 @@ class MediaStream : public Notifier { public: static rtc::scoped_refptr Create(const std::string& label); - virtual std::string label() const OVERRIDE { return label_; } + std::string label() const override { return label_; } - virtual bool AddTrack(AudioTrackInterface* track) OVERRIDE; - virtual bool AddTrack(VideoTrackInterface* track) OVERRIDE; - virtual bool RemoveTrack(AudioTrackInterface* track) OVERRIDE; - virtual bool RemoveTrack(VideoTrackInterface* track) OVERRIDE; + bool AddTrack(AudioTrackInterface* track) override; + bool AddTrack(VideoTrackInterface* track) override; + bool RemoveTrack(AudioTrackInterface* track) override; + bool RemoveTrack(VideoTrackInterface* track) override; virtual rtc::scoped_refptr FindAudioTrack(const std::string& track_id); virtual rtc::scoped_refptr FindVideoTrack(const std::string& track_id); - virtual AudioTrackVector GetAudioTracks() OVERRIDE { return audio_tracks_; } - virtual VideoTrackVector GetVideoTracks() OVERRIDE { return video_tracks_; } + AudioTrackVector GetAudioTracks() override { return audio_tracks_; } + VideoTrackVector GetVideoTracks() override { return video_tracks_; } protected: explicit MediaStream(const std::string& label); diff --git a/talk/app/webrtc/mediastreamhandler.h b/talk/app/webrtc/mediastreamhandler.h index ef858e550..801648dc0 100644 --- a/talk/app/webrtc/mediastreamhandler.h +++ b/talk/app/webrtc/mediastreamhandler.h @@ -78,12 +78,14 @@ class LocalAudioSinkAdapter : public AudioTrackSinkInterface, private: // AudioSinkInterface implementation. - virtual void OnData(const void* audio_data, int bits_per_sample, - int sample_rate, int number_of_channels, - int number_of_frames) OVERRIDE; + void OnData(const void* audio_data, + int bits_per_sample, + int sample_rate, + int number_of_channels, + int number_of_frames) override; // cricket::AudioRenderer implementation. - virtual void SetSink(cricket::AudioRenderer::Sink* sink) OVERRIDE; + void SetSink(cricket::AudioRenderer::Sink* sink) override; cricket::AudioRenderer::Sink* sink_; // Critical section protecting |sink_|. @@ -100,11 +102,11 @@ class LocalAudioTrackHandler : public TrackHandler { AudioProviderInterface* provider); virtual ~LocalAudioTrackHandler(); - virtual void Stop() OVERRIDE; + void Stop() override; protected: - virtual void OnStateChanged() OVERRIDE; - virtual void OnEnabledChanged() OVERRIDE; + void OnStateChanged() override; + void OnEnabledChanged() override; private: AudioTrackInterface* audio_track_; @@ -125,15 +127,15 @@ class RemoteAudioTrackHandler : public AudioSourceInterface::AudioObserver, uint32 ssrc, AudioProviderInterface* provider); virtual ~RemoteAudioTrackHandler(); - virtual void Stop() OVERRIDE; + void Stop() override; protected: - virtual void OnStateChanged() OVERRIDE; - virtual void OnEnabledChanged() OVERRIDE; + void OnStateChanged() override; + void OnEnabledChanged() override; private: // AudioSourceInterface::AudioObserver implementation. - virtual void OnSetVolume(double volume) OVERRIDE; + void OnSetVolume(double volume) override; AudioTrackInterface* audio_track_; AudioProviderInterface* provider_; @@ -148,11 +150,11 @@ class LocalVideoTrackHandler : public TrackHandler { uint32 ssrc, VideoProviderInterface* provider); virtual ~LocalVideoTrackHandler(); - virtual void Stop() OVERRIDE; + void Stop() override; protected: - virtual void OnStateChanged() OVERRIDE; - virtual void OnEnabledChanged() OVERRIDE; + void OnStateChanged() override; + void OnEnabledChanged() override; private: VideoTrackInterface* local_video_track_; @@ -168,11 +170,11 @@ class RemoteVideoTrackHandler : public TrackHandler { uint32 ssrc, VideoProviderInterface* provider); virtual ~RemoteVideoTrackHandler(); - virtual void Stop() OVERRIDE; + void Stop() override; protected: - virtual void OnStateChanged() OVERRIDE; - virtual void OnEnabledChanged() OVERRIDE; + void OnStateChanged() override; + void OnEnabledChanged() override; private: VideoTrackInterface* remote_video_track_; @@ -192,7 +194,7 @@ class MediaStreamHandler : public ObserverInterface { virtual void AddVideoTrack(VideoTrackInterface* video_track, uint32 ssrc) = 0; virtual void RemoveTrack(MediaStreamTrackInterface* track); - virtual void OnChanged() OVERRIDE; + void OnChanged() override; protected: TrackHandler* FindTrackHandler(MediaStreamTrackInterface* track); @@ -210,10 +212,8 @@ class LocalMediaStreamHandler : public MediaStreamHandler { VideoProviderInterface* video_provider); ~LocalMediaStreamHandler(); - virtual void AddAudioTrack(AudioTrackInterface* audio_track, - uint32 ssrc) OVERRIDE; - virtual void AddVideoTrack(VideoTrackInterface* video_track, - uint32 ssrc) OVERRIDE; + void AddAudioTrack(AudioTrackInterface* audio_track, uint32 ssrc) override; + void AddVideoTrack(VideoTrackInterface* video_track, uint32 ssrc) override; }; class RemoteMediaStreamHandler : public MediaStreamHandler { @@ -222,10 +222,8 @@ class RemoteMediaStreamHandler : public MediaStreamHandler { AudioProviderInterface* audio_provider, VideoProviderInterface* video_provider); ~RemoteMediaStreamHandler(); - virtual void AddAudioTrack(AudioTrackInterface* audio_track, - uint32 ssrc) OVERRIDE; - virtual void AddVideoTrack(VideoTrackInterface* video_track, - uint32 ssrc) OVERRIDE; + void AddAudioTrack(AudioTrackInterface* audio_track, uint32 ssrc) override; + void AddVideoTrack(VideoTrackInterface* video_track, uint32 ssrc) override; }; // Container for MediaStreamHandlers of currently known local and remote diff --git a/talk/app/webrtc/objc/RTCDataChannel.mm b/talk/app/webrtc/objc/RTCDataChannel.mm index e3126f86b..07b90d964 100644 --- a/talk/app/webrtc/objc/RTCDataChannel.mm +++ b/talk/app/webrtc/objc/RTCDataChannel.mm @@ -39,11 +39,11 @@ class RTCDataChannelObserver : public DataChannelObserver { public: RTCDataChannelObserver(RTCDataChannel* channel) { _channel = channel; } - virtual void OnStateChange() OVERRIDE { + void OnStateChange() override { [_channel.delegate channelDidChangeState:_channel]; } - virtual void OnMessage(const DataBuffer& buffer) OVERRIDE { + void OnMessage(const DataBuffer& buffer) override { if (!_channel.delegate) { return; } diff --git a/talk/app/webrtc/objc/RTCMediaStreamTrack.mm b/talk/app/webrtc/objc/RTCMediaStreamTrack.mm index 65f3bc6cb..c529f5a4b 100644 --- a/talk/app/webrtc/objc/RTCMediaStreamTrack.mm +++ b/talk/app/webrtc/objc/RTCMediaStreamTrack.mm @@ -38,7 +38,7 @@ class RTCMediaStreamTrackObserver : public ObserverInterface { public: RTCMediaStreamTrackObserver(RTCMediaStreamTrack* track) { _track = track; } - virtual void OnChanged() OVERRIDE { + void OnChanged() override { [_track.delegate mediaStreamTrackDidChange:_track]; } diff --git a/talk/app/webrtc/objc/RTCPeerConnection.mm b/talk/app/webrtc/objc/RTCPeerConnection.mm index a06a8928e..769219e1e 100644 --- a/talk/app/webrtc/objc/RTCPeerConnection.mm +++ b/talk/app/webrtc/objc/RTCPeerConnection.mm @@ -62,7 +62,7 @@ class RTCCreateSessionDescriptionObserver _peerConnection = peerConnection; } - virtual void OnSuccess(SessionDescriptionInterface* desc) OVERRIDE { + void OnSuccess(SessionDescriptionInterface* desc) override { RTCSessionDescription* session = [[RTCSessionDescription alloc] initWithSessionDescription:desc]; [_delegate peerConnection:_peerConnection @@ -71,7 +71,7 @@ class RTCCreateSessionDescriptionObserver delete desc; } - virtual void OnFailure(const std::string& error) OVERRIDE { + void OnFailure(const std::string& error) override { NSString* str = @(error.c_str()); NSError* err = [NSError errorWithDomain:kRTCSessionDescriptionDelegateErrorDomain @@ -95,12 +95,12 @@ class RTCSetSessionDescriptionObserver : public SetSessionDescriptionObserver { _peerConnection = peerConnection; } - virtual void OnSuccess() OVERRIDE { + void OnSuccess() override { [_delegate peerConnection:_peerConnection didSetSessionDescriptionWithError:nil]; } - virtual void OnFailure(const std::string& error) OVERRIDE { + void OnFailure(const std::string& error) override { NSString* str = @(error.c_str()); NSError* err = [NSError errorWithDomain:kRTCSessionDescriptionDelegateErrorDomain @@ -123,7 +123,7 @@ class RTCStatsObserver : public StatsObserver { _peerConnection = peerConnection; } - virtual void OnComplete(const StatsReports& reports) OVERRIDE { + void OnComplete(const StatsReports& reports) override { NSMutableArray* stats = [NSMutableArray arrayWithCapacity:reports.size()]; for (const auto* report : reports) { RTCStatsReport* statsReport = diff --git a/talk/app/webrtc/objc/RTCPeerConnectionObserver.h b/talk/app/webrtc/objc/RTCPeerConnectionObserver.h index fd09d0a34..9b981b930 100644 --- a/talk/app/webrtc/objc/RTCPeerConnectionObserver.h +++ b/talk/app/webrtc/objc/RTCPeerConnectionObserver.h @@ -42,31 +42,31 @@ class RTCPeerConnectionObserver : public PeerConnectionObserver { virtual ~RTCPeerConnectionObserver(); // Triggered when the SignalingState changed. - virtual void OnSignalingChange( - PeerConnectionInterface::SignalingState new_state) OVERRIDE; + void OnSignalingChange( + PeerConnectionInterface::SignalingState new_state) override; // Triggered when media is received on a new stream from remote peer. - virtual void OnAddStream(MediaStreamInterface* stream) OVERRIDE; + void OnAddStream(MediaStreamInterface* stream) override; // Triggered when a remote peer close a stream. - virtual void OnRemoveStream(MediaStreamInterface* stream) OVERRIDE; + void OnRemoveStream(MediaStreamInterface* stream) override; // Triggered when a remote peer open a data channel. - virtual void OnDataChannel(DataChannelInterface* data_channel) OVERRIDE; + void OnDataChannel(DataChannelInterface* data_channel) override; // Triggered when renegotiation is needed, for example the ICE has restarted. - virtual void OnRenegotiationNeeded() OVERRIDE; + void OnRenegotiationNeeded() override; // Called any time the ICEConnectionState changes - virtual void OnIceConnectionChange( - PeerConnectionInterface::IceConnectionState new_state) OVERRIDE; + void OnIceConnectionChange( + PeerConnectionInterface::IceConnectionState new_state) override; // Called any time the ICEGatheringState changes - virtual void OnIceGatheringChange( - PeerConnectionInterface::IceGatheringState new_state) OVERRIDE; + void OnIceGatheringChange( + PeerConnectionInterface::IceGatheringState new_state) override; // New Ice candidate have been found. - virtual void OnIceCandidate(const IceCandidateInterface* candidate) OVERRIDE; + void OnIceCandidate(const IceCandidateInterface* candidate) override; private: __weak RTCPeerConnection* _peerConnection; diff --git a/talk/app/webrtc/objc/RTCVideoRendererAdapter.mm b/talk/app/webrtc/objc/RTCVideoRendererAdapter.mm index 018808832..99cb12822 100644 --- a/talk/app/webrtc/objc/RTCVideoRendererAdapter.mm +++ b/talk/app/webrtc/objc/RTCVideoRendererAdapter.mm @@ -40,11 +40,11 @@ class RTCVideoRendererNativeAdapter : public VideoRendererInterface { _adapter = adapter; } - virtual void SetSize(int width, int height) OVERRIDE { + void SetSize(int width, int height) override { [_adapter.videoRenderer setSize:CGSizeMake(width, height)]; } - virtual void RenderFrame(const cricket::VideoFrame* frame) OVERRIDE { + void RenderFrame(const cricket::VideoFrame* frame) override { RTCI420Frame* i420Frame = [[RTCI420Frame alloc] initWithVideoFrame:frame]; [_adapter.videoRenderer renderFrame:i420Frame]; } diff --git a/talk/app/webrtc/peerconnection.h b/talk/app/webrtc/peerconnection.h index 9b4c2b716..bea9c2f61 100644 --- a/talk/app/webrtc/peerconnection.h +++ b/talk/app/webrtc/peerconnection.h @@ -118,34 +118,30 @@ class PeerConnection : public PeerConnectionInterface, virtual void OnMessage(rtc::Message* msg); // Implements MediaStreamSignalingObserver. - virtual void OnAddRemoteStream(MediaStreamInterface* stream) OVERRIDE; - virtual void OnRemoveRemoteStream(MediaStreamInterface* stream) OVERRIDE; - virtual void OnAddDataChannel(DataChannelInterface* data_channel) OVERRIDE; - virtual void OnAddRemoteAudioTrack(MediaStreamInterface* stream, - AudioTrackInterface* audio_track, - uint32 ssrc) OVERRIDE; - virtual void OnAddRemoteVideoTrack(MediaStreamInterface* stream, - VideoTrackInterface* video_track, - uint32 ssrc) OVERRIDE; - virtual void OnRemoveRemoteAudioTrack( - MediaStreamInterface* stream, - AudioTrackInterface* audio_track) OVERRIDE; - virtual void OnRemoveRemoteVideoTrack( - MediaStreamInterface* stream, - VideoTrackInterface* video_track) OVERRIDE; - virtual void OnAddLocalAudioTrack(MediaStreamInterface* stream, - AudioTrackInterface* audio_track, - uint32 ssrc) OVERRIDE; - virtual void OnAddLocalVideoTrack(MediaStreamInterface* stream, - VideoTrackInterface* video_track, - uint32 ssrc) OVERRIDE; - virtual void OnRemoveLocalAudioTrack( - MediaStreamInterface* stream, - AudioTrackInterface* audio_track, - uint32 ssrc) OVERRIDE; - virtual void OnRemoveLocalVideoTrack( - MediaStreamInterface* stream, - VideoTrackInterface* video_track) OVERRIDE; + void OnAddRemoteStream(MediaStreamInterface* stream) override; + void OnRemoveRemoteStream(MediaStreamInterface* stream) override; + void OnAddDataChannel(DataChannelInterface* data_channel) override; + void OnAddRemoteAudioTrack(MediaStreamInterface* stream, + AudioTrackInterface* audio_track, + uint32 ssrc) override; + void OnAddRemoteVideoTrack(MediaStreamInterface* stream, + VideoTrackInterface* video_track, + uint32 ssrc) override; + void OnRemoveRemoteAudioTrack(MediaStreamInterface* stream, + AudioTrackInterface* audio_track) override; + void OnRemoveRemoteVideoTrack(MediaStreamInterface* stream, + VideoTrackInterface* video_track) override; + void OnAddLocalAudioTrack(MediaStreamInterface* stream, + AudioTrackInterface* audio_track, + uint32 ssrc) override; + void OnAddLocalVideoTrack(MediaStreamInterface* stream, + VideoTrackInterface* video_track, + uint32 ssrc) override; + void OnRemoveLocalAudioTrack(MediaStreamInterface* stream, + AudioTrackInterface* audio_track, + uint32 ssrc) override; + void OnRemoveLocalVideoTrack(MediaStreamInterface* stream, + VideoTrackInterface* video_track) override; virtual void OnRemoveLocalStream(MediaStreamInterface* stream); // Implements IceObserver diff --git a/talk/app/webrtc/proxy.h b/talk/app/webrtc/proxy.h index 78245fc4d..76a5c1eff 100644 --- a/talk/app/webrtc/proxy.h +++ b/talk/app/webrtc/proxy.h @@ -312,72 +312,70 @@ class MethodCall5 : public rtc::Message, T5 a5_; }; -#define BEGIN_PROXY_MAP(c) \ - class c##Proxy : public c##Interface {\ - protected:\ - typedef c##Interface C;\ - c##Proxy(rtc::Thread* thread, C* c)\ - : owner_thread_(thread), \ - c_(c) {}\ - ~c##Proxy() {\ - MethodCall0 call(this, &c##Proxy::Release_s);\ - call.Marshal(owner_thread_);\ - }\ - public:\ - static rtc::scoped_refptr Create(rtc::Thread* thread, \ - C* c) {\ - return new rtc::RefCountedObject(thread, c);\ - }\ +#define BEGIN_PROXY_MAP(c) \ + class c##Proxy : public c##Interface { \ + protected: \ + typedef c##Interface C; \ + c##Proxy(rtc::Thread* thread, C* c) : owner_thread_(thread), c_(c) {} \ + ~c##Proxy() { \ + MethodCall0 call(this, &c##Proxy::Release_s); \ + call.Marshal(owner_thread_); \ + } \ + \ + public: \ + static rtc::scoped_refptr Create(rtc::Thread* thread, C* c) { \ + return new rtc::RefCountedObject(thread, c); \ + } -#define PROXY_METHOD0(r, method)\ - r method() OVERRIDE {\ - MethodCall0 call(c_.get(), &C::method);\ - return call.Marshal(owner_thread_);\ - }\ +#define PROXY_METHOD0(r, method) \ + r method() override { \ + MethodCall0 call(c_.get(), &C::method); \ + return call.Marshal(owner_thread_); \ + } -#define PROXY_CONSTMETHOD0(r, method)\ - r method() const OVERRIDE {\ - ConstMethodCall0 call(c_.get(), &C::method);\ - return call.Marshal(owner_thread_);\ - }\ +#define PROXY_CONSTMETHOD0(r, method) \ + r method() const override { \ + ConstMethodCall0 call(c_.get(), &C::method); \ + return call.Marshal(owner_thread_); \ + } -#define PROXY_METHOD1(r, method, t1)\ - r method(t1 a1) OVERRIDE {\ - MethodCall1 call(c_.get(), &C::method, a1);\ - return call.Marshal(owner_thread_);\ - }\ +#define PROXY_METHOD1(r, method, t1) \ + r method(t1 a1) override { \ + MethodCall1 call(c_.get(), &C::method, a1); \ + return call.Marshal(owner_thread_); \ + } -#define PROXY_CONSTMETHOD1(r, method, t1)\ - r method(t1 a1) const OVERRIDE {\ - ConstMethodCall1 call(c_.get(), &C::method, a1);\ - return call.Marshal(owner_thread_);\ - }\ +#define PROXY_CONSTMETHOD1(r, method, t1) \ + r method(t1 a1) const override { \ + ConstMethodCall1 call(c_.get(), &C::method, a1); \ + return call.Marshal(owner_thread_); \ + } -#define PROXY_METHOD2(r, method, t1, t2)\ - r method(t1 a1, t2 a2) OVERRIDE {\ - MethodCall2 call(c_.get(), &C::method, a1, a2);\ - return call.Marshal(owner_thread_);\ - }\ +#define PROXY_METHOD2(r, method, t1, t2) \ + r method(t1 a1, t2 a2) override { \ + MethodCall2 call(c_.get(), &C::method, a1, a2); \ + return call.Marshal(owner_thread_); \ + } -#define PROXY_METHOD3(r, method, t1, t2, t3)\ - r method(t1 a1, t2 a2, t3 a3) OVERRIDE {\ - MethodCall3 call(c_.get(), &C::method, a1, a2, a3);\ - return call.Marshal(owner_thread_);\ - }\ +#define PROXY_METHOD3(r, method, t1, t2, t3) \ + r method(t1 a1, t2 a2, t3 a3) override { \ + MethodCall3 call(c_.get(), &C::method, a1, a2, a3); \ + return call.Marshal(owner_thread_); \ + } -#define PROXY_METHOD4(r, method, t1, t2, t3, t4)\ - r method(t1 a1, t2 a2, t3 a3, t4 a4) OVERRIDE {\ - MethodCall4 call(\ - c_.get(), &C::method, a1, a2, a3, a4);\ - return call.Marshal(owner_thread_);\ - }\ +#define PROXY_METHOD4(r, method, t1, t2, t3, t4) \ + r method(t1 a1, t2 a2, t3 a3, t4 a4) override { \ + MethodCall4 call(c_.get(), &C::method, a1, a2, a3, \ + a4); \ + return call.Marshal(owner_thread_); \ + } -#define PROXY_METHOD5(r, method, t1, t2, t3, t4, t5)\ - r method(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) OVERRIDE {\ - MethodCall5 call(\ - c_.get(), &C::method, a1, a2, a3, a4, a5);\ - return call.Marshal(owner_thread_);\ - }\ +#define PROXY_METHOD5(r, method, t1, t2, t3, t4, t5) \ + r method(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) override { \ + MethodCall5 call(c_.get(), &C::method, a1, a2, \ + a3, a4, a5); \ + return call.Marshal(owner_thread_); \ + } #define END_PROXY() \ private:\ diff --git a/talk/app/webrtc/remoteaudiosource.h b/talk/app/webrtc/remoteaudiosource.h index b05ed3d6a..e49aca568 100644 --- a/talk/app/webrtc/remoteaudiosource.h +++ b/talk/app/webrtc/remoteaudiosource.h @@ -51,12 +51,12 @@ class RemoteAudioSource : public Notifier { typedef std::list AudioObserverList; // MediaSourceInterface implementation. - virtual MediaSourceInterface::SourceState state() const OVERRIDE; + MediaSourceInterface::SourceState state() const override; // AudioSourceInterface implementation. - virtual void SetVolume(double volume) OVERRIDE; - virtual void RegisterAudioObserver(AudioObserver* observer) OVERRIDE; - virtual void UnregisterAudioObserver(AudioObserver* observer) OVERRIDE; + void SetVolume(double volume) override; + void RegisterAudioObserver(AudioObserver* observer) override; + void UnregisterAudioObserver(AudioObserver* observer) override; AudioObserverList audio_observers_; }; diff --git a/talk/app/webrtc/remotevideocapturer.h b/talk/app/webrtc/remotevideocapturer.h index b11d91df7..1bb4d07bd 100644 --- a/talk/app/webrtc/remotevideocapturer.h +++ b/talk/app/webrtc/remotevideocapturer.h @@ -47,14 +47,14 @@ class RemoteVideoCapturer : public cricket::VideoCapturer { virtual ~RemoteVideoCapturer(); // cricket::VideoCapturer implementation. - virtual cricket::CaptureState Start( - const cricket::VideoFormat& capture_format) OVERRIDE; - virtual void Stop() OVERRIDE; - virtual bool IsRunning() OVERRIDE; - virtual bool GetPreferredFourccs(std::vector* fourccs) OVERRIDE; - virtual bool GetBestCaptureFormat(const cricket::VideoFormat& desired, - cricket::VideoFormat* best_format) OVERRIDE; - virtual bool IsScreencast() const OVERRIDE; + cricket::CaptureState Start( + const cricket::VideoFormat& capture_format) override; + void Stop() override; + bool IsRunning() override; + bool GetPreferredFourccs(std::vector* fourccs) override; + bool GetBestCaptureFormat(const cricket::VideoFormat& desired, + cricket::VideoFormat* best_format) override; + bool IsScreencast() const override; private: DISALLOW_COPY_AND_ASSIGN(RemoteVideoCapturer); diff --git a/talk/app/webrtc/statscollector_unittest.cc b/talk/app/webrtc/statscollector_unittest.cc index 373c127a2..e7a9664d5 100644 --- a/talk/app/webrtc/statscollector_unittest.cc +++ b/talk/app/webrtc/statscollector_unittest.cc @@ -113,8 +113,7 @@ class FakeAudioProcessor : public webrtc::AudioProcessorInterface { ~FakeAudioProcessor() {} private: - virtual void GetStats( - AudioProcessorInterface::AudioProcessorStats* stats) OVERRIDE { + void GetStats(AudioProcessorInterface::AudioProcessorStats* stats) override { stats->typing_noise_detected = true; stats->echo_return_loss = 2; stats->echo_return_loss_enhancement = 3; @@ -130,20 +129,16 @@ class FakeAudioTrack explicit FakeAudioTrack(const std::string& id) : webrtc::MediaStreamTrack(id), processor_(new rtc::RefCountedObject()) {} - std::string kind() const OVERRIDE { - return "audio"; - } - virtual webrtc::AudioSourceInterface* GetSource() const OVERRIDE { - return NULL; - } - virtual void AddSink(webrtc::AudioTrackSinkInterface* sink) OVERRIDE {} - virtual void RemoveSink(webrtc::AudioTrackSinkInterface* sink) OVERRIDE {} - virtual bool GetSignalLevel(int* level) OVERRIDE { + std::string kind() const override { return "audio"; } + webrtc::AudioSourceInterface* GetSource() const override { return NULL; } + void AddSink(webrtc::AudioTrackSinkInterface* sink) override {} + void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {} + bool GetSignalLevel(int* level) override { *level = 1; return true; } - virtual rtc::scoped_refptr - GetAudioProcessor() OVERRIDE { + rtc::scoped_refptr GetAudioProcessor() + override { return processor_; } diff --git a/talk/app/webrtc/test/fakeaudiocapturemodule.h b/talk/app/webrtc/test/fakeaudiocapturemodule.h index 1c54a0431..57c1e58aa 100644 --- a/talk/app/webrtc/test/fakeaudiocapturemodule.h +++ b/talk/app/webrtc/test/fakeaudiocapturemodule.h @@ -76,133 +76,129 @@ class FakeAudioCaptureModule // Only functions called by PeerConnection are implemented, the rest do // nothing and return success. If a function is not expected to be called by // PeerConnection an assertion is triggered if it is in fact called. - virtual int64_t TimeUntilNextProcess() OVERRIDE; - virtual int32_t Process() OVERRIDE; + int64_t TimeUntilNextProcess() override; + int32_t Process() override; - virtual int32_t ActiveAudioLayer(AudioLayer* audio_layer) const OVERRIDE; + int32_t ActiveAudioLayer(AudioLayer* audio_layer) const override; - virtual ErrorCode LastError() const OVERRIDE; - virtual int32_t RegisterEventObserver( - webrtc::AudioDeviceObserver* event_callback) OVERRIDE; + ErrorCode LastError() const override; + int32_t RegisterEventObserver( + webrtc::AudioDeviceObserver* event_callback) override; // Note: Calling this method from a callback may result in deadlock. - virtual int32_t RegisterAudioCallback( - webrtc::AudioTransport* audio_callback) OVERRIDE; + int32_t RegisterAudioCallback( + webrtc::AudioTransport* audio_callback) override; - virtual int32_t Init() OVERRIDE; - virtual int32_t Terminate() OVERRIDE; - virtual bool Initialized() const OVERRIDE; + int32_t Init() override; + int32_t Terminate() override; + bool Initialized() const override; - virtual int16_t PlayoutDevices() OVERRIDE; - virtual int16_t RecordingDevices() OVERRIDE; - virtual int32_t PlayoutDeviceName( - uint16_t index, - char name[webrtc::kAdmMaxDeviceNameSize], - char guid[webrtc::kAdmMaxGuidSize]) OVERRIDE; - virtual int32_t RecordingDeviceName( - uint16_t index, - char name[webrtc::kAdmMaxDeviceNameSize], - char guid[webrtc::kAdmMaxGuidSize]) OVERRIDE; + int16_t PlayoutDevices() override; + int16_t RecordingDevices() override; + int32_t PlayoutDeviceName(uint16_t index, + char name[webrtc::kAdmMaxDeviceNameSize], + char guid[webrtc::kAdmMaxGuidSize]) override; + int32_t RecordingDeviceName(uint16_t index, + char name[webrtc::kAdmMaxDeviceNameSize], + char guid[webrtc::kAdmMaxGuidSize]) override; - virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE; - virtual int32_t SetPlayoutDevice(WindowsDeviceType device) OVERRIDE; - virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE; - virtual int32_t SetRecordingDevice(WindowsDeviceType device) OVERRIDE; + int32_t SetPlayoutDevice(uint16_t index) override; + int32_t SetPlayoutDevice(WindowsDeviceType device) override; + int32_t SetRecordingDevice(uint16_t index) override; + int32_t SetRecordingDevice(WindowsDeviceType device) override; - virtual int32_t PlayoutIsAvailable(bool* available) OVERRIDE; - virtual int32_t InitPlayout() OVERRIDE; - virtual bool PlayoutIsInitialized() const OVERRIDE; - virtual int32_t RecordingIsAvailable(bool* available) OVERRIDE; - virtual int32_t InitRecording() OVERRIDE; - virtual bool RecordingIsInitialized() const OVERRIDE; + int32_t PlayoutIsAvailable(bool* available) override; + int32_t InitPlayout() override; + bool PlayoutIsInitialized() const override; + int32_t RecordingIsAvailable(bool* available) override; + int32_t InitRecording() override; + bool RecordingIsInitialized() const override; - virtual int32_t StartPlayout() OVERRIDE; - virtual int32_t StopPlayout() OVERRIDE; - virtual bool Playing() const OVERRIDE; - virtual int32_t StartRecording() OVERRIDE; - virtual int32_t StopRecording() OVERRIDE; - virtual bool Recording() const OVERRIDE; + int32_t StartPlayout() override; + int32_t StopPlayout() override; + bool Playing() const override; + int32_t StartRecording() override; + int32_t StopRecording() override; + bool Recording() const override; - virtual int32_t SetAGC(bool enable) OVERRIDE; - virtual bool AGC() const OVERRIDE; + int32_t SetAGC(bool enable) override; + bool AGC() const override; - virtual int32_t SetWaveOutVolume(uint16_t volume_left, - uint16_t volume_right) OVERRIDE; - virtual int32_t WaveOutVolume(uint16_t* volume_left, - uint16_t* volume_right) const OVERRIDE; + int32_t SetWaveOutVolume(uint16_t volume_left, + uint16_t volume_right) override; + int32_t WaveOutVolume(uint16_t* volume_left, + uint16_t* volume_right) const override; - virtual int32_t InitSpeaker() OVERRIDE; - virtual bool SpeakerIsInitialized() const OVERRIDE; - virtual int32_t InitMicrophone() OVERRIDE; - virtual bool MicrophoneIsInitialized() const OVERRIDE; + int32_t InitSpeaker() override; + bool SpeakerIsInitialized() const override; + int32_t InitMicrophone() override; + bool MicrophoneIsInitialized() const override; - virtual int32_t SpeakerVolumeIsAvailable(bool* available) OVERRIDE; - virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE; - virtual int32_t SpeakerVolume(uint32_t* volume) const OVERRIDE; - virtual int32_t MaxSpeakerVolume(uint32_t* max_volume) const OVERRIDE; - virtual int32_t MinSpeakerVolume(uint32_t* min_volume) const OVERRIDE; - virtual int32_t SpeakerVolumeStepSize(uint16_t* step_size) const OVERRIDE; + int32_t SpeakerVolumeIsAvailable(bool* available) override; + int32_t SetSpeakerVolume(uint32_t volume) override; + int32_t SpeakerVolume(uint32_t* volume) const override; + int32_t MaxSpeakerVolume(uint32_t* max_volume) const override; + int32_t MinSpeakerVolume(uint32_t* min_volume) const override; + int32_t SpeakerVolumeStepSize(uint16_t* step_size) const override; - virtual int32_t MicrophoneVolumeIsAvailable(bool* available) OVERRIDE; - virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE; - virtual int32_t MicrophoneVolume(uint32_t* volume) const OVERRIDE; - virtual int32_t MaxMicrophoneVolume(uint32_t* max_volume) const OVERRIDE; + int32_t MicrophoneVolumeIsAvailable(bool* available) override; + int32_t SetMicrophoneVolume(uint32_t volume) override; + int32_t MicrophoneVolume(uint32_t* volume) const override; + int32_t MaxMicrophoneVolume(uint32_t* max_volume) const override; - virtual int32_t MinMicrophoneVolume(uint32_t* min_volume) const OVERRIDE; - virtual int32_t MicrophoneVolumeStepSize(uint16_t* step_size) const OVERRIDE; + int32_t MinMicrophoneVolume(uint32_t* min_volume) const override; + int32_t MicrophoneVolumeStepSize(uint16_t* step_size) const override; - virtual int32_t SpeakerMuteIsAvailable(bool* available) OVERRIDE; - virtual int32_t SetSpeakerMute(bool enable) OVERRIDE; - virtual int32_t SpeakerMute(bool* enabled) const OVERRIDE; + int32_t SpeakerMuteIsAvailable(bool* available) override; + int32_t SetSpeakerMute(bool enable) override; + int32_t SpeakerMute(bool* enabled) const override; - virtual int32_t MicrophoneMuteIsAvailable(bool* available) OVERRIDE; - virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE; - virtual int32_t MicrophoneMute(bool* enabled) const OVERRIDE; + int32_t MicrophoneMuteIsAvailable(bool* available) override; + int32_t SetMicrophoneMute(bool enable) override; + int32_t MicrophoneMute(bool* enabled) const override; - virtual int32_t MicrophoneBoostIsAvailable(bool* available) OVERRIDE; - virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE; - virtual int32_t MicrophoneBoost(bool* enabled) const OVERRIDE; + int32_t MicrophoneBoostIsAvailable(bool* available) override; + int32_t SetMicrophoneBoost(bool enable) override; + int32_t MicrophoneBoost(bool* enabled) const override; - virtual int32_t StereoPlayoutIsAvailable(bool* available) const OVERRIDE; - virtual int32_t SetStereoPlayout(bool enable) OVERRIDE; - virtual int32_t StereoPlayout(bool* enabled) const OVERRIDE; - virtual int32_t StereoRecordingIsAvailable(bool* available) const OVERRIDE; - virtual int32_t SetStereoRecording(bool enable) OVERRIDE; - virtual int32_t StereoRecording(bool* enabled) const OVERRIDE; - virtual int32_t SetRecordingChannel(const ChannelType channel) OVERRIDE; - virtual int32_t RecordingChannel(ChannelType* channel) const OVERRIDE; + int32_t StereoPlayoutIsAvailable(bool* available) const override; + int32_t SetStereoPlayout(bool enable) override; + int32_t StereoPlayout(bool* enabled) const override; + int32_t StereoRecordingIsAvailable(bool* available) const override; + int32_t SetStereoRecording(bool enable) override; + int32_t StereoRecording(bool* enabled) const override; + int32_t SetRecordingChannel(const ChannelType channel) override; + int32_t RecordingChannel(ChannelType* channel) const override; - virtual int32_t SetPlayoutBuffer(const BufferType type, - uint16_t size_ms = 0) OVERRIDE; - virtual int32_t PlayoutBuffer(BufferType* type, - uint16_t* size_ms) const OVERRIDE; - virtual int32_t PlayoutDelay(uint16_t* delay_ms) const OVERRIDE; - virtual int32_t RecordingDelay(uint16_t* delay_ms) const OVERRIDE; + int32_t SetPlayoutBuffer(const BufferType type, + uint16_t size_ms = 0) override; + int32_t PlayoutBuffer(BufferType* type, uint16_t* size_ms) const override; + int32_t PlayoutDelay(uint16_t* delay_ms) const override; + int32_t RecordingDelay(uint16_t* delay_ms) const override; - virtual int32_t CPULoad(uint16_t* load) const OVERRIDE; + int32_t CPULoad(uint16_t* load) const override; - virtual int32_t StartRawOutputFileRecording( - const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]) OVERRIDE; - virtual int32_t StopRawOutputFileRecording() OVERRIDE; - virtual int32_t StartRawInputFileRecording( - const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]) OVERRIDE; - virtual int32_t StopRawInputFileRecording() OVERRIDE; + int32_t StartRawOutputFileRecording( + const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]) override; + int32_t StopRawOutputFileRecording() override; + int32_t StartRawInputFileRecording( + const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]) override; + int32_t StopRawInputFileRecording() override; - virtual int32_t SetRecordingSampleRate( - const uint32_t samples_per_sec) OVERRIDE; - virtual int32_t RecordingSampleRate(uint32_t* samples_per_sec) const OVERRIDE; - virtual int32_t SetPlayoutSampleRate(const uint32_t samples_per_sec) OVERRIDE; - virtual int32_t PlayoutSampleRate(uint32_t* samples_per_sec) const OVERRIDE; + int32_t SetRecordingSampleRate(const uint32_t samples_per_sec) override; + int32_t RecordingSampleRate(uint32_t* samples_per_sec) const override; + int32_t SetPlayoutSampleRate(const uint32_t samples_per_sec) override; + int32_t PlayoutSampleRate(uint32_t* samples_per_sec) const override; - virtual int32_t ResetAudioDevice() OVERRIDE; - virtual int32_t SetLoudspeakerStatus(bool enable) OVERRIDE; - virtual int32_t GetLoudspeakerStatus(bool* enabled) const OVERRIDE; + int32_t ResetAudioDevice() override; + int32_t SetLoudspeakerStatus(bool enable) override; + int32_t GetLoudspeakerStatus(bool* enabled) const override; virtual bool BuiltInAECIsAvailable() const { return false; } virtual int32_t EnableBuiltInAEC(bool enable) { return -1; } // End of functions inherited from webrtc::AudioDeviceModule. // The following function is inherited from rtc::MessageHandler. - virtual void OnMessage(rtc::Message* msg) OVERRIDE; + void OnMessage(rtc::Message* msg) override; protected: // The constructor is protected because the class needs to be created as a diff --git a/talk/app/webrtc/test/fakedatachannelprovider.h b/talk/app/webrtc/test/fakedatachannelprovider.h index 75de524f4..41d673752 100644 --- a/talk/app/webrtc/test/fakedatachannelprovider.h +++ b/talk/app/webrtc/test/fakedatachannelprovider.h @@ -36,9 +36,9 @@ class FakeDataChannelProvider : public webrtc::DataChannelProviderInterface { transport_error_(false) {} virtual ~FakeDataChannelProvider() {} - virtual bool SendData(const cricket::SendDataParams& params, - const rtc::Buffer& payload, - cricket::SendDataResult* result) OVERRIDE { + bool SendData(const cricket::SendDataParams& params, + const rtc::Buffer& payload, + cricket::SendDataResult* result) override { ASSERT(ready_to_send_ && transport_available_); if (send_blocked_) { *result = cricket::SDR_BLOCK; @@ -54,7 +54,7 @@ class FakeDataChannelProvider : public webrtc::DataChannelProviderInterface { return true; } - virtual bool ConnectDataChannel(webrtc::DataChannel* data_channel) OVERRIDE { + bool ConnectDataChannel(webrtc::DataChannel* data_channel) override { ASSERT(connected_channels_.find(data_channel) == connected_channels_.end()); if (!transport_available_) { return false; @@ -64,14 +64,13 @@ class FakeDataChannelProvider : public webrtc::DataChannelProviderInterface { return true; } - virtual void DisconnectDataChannel( - webrtc::DataChannel* data_channel) OVERRIDE { + void DisconnectDataChannel(webrtc::DataChannel* data_channel) override { ASSERT(connected_channels_.find(data_channel) != connected_channels_.end()); LOG(LS_INFO) << "DataChannel disconnected " << data_channel; connected_channels_.erase(data_channel); } - virtual void AddSctpDataStream(int sid) OVERRIDE { + void AddSctpDataStream(int sid) override { ASSERT(sid >= 0); if (!transport_available_) { return; @@ -80,15 +79,13 @@ class FakeDataChannelProvider : public webrtc::DataChannelProviderInterface { recv_ssrcs_.insert(sid); } - virtual void RemoveSctpDataStream(int sid) OVERRIDE { + void RemoveSctpDataStream(int sid) override { ASSERT(sid >= 0); send_ssrcs_.erase(sid); recv_ssrcs_.erase(sid); } - virtual bool ReadyToSendData() const OVERRIDE { - return ready_to_send_; - } + bool ReadyToSendData() const override { return ready_to_send_; } // Set true to emulate the SCTP stream being blocked by congestion control. void set_send_blocked(bool blocked) { diff --git a/talk/app/webrtc/videosource.cc b/talk/app/webrtc/videosource.cc index 2935c095b..d6e92b0f3 100644 --- a/talk/app/webrtc/videosource.cc +++ b/talk/app/webrtc/videosource.cc @@ -305,11 +305,9 @@ class FrameInputWrapper : public cricket::VideoRenderer { virtual ~FrameInputWrapper() {} // VideoRenderer implementation. - virtual bool SetSize(int width, int height, int reserved) OVERRIDE { - return true; - } + bool SetSize(int width, int height, int reserved) override { return true; } - virtual bool RenderFrame(const cricket::VideoFrame* frame) OVERRIDE { + bool RenderFrame(const cricket::VideoFrame* frame) override { if (!capturer_->IsRunning()) { return true; } diff --git a/talk/app/webrtc/webrtcsession.h b/talk/app/webrtc/webrtcsession.h index 4f37340b9..7b4d1f425 100644 --- a/talk/app/webrtc/webrtcsession.h +++ b/talk/app/webrtc/webrtcsession.h @@ -180,21 +180,23 @@ class WebRtcSession : public cricket::BaseSession, // AudioMediaProviderInterface implementation. - virtual void SetAudioPlayout(uint32 ssrc, bool enable, - cricket::AudioRenderer* renderer) OVERRIDE; - virtual void SetAudioSend(uint32 ssrc, bool enable, - const cricket::AudioOptions& options, - cricket::AudioRenderer* renderer) OVERRIDE; - virtual void SetAudioPlayoutVolume(uint32 ssrc, double volume) OVERRIDE; + void SetAudioPlayout(uint32 ssrc, + bool enable, + cricket::AudioRenderer* renderer) override; + void SetAudioSend(uint32 ssrc, + bool enable, + const cricket::AudioOptions& options, + cricket::AudioRenderer* renderer) override; + void SetAudioPlayoutVolume(uint32 ssrc, double volume) override; // Implements VideoMediaProviderInterface. - virtual bool SetCaptureDevice(uint32 ssrc, - cricket::VideoCapturer* camera) OVERRIDE; - virtual void SetVideoPlayout(uint32 ssrc, - bool enable, - cricket::VideoRenderer* renderer) OVERRIDE; - virtual void SetVideoSend(uint32 ssrc, bool enable, - const cricket::VideoOptions* options) OVERRIDE; + bool SetCaptureDevice(uint32 ssrc, cricket::VideoCapturer* camera) override; + void SetVideoPlayout(uint32 ssrc, + bool enable, + cricket::VideoRenderer* renderer) override; + void SetVideoSend(uint32 ssrc, + bool enable, + const cricket::VideoOptions* options) override; // Implements DtmfProviderInterface. virtual bool CanInsertDtmf(const std::string& track_id); @@ -203,19 +205,19 @@ class WebRtcSession : public cricket::BaseSession, virtual sigslot::signal0<>* GetOnDestroyedSignal(); // Implements DataChannelProviderInterface. - virtual bool SendData(const cricket::SendDataParams& params, - const rtc::Buffer& payload, - cricket::SendDataResult* result) OVERRIDE; - virtual bool ConnectDataChannel(DataChannel* webrtc_data_channel) OVERRIDE; - virtual void DisconnectDataChannel(DataChannel* webrtc_data_channel) OVERRIDE; - virtual void AddSctpDataStream(int sid) OVERRIDE; - virtual void RemoveSctpDataStream(int sid) OVERRIDE; - virtual bool ReadyToSendData() const OVERRIDE; + bool SendData(const cricket::SendDataParams& params, + const rtc::Buffer& payload, + cricket::SendDataResult* result) override; + bool ConnectDataChannel(DataChannel* webrtc_data_channel) override; + void DisconnectDataChannel(DataChannel* webrtc_data_channel) override; + void AddSctpDataStream(int sid) override; + void RemoveSctpDataStream(int sid) override; + bool ReadyToSendData() const override; // Implements DataChannelFactory. rtc::scoped_refptr CreateDataChannel( const std::string& label, - const InternalDataChannelInit* config) OVERRIDE; + const InternalDataChannelInit* config) override; cricket::DataChannelType data_channel_type() const; diff --git a/talk/app/webrtc/webrtcsession_unittest.cc b/talk/app/webrtc/webrtcsession_unittest.cc index f253927e4..b23ba5444 100644 --- a/talk/app/webrtc/webrtcsession_unittest.cc +++ b/talk/app/webrtc/webrtcsession_unittest.cc @@ -154,12 +154,11 @@ class FakeMetricsObserver : public webrtc::MetricsObserverInterface { sizeof(peer_connection_metrics_name_)); } - virtual void IncrementCounter( - webrtc::PeerConnectionMetricsCounter type) OVERRIDE { + void IncrementCounter(webrtc::PeerConnectionMetricsCounter type) override { peer_connection_metrics_counters_[type]++; } - virtual void AddHistogramSample(webrtc::PeerConnectionMetricsName type, - int value) OVERRIDE { + void AddHistogramSample(webrtc::PeerConnectionMetricsName type, + int value) override { ASSERT(peer_connection_metrics_name_[type] == 0); peer_connection_metrics_name_[type] = value; } @@ -168,8 +167,8 @@ class FakeMetricsObserver : public webrtc::MetricsObserverInterface { [webrtc::kPeerConnectionMetricsCounter_Max]; int peer_connection_metrics_name_[webrtc::kPeerConnectionMetricsCounter_Max]; - virtual int AddRef() OVERRIDE { return 1; } - virtual int Release() OVERRIDE { return 1; } + int AddRef() override { return 1; } + int Release() override { return 1; } }; class MockIceObserver : public webrtc::IceObserver { @@ -300,17 +299,15 @@ class FakeAudioRenderer : public cricket::AudioRenderer { sink_->OnClose(); } - virtual void AddChannel(int channel_id) OVERRIDE { + void AddChannel(int channel_id) override { ASSERT(channel_id_ == -1); channel_id_ = channel_id; } - virtual void RemoveChannel(int channel_id) OVERRIDE { + void RemoveChannel(int channel_id) override { ASSERT(channel_id == channel_id_); channel_id_ = -1; } - virtual void SetSink(Sink* sink) OVERRIDE { - sink_ = sink; - } + void SetSink(Sink* sink) override { sink_ = sink; } int channel_id() const { return channel_id_; } cricket::AudioRenderer::Sink* sink() const { return sink_; } diff --git a/talk/media/base/fakemediaengine.h b/talk/media/base/fakemediaengine.h index 626d6ec7e..c7b52c44a 100644 --- a/talk/media/base/fakemediaengine.h +++ b/talk/media/base/fakemediaengine.h @@ -432,14 +432,12 @@ class FakeVoiceMediaChannel : public RtpHelper { renderer_->SetSink(NULL); } } - virtual void OnData(const void* audio_data, - int bits_per_sample, - int sample_rate, - int number_of_channels, - int number_of_frames) OVERRIDE {} - virtual void OnClose() OVERRIDE { - renderer_ = NULL; - } + void OnData(const void* audio_data, + int bits_per_sample, + int sample_rate, + int number_of_channels, + int number_of_frames) override {} + void OnClose() override { renderer_ = NULL; } AudioRenderer* renderer() const { return renderer_; } private: diff --git a/talk/media/webrtc/fakewebrtccommon.h b/talk/media/webrtc/fakewebrtccommon.h index 4e867074e..96fff4224 100644 --- a/talk/media/webrtc/fakewebrtccommon.h +++ b/talk/media/webrtc/fakewebrtccommon.h @@ -33,31 +33,27 @@ namespace cricket { #define WEBRTC_STUB(method, args) \ - virtual int method args OVERRIDE { return 0; } + int method args override { return 0; } #define WEBRTC_STUB_CONST(method, args) \ - virtual int method args const OVERRIDE { return 0; } + int method args const override { return 0; } #define WEBRTC_BOOL_STUB(method, args) \ - virtual bool method args OVERRIDE { return true; } + bool method args override { return true; } #define WEBRTC_BOOL_STUB_CONST(method, args) \ - virtual bool method args const OVERRIDE { return true; } + bool method args const override { return true; } #define WEBRTC_VOID_STUB(method, args) \ - virtual void method args OVERRIDE {} + void method args override {} -#define WEBRTC_FUNC(method, args) \ - virtual int method args OVERRIDE +#define WEBRTC_FUNC(method, args) int method args override -#define WEBRTC_FUNC_CONST(method, args) \ - virtual int method args const OVERRIDE +#define WEBRTC_FUNC_CONST(method, args) int method args const override -#define WEBRTC_BOOL_FUNC(method, args) \ - virtual bool method args OVERRIDE +#define WEBRTC_BOOL_FUNC(method, args) bool method args override -#define WEBRTC_VOID_FUNC(method, args) \ - virtual void method args OVERRIDE +#define WEBRTC_VOID_FUNC(method, args) void method args override #define WEBRTC_CHECK_CHANNEL(channel) \ if (channels_.find(channel) == channels_.end()) return -1; diff --git a/talk/media/webrtc/fakewebrtcvideocapturemodule.h b/talk/media/webrtc/fakewebrtcvideocapturemodule.h index e86b4234b..93406cd55 100644 --- a/talk/media/webrtc/fakewebrtcvideocapturemodule.h +++ b/talk/media/webrtc/fakewebrtcvideocapturemodule.h @@ -46,73 +46,63 @@ class FakeWebRtcVideoCaptureModule : public webrtc::VideoCaptureModule { running_(false), delay_(0) { } - virtual int64_t TimeUntilNextProcess() OVERRIDE { - return 0; - } - virtual int32_t Process() OVERRIDE { - return 0; - } - virtual void RegisterCaptureDataCallback( - webrtc::VideoCaptureDataCallback& callback) OVERRIDE { + int64_t TimeUntilNextProcess() override { return 0; } + int32_t Process() override { return 0; } + void RegisterCaptureDataCallback( + webrtc::VideoCaptureDataCallback& callback) override { callback_ = &callback; } - virtual void DeRegisterCaptureDataCallback() OVERRIDE { callback_ = NULL; } - virtual void RegisterCaptureCallback( - webrtc::VideoCaptureFeedBack& callback) OVERRIDE { + void DeRegisterCaptureDataCallback() override { callback_ = NULL; } + void RegisterCaptureCallback( + webrtc::VideoCaptureFeedBack& callback) override { // Not implemented. } - virtual void DeRegisterCaptureCallback() OVERRIDE { + void DeRegisterCaptureCallback() override { // Not implemented. } - virtual void SetCaptureDelay(int32_t delay) OVERRIDE { delay_ = delay; } - virtual int32_t CaptureDelay() OVERRIDE { return delay_; } - virtual void EnableFrameRateCallback(const bool enable) OVERRIDE { + void SetCaptureDelay(int32_t delay) override { delay_ = delay; } + int32_t CaptureDelay() override { return delay_; } + void EnableFrameRateCallback(const bool enable) override { // not implemented } - virtual void EnableNoPictureAlarm(const bool enable) OVERRIDE { + void EnableNoPictureAlarm(const bool enable) override { // not implemented } - virtual int32_t StartCapture( - const webrtc::VideoCaptureCapability& cap) OVERRIDE { + int32_t StartCapture(const webrtc::VideoCaptureCapability& cap) override { if (running_) return -1; cap_ = cap; running_ = true; return 0; } - virtual int32_t StopCapture() OVERRIDE { + int32_t StopCapture() override { running_ = false; return 0; } - virtual const char* CurrentDeviceName() const OVERRIDE { + const char* CurrentDeviceName() const override { return NULL; // not implemented } - virtual bool CaptureStarted() OVERRIDE { - return running_; - } - virtual int32_t CaptureSettings( - webrtc::VideoCaptureCapability& settings) OVERRIDE { + bool CaptureStarted() override { return running_; } + int32_t CaptureSettings(webrtc::VideoCaptureCapability& settings) override { if (!running_) return -1; settings = cap_; return 0; } - virtual int32_t SetCaptureRotation(webrtc::VideoRotation rotation) OVERRIDE { + int32_t SetCaptureRotation(webrtc::VideoRotation rotation) override { return -1; // not implemented } - virtual bool SetApplyRotation(bool enable) OVERRIDE { + bool SetApplyRotation(bool enable) override { return false; // not implemented } - virtual bool GetApplyRotation() OVERRIDE { + bool GetApplyRotation() override { return true; // Rotation compensation is turned on. } - virtual VideoCaptureEncodeInterface* GetEncodeInterface( - const webrtc::VideoCodec& codec) OVERRIDE { + VideoCaptureEncodeInterface* GetEncodeInterface( + const webrtc::VideoCodec& codec) override { return NULL; // not implemented } - virtual int32_t AddRef() OVERRIDE { - return 0; - } - virtual int32_t Release() OVERRIDE { + int32_t AddRef() override { return 0; } + int32_t Release() override { delete this; return 0; } diff --git a/talk/media/webrtc/fakewebrtcvoiceengine.h b/talk/media/webrtc/fakewebrtcvoiceengine.h index 65807fc36..bb529e2c8 100644 --- a/talk/media/webrtc/fakewebrtcvoiceengine.h +++ b/talk/media/webrtc/fakewebrtcvoiceengine.h @@ -145,25 +145,15 @@ class FakeAudioProcessing : public webrtc::AudioProcessing { WEBRTC_STUB(StartDebugRecording, (const char filename[kMaxFilenameSize])); WEBRTC_STUB(StartDebugRecording, (FILE* handle)); WEBRTC_STUB(StopDebugRecording, ()); - virtual webrtc::EchoCancellation* echo_cancellation() const OVERRIDE { - return NULL; - } - virtual webrtc::EchoControlMobile* echo_control_mobile() const OVERRIDE { - return NULL; - } - virtual webrtc::GainControl* gain_control() const OVERRIDE { return NULL; } - virtual webrtc::HighPassFilter* high_pass_filter() const OVERRIDE { - return NULL; - } - virtual webrtc::LevelEstimator* level_estimator() const OVERRIDE { - return NULL; - } - virtual webrtc::NoiseSuppression* noise_suppression() const OVERRIDE { - return NULL; - } - virtual webrtc::VoiceDetection* voice_detection() const OVERRIDE { + webrtc::EchoCancellation* echo_cancellation() const override { return NULL; } + webrtc::EchoControlMobile* echo_control_mobile() const override { return NULL; } + webrtc::GainControl* gain_control() const override { return NULL; } + webrtc::HighPassFilter* high_pass_filter() const override { return NULL; } + webrtc::LevelEstimator* level_estimator() const override { return NULL; } + webrtc::NoiseSuppression* noise_suppression() const override { return NULL; } + webrtc::VoiceDetection* voice_detection() const override { return NULL; } bool experimental_ns_enabled() { return experimental_ns_enabled_; @@ -456,7 +446,7 @@ class FakeWebRtcVoiceEngine inited_ = false; return 0; } - virtual webrtc::AudioProcessing* audio_processing() OVERRIDE { + webrtc::AudioProcessing* audio_processing() override { return &audio_processing_; } WEBRTC_FUNC(CreateChannel, ()) { diff --git a/talk/media/webrtc/webrtcmediaengine.h b/talk/media/webrtc/webrtcmediaengine.h index b4436cd66..044fc0e68 100644 --- a/talk/media/webrtc/webrtcmediaengine.h +++ b/talk/media/webrtc/webrtcmediaengine.h @@ -97,90 +97,83 @@ class DelegatingWebRtcMediaEngine : public cricket::MediaEngineInterface { virtual ~DelegatingWebRtcMediaEngine() { DestroyWebRtcMediaEngine(delegate_); } - virtual bool Init(rtc::Thread* worker_thread) OVERRIDE { + bool Init(rtc::Thread* worker_thread) override { return delegate_->Init(worker_thread); } - virtual void Terminate() OVERRIDE { - delegate_->Terminate(); - } - virtual int GetCapabilities() OVERRIDE { - return delegate_->GetCapabilities(); - } - virtual VoiceMediaChannel* CreateChannel() OVERRIDE { + void Terminate() override { delegate_->Terminate(); } + int GetCapabilities() override { return delegate_->GetCapabilities(); } + VoiceMediaChannel* CreateChannel() override { return delegate_->CreateChannel(); } - virtual VideoMediaChannel* CreateVideoChannel( + VideoMediaChannel* CreateVideoChannel( const VideoOptions& options, - VoiceMediaChannel* voice_media_channel) OVERRIDE { + VoiceMediaChannel* voice_media_channel) override { return delegate_->CreateVideoChannel(options, voice_media_channel); } - virtual SoundclipMedia* CreateSoundclip() OVERRIDE { + SoundclipMedia* CreateSoundclip() override { return delegate_->CreateSoundclip(); } - virtual AudioOptions GetAudioOptions() const OVERRIDE { + AudioOptions GetAudioOptions() const override { return delegate_->GetAudioOptions(); } - virtual bool SetAudioOptions(const AudioOptions& options) OVERRIDE { + bool SetAudioOptions(const AudioOptions& options) override { return delegate_->SetAudioOptions(options); } - virtual bool SetAudioDelayOffset(int offset) OVERRIDE { + bool SetAudioDelayOffset(int offset) override { return delegate_->SetAudioDelayOffset(offset); } - virtual bool SetDefaultVideoEncoderConfig( - const VideoEncoderConfig& config) OVERRIDE { + bool SetDefaultVideoEncoderConfig(const VideoEncoderConfig& config) override { return delegate_->SetDefaultVideoEncoderConfig(config); } - virtual bool SetSoundDevices( - const Device* in_device, const Device* out_device) OVERRIDE { + bool SetSoundDevices(const Device* in_device, + const Device* out_device) override { return delegate_->SetSoundDevices(in_device, out_device); } - virtual bool GetOutputVolume(int* level) OVERRIDE { + bool GetOutputVolume(int* level) override { return delegate_->GetOutputVolume(level); } - virtual bool SetOutputVolume(int level) OVERRIDE { + bool SetOutputVolume(int level) override { return delegate_->SetOutputVolume(level); } - virtual int GetInputLevel() OVERRIDE { - return delegate_->GetInputLevel(); - } - virtual bool SetLocalMonitor(bool enable) OVERRIDE { + int GetInputLevel() override { return delegate_->GetInputLevel(); } + bool SetLocalMonitor(bool enable) override { return delegate_->SetLocalMonitor(enable); } - virtual const std::vector& audio_codecs() OVERRIDE { + const std::vector& audio_codecs() override { return delegate_->audio_codecs(); } - virtual const std::vector& - audio_rtp_header_extensions() OVERRIDE { + const std::vector& audio_rtp_header_extensions() + override { return delegate_->audio_rtp_header_extensions(); } - virtual const std::vector& video_codecs() OVERRIDE { + const std::vector& video_codecs() override { return delegate_->video_codecs(); } - virtual const std::vector& - video_rtp_header_extensions() OVERRIDE { + const std::vector& video_rtp_header_extensions() + override { return delegate_->video_rtp_header_extensions(); } - virtual void SetVoiceLogging(int min_sev, const char* filter) OVERRIDE { + void SetVoiceLogging(int min_sev, const char* filter) override { delegate_->SetVoiceLogging(min_sev, filter); } - virtual void SetVideoLogging(int min_sev, const char* filter) OVERRIDE { + void SetVideoLogging(int min_sev, const char* filter) override { delegate_->SetVideoLogging(min_sev, filter); } - virtual bool StartAecDump(rtc::PlatformFile file) OVERRIDE { + bool StartAecDump(rtc::PlatformFile file) override { return delegate_->StartAecDump(file); } - virtual bool RegisterVoiceProcessor( - uint32 ssrc, VoiceProcessor* video_processor, - MediaProcessorDirection direction) OVERRIDE { + bool RegisterVoiceProcessor(uint32 ssrc, + VoiceProcessor* video_processor, + MediaProcessorDirection direction) override { return delegate_->RegisterVoiceProcessor(ssrc, video_processor, direction); } - virtual bool UnregisterVoiceProcessor( - uint32 ssrc, VoiceProcessor* video_processor, - MediaProcessorDirection direction) OVERRIDE { + bool UnregisterVoiceProcessor(uint32 ssrc, + VoiceProcessor* video_processor, + MediaProcessorDirection direction) override { return delegate_->UnregisterVoiceProcessor(ssrc, video_processor, direction); } - virtual VideoFormat GetStartCaptureFormat() const OVERRIDE { + VideoFormat GetStartCaptureFormat() const override { return delegate_->GetStartCaptureFormat(); } virtual sigslot::repeater2& diff --git a/talk/media/webrtc/webrtcpassthroughrender.h b/talk/media/webrtc/webrtcpassthroughrender.h index e8e1ed635..bbe225b8b 100644 --- a/talk/media/webrtc/webrtcpassthroughrender.h +++ b/talk/media/webrtc/webrtcpassthroughrender.h @@ -41,139 +41,138 @@ class WebRtcPassthroughRender : public webrtc::VideoRender { WebRtcPassthroughRender(); virtual ~WebRtcPassthroughRender(); - virtual int64_t TimeUntilNextProcess() OVERRIDE { return 0; } + int64_t TimeUntilNextProcess() override { return 0; } - virtual int32_t Process() OVERRIDE { return 0; } + int32_t Process() override { return 0; } - virtual void* Window() OVERRIDE { + void* Window() override { rtc::CritScope cs(&render_critical_); return window_; } - virtual int32_t ChangeWindow(void* window) OVERRIDE { + int32_t ChangeWindow(void* window) override { rtc::CritScope cs(&render_critical_); window_ = window; return 0; } - virtual webrtc::VideoRenderCallback* AddIncomingRenderStream( + webrtc::VideoRenderCallback* AddIncomingRenderStream( const uint32_t stream_id, const uint32_t zOrder, - const float left, const float top, - const float right, const float bottom) OVERRIDE; + const float left, + const float top, + const float right, + const float bottom) override; - virtual int32_t DeleteIncomingRenderStream(const uint32_t stream_id) OVERRIDE; + int32_t DeleteIncomingRenderStream(const uint32_t stream_id) override; - virtual int32_t AddExternalRenderCallback( + int32_t AddExternalRenderCallback( const uint32_t stream_id, - webrtc::VideoRenderCallback* render_object) OVERRIDE; + webrtc::VideoRenderCallback* render_object) override; - virtual int32_t GetIncomingRenderStreamProperties( - const uint32_t stream_id, - uint32_t& zOrder, - float& left, float& top, - float& right, float& bottom) const OVERRIDE { + int32_t GetIncomingRenderStreamProperties(const uint32_t stream_id, + uint32_t& zOrder, + float& left, + float& top, + float& right, + float& bottom) const override { return -1; } - virtual uint32_t GetIncomingFrameRate(const uint32_t stream_id) OVERRIDE { - return 0; - } + uint32_t GetIncomingFrameRate(const uint32_t stream_id) override { return 0; } - virtual uint32_t GetNumIncomingRenderStreams() const OVERRIDE { + uint32_t GetNumIncomingRenderStreams() const override { return static_cast(stream_render_map_.size()); } - virtual bool HasIncomingRenderStream(const uint32_t stream_id) const OVERRIDE; + bool HasIncomingRenderStream(const uint32_t stream_id) const override; - virtual int32_t RegisterRawFrameCallback( + int32_t RegisterRawFrameCallback( const uint32_t stream_id, - webrtc::VideoRenderCallback* callback_obj) OVERRIDE { + webrtc::VideoRenderCallback* callback_obj) override { return -1; } - virtual int32_t GetLastRenderedFrame( - const uint32_t stream_id, - webrtc::I420VideoFrame &frame) const OVERRIDE { + int32_t GetLastRenderedFrame(const uint32_t stream_id, + webrtc::I420VideoFrame& frame) const override { return -1; } - virtual int32_t StartRender(const uint32_t stream_id) OVERRIDE; + int32_t StartRender(const uint32_t stream_id) override; - virtual int32_t StopRender(const uint32_t stream_id) OVERRIDE; + int32_t StopRender(const uint32_t stream_id) override; - virtual int32_t ResetRender() OVERRIDE { return 0; } + int32_t ResetRender() override { return 0; } - virtual webrtc::RawVideoType PreferredVideoType() const OVERRIDE; + webrtc::RawVideoType PreferredVideoType() const override; - virtual bool IsFullScreen() OVERRIDE { return false; } + bool IsFullScreen() override { return false; } - virtual int32_t GetScreenResolution(uint32_t& screenWidth, - uint32_t& screenHeight) const OVERRIDE { + int32_t GetScreenResolution(uint32_t& screenWidth, + uint32_t& screenHeight) const override { return -1; } - virtual uint32_t RenderFrameRate(const uint32_t stream_id) OVERRIDE { - return 0; - } + uint32_t RenderFrameRate(const uint32_t stream_id) override { return 0; } - virtual int32_t SetStreamCropping( - const uint32_t stream_id, - const float left, const float top, - const float right, - const float bottom) OVERRIDE { + int32_t SetStreamCropping(const uint32_t stream_id, + const float left, + const float top, + const float right, + const float bottom) override { return -1; } - virtual int32_t SetExpectedRenderDelay(uint32_t stream_id, - int32_t delay_ms) OVERRIDE { + int32_t SetExpectedRenderDelay(uint32_t stream_id, + int32_t delay_ms) override { return -1; } - virtual int32_t ConfigureRenderer( - const uint32_t stream_id, - const unsigned int zOrder, - const float left, const float top, - const float right, - const float bottom) OVERRIDE { + int32_t ConfigureRenderer(const uint32_t stream_id, + const unsigned int zOrder, + const float left, + const float top, + const float right, + const float bottom) override { return -1; } - virtual int32_t SetTransparentBackground(const bool enable) OVERRIDE { + int32_t SetTransparentBackground(const bool enable) override { return -1; } + + int32_t FullScreenRender(void* window, const bool enable) override { return -1; } - virtual int32_t FullScreenRender(void* window, const bool enable) OVERRIDE { + int32_t SetBitmap(const void* bitMap, + const uint8_t pictureId, + const void* colorKey, + const float left, + const float top, + const float right, + const float bottom) override { return -1; } - virtual int32_t SetBitmap(const void* bitMap, - const uint8_t pictureId, const void* colorKey, - const float left, const float top, - const float right, const float bottom) OVERRIDE { + int32_t SetText(const uint8_t textId, + const uint8_t* text, + const int32_t textLength, + const uint32_t textColorRef, + const uint32_t backgroundColorRef, + const float left, + const float top, + const float right, + const float bottom) override { return -1; } - virtual int32_t SetText(const uint8_t textId, - const uint8_t* text, - const int32_t textLength, - const uint32_t textColorRef, - const uint32_t backgroundColorRef, - const float left, const float top, - const float right, const float bottom) OVERRIDE { + int32_t SetStartImage(const uint32_t stream_id, + const webrtc::I420VideoFrame& videoFrame) override { return -1; } - virtual int32_t SetStartImage( - const uint32_t stream_id, - const webrtc::I420VideoFrame& videoFrame) OVERRIDE { - return -1; - } - - virtual int32_t SetTimeoutImage( - const uint32_t stream_id, - const webrtc::I420VideoFrame& videoFrame, - const uint32_t timeout) OVERRIDE { + int32_t SetTimeoutImage(const uint32_t stream_id, + const webrtc::I420VideoFrame& videoFrame, + const uint32_t timeout) override { return -1; } diff --git a/talk/media/webrtc/webrtcvideoengine.cc b/talk/media/webrtc/webrtcvideoengine.cc index d860e487d..075a6929b 100644 --- a/talk/media/webrtc/webrtcvideoengine.cc +++ b/talk/media/webrtc/webrtcvideoengine.cc @@ -127,11 +127,11 @@ class EncoderFactoryAdapter : public webrtc::VideoEncoderFactory { virtual ~EncoderFactoryAdapter() {} // Implement webrtc::VideoEncoderFactory. - virtual webrtc::VideoEncoder* Create() OVERRIDE { + webrtc::VideoEncoder* Create() override { return factory_->CreateVideoEncoder(webrtc::kVideoCodecVP8); } - virtual void Destroy(webrtc::VideoEncoder* encoder) OVERRIDE { + void Destroy(webrtc::VideoEncoder* encoder) override { return factory_->DestroyVideoEncoder(encoder); } @@ -677,7 +677,7 @@ class WebRtcOveruseObserver : public webrtc::CpuOveruseObserver { // TODO(mflodman): Consider sending resolution as part of event, to let // adapter know what resolution the request is based on. Helps eliminate stale // data, race conditions. - virtual void OveruseDetected() OVERRIDE { + void OveruseDetected() override { rtc::CritScope cs(&crit_); if (!enabled_) { return; @@ -686,7 +686,7 @@ class WebRtcOveruseObserver : public webrtc::CpuOveruseObserver { video_adapter_->OnCpuResolutionRequest(CoordinatedVideoAdapter::DOWNGRADE); } - virtual void NormalUsage() OVERRIDE { + void NormalUsage() override { rtc::CritScope cs(&crit_); if (!enabled_) { return; diff --git a/talk/media/webrtc/webrtcvideoengine.h b/talk/media/webrtc/webrtcvideoengine.h index 3c2e379c9..35b34a14a 100644 --- a/talk/media/webrtc/webrtcvideoengine.h +++ b/talk/media/webrtc/webrtcvideoengine.h @@ -266,43 +266,42 @@ class WebRtcVideoMediaChannel : public rtc::MessageHandler, int GetDefaultChannelId() const { return default_channel_id_; } // VideoMediaChannel implementation - virtual bool SetRecvCodecs(const std::vector &codecs) OVERRIDE; - virtual bool SetSendCodecs(const std::vector &codecs) OVERRIDE; - virtual bool GetSendCodec(VideoCodec* send_codec) OVERRIDE; - virtual bool SetSendStreamFormat(uint32 ssrc, - const VideoFormat& format) OVERRIDE; - virtual bool SetRender(bool render) OVERRIDE; - virtual bool SetSend(bool send) OVERRIDE; + bool SetRecvCodecs(const std::vector& codecs) override; + bool SetSendCodecs(const std::vector& codecs) override; + bool GetSendCodec(VideoCodec* send_codec) override; + bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) override; + bool SetRender(bool render) override; + bool SetSend(bool send) override; - virtual bool AddSendStream(const StreamParams& sp) OVERRIDE; - virtual bool RemoveSendStream(uint32 ssrc) OVERRIDE; - virtual bool AddRecvStream(const StreamParams& sp) OVERRIDE; - virtual bool RemoveRecvStream(uint32 ssrc) OVERRIDE; - virtual bool SetRenderer(uint32 ssrc, VideoRenderer* renderer) OVERRIDE; - virtual bool GetStats(VideoMediaInfo* info) OVERRIDE; - virtual bool SetCapturer(uint32 ssrc, VideoCapturer* capturer) OVERRIDE; - virtual bool SendIntraFrame() OVERRIDE; - virtual bool RequestIntraFrame() OVERRIDE; + bool AddSendStream(const StreamParams& sp) override; + bool RemoveSendStream(uint32 ssrc) override; + bool AddRecvStream(const StreamParams& sp) override; + bool RemoveRecvStream(uint32 ssrc) override; + bool SetRenderer(uint32 ssrc, VideoRenderer* renderer) override; + bool GetStats(VideoMediaInfo* info) override; + bool SetCapturer(uint32 ssrc, VideoCapturer* capturer) override; + bool SendIntraFrame() override; + bool RequestIntraFrame() override; - virtual void OnPacketReceived(rtc::Buffer* packet, - const rtc::PacketTime& packet_time) OVERRIDE; - virtual void OnRtcpReceived(rtc::Buffer* packet, - const rtc::PacketTime& packet_time) OVERRIDE; - virtual void OnReadyToSend(bool ready) OVERRIDE; - virtual bool MuteStream(uint32 ssrc, bool on) OVERRIDE; - virtual bool SetRecvRtpHeaderExtensions( - const std::vector& extensions) OVERRIDE; - virtual bool SetSendRtpHeaderExtensions( - const std::vector& extensions) OVERRIDE; - virtual int GetRtpSendTimeExtnId() const OVERRIDE; - virtual bool SetMaxSendBandwidth(int bps) OVERRIDE; - virtual bool SetOptions(const VideoOptions &options) OVERRIDE; - virtual bool GetOptions(VideoOptions *options) const OVERRIDE { + void OnPacketReceived(rtc::Buffer* packet, + const rtc::PacketTime& packet_time) override; + void OnRtcpReceived(rtc::Buffer* packet, + const rtc::PacketTime& packet_time) override; + void OnReadyToSend(bool ready) override; + bool MuteStream(uint32 ssrc, bool on) override; + bool SetRecvRtpHeaderExtensions( + const std::vector& extensions) override; + bool SetSendRtpHeaderExtensions( + const std::vector& extensions) override; + int GetRtpSendTimeExtnId() const override; + bool SetMaxSendBandwidth(int bps) override; + bool SetOptions(const VideoOptions& options) override; + bool GetOptions(VideoOptions* options) const override { *options = options_; return true; } - virtual void SetInterface(NetworkInterface* iface) OVERRIDE; - virtual void UpdateAspectRatio(int ratio_w, int ratio_h) OVERRIDE; + void SetInterface(NetworkInterface* iface) override; + void UpdateAspectRatio(int ratio_w, int ratio_h) override; // Public functions for use by tests and other specialized code. uint32 send_ssrc() const { return 0; } @@ -320,17 +319,15 @@ class WebRtcVideoMediaChannel : public rtc::MessageHandler, } // rtc::MessageHandler: - virtual void OnMessage(rtc::Message* msg) OVERRIDE; + void OnMessage(rtc::Message* msg) override; protected: void Terminate(); int GetLastEngineError() { return engine()->GetLastEngineError(); } // webrtc::Transport: - virtual int SendPacket(int channel, const void* data, size_t len) OVERRIDE; - virtual int SendRTCPPacket(int channel, - const void* data, - size_t len) OVERRIDE; + int SendPacket(int channel, const void* data, size_t len) override; + int SendRTCPPacket(int channel, const void* data, size_t len) override; bool ConferenceModeIsEnabled() const { return options_.conference_mode.GetWithDefaultIfUnset(false); @@ -531,10 +528,10 @@ class WebRtcSimulcastEncoderFactory static bool UseSimulcastEncoderFactory(const std::vector& codecs); - virtual webrtc::VideoEncoder* CreateVideoEncoder( - webrtc::VideoCodecType type) OVERRIDE; - virtual const std::vector& codecs() const OVERRIDE; - virtual void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) OVERRIDE; + webrtc::VideoEncoder* CreateVideoEncoder( + webrtc::VideoCodecType type) override; + const std::vector& codecs() const override; + void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override; private: cricket::WebRtcVideoEncoderFactory* factory_; diff --git a/talk/media/webrtc/webrtcvideoengine2.h b/talk/media/webrtc/webrtcvideoengine2.h index b0da32779..b5d69c68d 100644 --- a/talk/media/webrtc/webrtcvideoengine2.h +++ b/talk/media/webrtc/webrtcvideoengine2.h @@ -89,8 +89,7 @@ class UnsignalledSsrcHandler { class DefaultUnsignalledSsrcHandler : public UnsignalledSsrcHandler { public: DefaultUnsignalledSsrcHandler(); - virtual Action OnUnsignalledSsrc(VideoMediaChannel* engine, - uint32_t ssrc) override; + Action OnUnsignalledSsrc(VideoMediaChannel* engine, uint32_t ssrc) override; VideoRenderer* GetDefaultRenderer() const; void SetDefaultRenderer(VideoMediaChannel* channel, VideoRenderer* renderer); @@ -188,49 +187,48 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler, bool Init(); // VideoMediaChannel implementation - virtual bool SetRecvCodecs(const std::vector& codecs) override; - virtual bool SetSendCodecs(const std::vector& codecs) override; - virtual bool GetSendCodec(VideoCodec* send_codec) override; - virtual bool SetSendStreamFormat(uint32 ssrc, - const VideoFormat& format) override; - virtual bool SetRender(bool render) override; - virtual bool SetSend(bool send) override; + bool SetRecvCodecs(const std::vector& codecs) override; + bool SetSendCodecs(const std::vector& codecs) override; + bool GetSendCodec(VideoCodec* send_codec) override; + bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) override; + bool SetRender(bool render) override; + bool SetSend(bool send) override; - virtual bool AddSendStream(const StreamParams& sp) override; - virtual bool RemoveSendStream(uint32 ssrc) override; - virtual bool AddRecvStream(const StreamParams& sp) override; - virtual bool RemoveRecvStream(uint32 ssrc) override; - virtual bool SetRenderer(uint32 ssrc, VideoRenderer* renderer) override; - virtual bool GetStats(VideoMediaInfo* info) override; - virtual bool SetCapturer(uint32 ssrc, VideoCapturer* capturer) override; - virtual bool SendIntraFrame() override; - virtual bool RequestIntraFrame() override; + bool AddSendStream(const StreamParams& sp) override; + bool RemoveSendStream(uint32 ssrc) override; + bool AddRecvStream(const StreamParams& sp) override; + bool RemoveRecvStream(uint32 ssrc) override; + bool SetRenderer(uint32 ssrc, VideoRenderer* renderer) override; + bool GetStats(VideoMediaInfo* info) override; + bool SetCapturer(uint32 ssrc, VideoCapturer* capturer) override; + bool SendIntraFrame() override; + bool RequestIntraFrame() override; - virtual void OnPacketReceived(rtc::Buffer* packet, - const rtc::PacketTime& packet_time) override; - virtual void OnRtcpReceived(rtc::Buffer* packet, - const rtc::PacketTime& packet_time) override; - virtual void OnReadyToSend(bool ready) override; - virtual bool MuteStream(uint32 ssrc, bool mute) override; + void OnPacketReceived(rtc::Buffer* packet, + const rtc::PacketTime& packet_time) override; + void OnRtcpReceived(rtc::Buffer* packet, + const rtc::PacketTime& packet_time) override; + void OnReadyToSend(bool ready) override; + bool MuteStream(uint32 ssrc, bool mute) override; // Set send/receive RTP header extensions. This must be done before creating // streams as it only has effect on future streams. - virtual bool SetRecvRtpHeaderExtensions( + bool SetRecvRtpHeaderExtensions( const std::vector& extensions) override; - virtual bool SetSendRtpHeaderExtensions( + bool SetSendRtpHeaderExtensions( const std::vector& extensions) override; - virtual bool SetMaxSendBandwidth(int bps) override; - virtual bool SetOptions(const VideoOptions& options) override; - virtual bool GetOptions(VideoOptions* options) const override { + bool SetMaxSendBandwidth(int bps) override; + bool SetOptions(const VideoOptions& options) override; + bool GetOptions(VideoOptions* options) const override { *options = options_; return true; } - virtual void SetInterface(NetworkInterface* iface) override; - virtual void UpdateAspectRatio(int ratio_w, int ratio_h) override; + void SetInterface(NetworkInterface* iface) override; + void UpdateAspectRatio(int ratio_w, int ratio_h) override; - virtual void OnMessage(rtc::Message* msg) override; + void OnMessage(rtc::Message* msg) override; - virtual void OnLoadUpdate(Load load) override; + void OnLoadUpdate(Load load) override; // Implemented for VideoMediaChannelTest. bool sending() const { return sending_; } @@ -396,9 +394,9 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler, void SetRecvCodecs(const std::vector& recv_codecs); void SetRtpExtensions(const std::vector& extensions); - virtual void RenderFrame(const webrtc::I420VideoFrame& frame, - int time_to_render_ms) override; - virtual bool IsTextureSupported() const override; + void RenderFrame(const webrtc::I420VideoFrame& frame, + int time_to_render_ms) override; + bool IsTextureSupported() const override; void SetRenderer(cricket::VideoRenderer* renderer); cricket::VideoRenderer* GetRenderer(); @@ -449,8 +447,8 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler, void Construct(webrtc::Call* call, WebRtcVideoEngine2* engine); void SetDefaultOptions(); - virtual bool SendRtp(const uint8_t* data, size_t len) override; - virtual bool SendRtcp(const uint8_t* data, size_t len) override; + bool SendRtp(const uint8_t* data, size_t len) override; + bool SendRtcp(const uint8_t* data, size_t len) override; void StartAllSendStreams(); void StopAllSendStreams(); diff --git a/talk/media/webrtc/webrtcvideoengine2_unittest.cc b/talk/media/webrtc/webrtcvideoengine2_unittest.cc index 2967ea685..174c3e998 100644 --- a/talk/media/webrtc/webrtcvideoengine2_unittest.cc +++ b/talk/media/webrtc/webrtcvideoengine2_unittest.cc @@ -392,8 +392,7 @@ class WebRtcVideoEngine2Test : public ::testing::Test { FakeCall* GetCall() { return fake_call_; } private: - virtual webrtc::Call* CreateCall( - const webrtc::Call::Config& config) OVERRIDE { + webrtc::Call* CreateCall(const webrtc::Call::Config& config) override { assert(fake_call_ == NULL); fake_call_ = new FakeCall(config); return fake_call_; @@ -799,7 +798,7 @@ class WebRtcVideoChannel2BaseTest protected: typedef VideoMediaChannelTest Base; - virtual cricket::VideoCodec DefaultCodec() OVERRIDE { return kVp8Codec; } + cricket::VideoCodec DefaultCodec() override { return kVp8Codec; } }; #define WEBRTC_BASE_TEST(test) \ @@ -923,7 +922,7 @@ class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test, public WebRtcCallFactory { public: WebRtcVideoChannel2Test() : fake_call_(NULL) {} - virtual void SetUp() OVERRIDE { + void SetUp() override { engine_.SetCallFactory(this); engine_.Init(rtc::Thread::Current()); channel_.reset(engine_.CreateChannel(cricket::VideoOptions(), NULL)); @@ -933,8 +932,7 @@ class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test, } protected: - virtual webrtc::Call* CreateCall( - const webrtc::Call::Config& config) OVERRIDE { + webrtc::Call* CreateCall(const webrtc::Call::Config& config) override { assert(fake_call_ == NULL); fake_call_ = new FakeCall(config); return fake_call_; @@ -2325,7 +2323,7 @@ class WebRtcVideoChannel2SimulcastTest : public WebRtcVideoEngine2SimulcastTest, public: WebRtcVideoChannel2SimulcastTest() : fake_call_(NULL) {} - virtual void SetUp() OVERRIDE { + void SetUp() override { engine_.SetCallFactory(this); engine_.Init(rtc::Thread::Current()); channel_.reset(engine_.CreateChannel(VideoOptions(), NULL)); @@ -2334,8 +2332,7 @@ class WebRtcVideoChannel2SimulcastTest : public WebRtcVideoEngine2SimulcastTest, } protected: - virtual webrtc::Call* CreateCall( - const webrtc::Call::Config& config) OVERRIDE { + webrtc::Call* CreateCall(const webrtc::Call::Config& config) override { assert(fake_call_ == NULL); fake_call_ = new FakeCall(config); return fake_call_; diff --git a/talk/media/webrtc/webrtcvideoengine2_unittest.h b/talk/media/webrtc/webrtcvideoengine2_unittest.h index cf2539b68..1149949e0 100644 --- a/talk/media/webrtc/webrtcvideoengine2_unittest.h +++ b/talk/media/webrtc/webrtcvideoengine2_unittest.h @@ -54,16 +54,16 @@ class FakeVideoSendStream : public webrtc::VideoSendStream, void SetStats(const webrtc::VideoSendStream::Stats& stats); private: - virtual void SwapFrame(webrtc::I420VideoFrame* frame) OVERRIDE; - virtual webrtc::VideoSendStream::Stats GetStats() OVERRIDE; + void SwapFrame(webrtc::I420VideoFrame* frame) override; + webrtc::VideoSendStream::Stats GetStats() override; - virtual bool ReconfigureVideoEncoder( - const webrtc::VideoEncoderConfig& config) OVERRIDE; + bool ReconfigureVideoEncoder( + const webrtc::VideoEncoderConfig& config) override; - virtual webrtc::VideoSendStreamInput* Input() OVERRIDE; + webrtc::VideoSendStreamInput* Input() override; - virtual void Start() OVERRIDE; - virtual void Stop() OVERRIDE; + void Start() override; + void Stop() override; bool sending_; webrtc::VideoSendStream::Config config_; @@ -89,10 +89,10 @@ class FakeVideoReceiveStream : public webrtc::VideoReceiveStream { void SetStats(const webrtc::VideoReceiveStream::Stats& stats); private: - virtual webrtc::VideoReceiveStream::Stats GetStats() const OVERRIDE; + webrtc::VideoReceiveStream::Stats GetStats() const override; - virtual void Start() OVERRIDE; - virtual void Stop() OVERRIDE; + void Start() override; + void Stop() override; webrtc::VideoReceiveStream::Config config_; bool receiving_; @@ -123,25 +123,24 @@ class FakeCall : public webrtc::Call { void SetStats(const webrtc::Call::Stats& stats); private: - virtual webrtc::VideoSendStream* CreateVideoSendStream( + webrtc::VideoSendStream* CreateVideoSendStream( const webrtc::VideoSendStream::Config& config, - const webrtc::VideoEncoderConfig& encoder_config) OVERRIDE; + const webrtc::VideoEncoderConfig& encoder_config) override; - virtual void DestroyVideoSendStream( - webrtc::VideoSendStream* send_stream) OVERRIDE; + void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override; - virtual webrtc::VideoReceiveStream* CreateVideoReceiveStream( - const webrtc::VideoReceiveStream::Config& config) OVERRIDE; + webrtc::VideoReceiveStream* CreateVideoReceiveStream( + const webrtc::VideoReceiveStream::Config& config) override; - virtual void DestroyVideoReceiveStream( - webrtc::VideoReceiveStream* receive_stream) OVERRIDE; - virtual webrtc::PacketReceiver* Receiver() OVERRIDE; + void DestroyVideoReceiveStream( + webrtc::VideoReceiveStream* receive_stream) override; + webrtc::PacketReceiver* Receiver() override; - virtual webrtc::Call::Stats GetStats() const OVERRIDE; + webrtc::Call::Stats GetStats() const override; - virtual void SetBitrateConfig( - const webrtc::Call::Config::BitrateConfig& bitrate_config) OVERRIDE; - virtual void SignalNetworkState(webrtc::Call::NetworkState state) OVERRIDE; + void SetBitrateConfig( + const webrtc::Call::Config::BitrateConfig& bitrate_config) override; + void SignalNetworkState(webrtc::Call::NetworkState state) override; webrtc::Call::Config config_; webrtc::Call::NetworkState network_state_; diff --git a/talk/media/webrtc/webrtcvideoframefactory.h b/talk/media/webrtc/webrtcvideoframefactory.h old mode 100755 new mode 100644 index 51f60aaeb..5557a357b --- a/talk/media/webrtc/webrtcvideoframefactory.h +++ b/talk/media/webrtc/webrtcvideoframefactory.h @@ -37,8 +37,9 @@ struct CapturedFrame; // Creates instances of cricket::WebRtcVideoFrame. class WebRtcVideoFrameFactory : public VideoFrameFactory { public: - virtual VideoFrame* CreateAliasedFrame( - const CapturedFrame* aliased_frame, int width, int height) const OVERRIDE; + VideoFrame* CreateAliasedFrame(const CapturedFrame* aliased_frame, + int width, + int height) const override; }; } // namespace cricket diff --git a/talk/media/webrtc/webrtcvoiceengine.cc b/talk/media/webrtc/webrtcvoiceengine.cc index 80b3be980..20c2e50e1 100644 --- a/talk/media/webrtc/webrtcvoiceengine.cc +++ b/talk/media/webrtc/webrtcvoiceengine.cc @@ -1790,11 +1790,11 @@ class WebRtcVoiceMediaChannel::WebRtcVoiceChannelRenderer // AudioRenderer::Sink implementation. // This method is called on the audio thread. - virtual void OnData(const void* audio_data, - int bits_per_sample, - int sample_rate, - int number_of_channels, - int number_of_frames) OVERRIDE { + void OnData(const void* audio_data, + int bits_per_sample, + int sample_rate, + int number_of_channels, + int number_of_frames) override { voe_audio_transport_->OnData(channel_, audio_data, bits_per_sample, @@ -1805,7 +1805,7 @@ class WebRtcVoiceMediaChannel::WebRtcVoiceChannelRenderer // Callback from the |renderer_| when it is going away. In case Start() has // never been called, this callback won't be triggered. - virtual void OnClose() OVERRIDE { + void OnClose() override { rtc::CritScope lock(&lock_); // Set |renderer_| to NULL to make sure no more callback will get into // the renderer. diff --git a/talk/media/webrtc/webrtcvoiceengine.h b/talk/media/webrtc/webrtcvoiceengine.h index 6dc1f25a8..b896f210f 100644 --- a/talk/media/webrtc/webrtcvoiceengine.h +++ b/talk/media/webrtc/webrtcvoiceengine.h @@ -69,8 +69,8 @@ class WebRtcSoundclipStream : public webrtc::InStream { } void set_loop(bool loop) { loop_ = loop; } - virtual int Read(void* buf, size_t len) OVERRIDE; - virtual int Rewind() OVERRIDE; + int Read(void* buf, size_t len) override; + int Rewind() override; private: rtc::MemoryStream mem_; @@ -80,9 +80,7 @@ class WebRtcSoundclipStream : public webrtc::InStream { // WebRtcMonitorStream is used to monitor a stream coming from WebRtc. // For now we just dump the data. class WebRtcMonitorStream : public webrtc::OutStream { - virtual bool Write(const void *buf, size_t len) OVERRIDE { - return true; - } + bool Write(const void* buf, size_t len) override { return true; } }; class AudioDeviceModule; @@ -152,12 +150,12 @@ class WebRtcVoiceEngine MediaProcessorDirection direction); // Method from webrtc::VoEMediaProcess - virtual void Process(int channel, - webrtc::ProcessingTypes type, - int16_t audio10ms[], - int length, - int sampling_freq, - bool is_stereo) OVERRIDE; + void Process(int channel, + webrtc::ProcessingTypes type, + int16_t audio10ms[], + int length, + int sampling_freq, + bool is_stereo) override; // For tracking WebRtc channels. Needed because we have to pause them // all when switching devices. @@ -211,12 +209,10 @@ class WebRtcVoiceEngine bool ApplyOptions(const AudioOptions& options); // webrtc::TraceCallback: - virtual void Print(webrtc::TraceLevel level, - const char* trace, - int length) OVERRIDE; + void Print(webrtc::TraceLevel level, const char* trace, int length) override; // webrtc::VoiceEngineObserver: - virtual void CallbackOnError(int channel, int errCode) OVERRIDE; + void CallbackOnError(int channel, int errCode) override; // Given the device type, name, and id, find device id. Return true and // set the output parameter rtc_id if successful. @@ -315,14 +311,12 @@ class WebRtcMediaChannel : public T, public webrtc::Transport { protected: // implements Transport interface - virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE { + int SendPacket(int channel, const void* data, size_t len) override { rtc::Buffer packet(data, len, kMaxRtpPacketLen); return T::SendPacket(&packet) ? static_cast(len) : -1; } - virtual int SendRTCPPacket(int channel, - const void* data, - size_t len) OVERRIDE { + int SendRTCPPacket(int channel, const void* data, size_t len) override { rtc::Buffer packet(data, len, kMaxRtpPacketLen); return T::SendRtcp(&packet) ? static_cast(len) : -1; } diff --git a/webrtc/base/common.h b/webrtc/base/common.h index 2a8ac3359..e39b75daf 100644 --- a/webrtc/base/common.h +++ b/webrtc/base/common.h @@ -183,28 +183,6 @@ inline bool ImplicitCastToBool(bool result) { return result; } #define FORCE_INLINE #endif -// Borrowed from Chromium's base/compiler_specific.h. -// Annotate a virtual method indicating it must be overriding a virtual -// method in the parent class. -// Use like: -// virtual void foo() OVERRIDE; -#if defined(WEBRTC_WIN) -#define OVERRIDE override -#elif defined(__clang__) -// Clang defaults to C++03 and warns about using override. Squelch that. -// Intentionally no push/pop here so all users of OVERRIDE ignore the warning -// too. This is like passing -Wno-c++11-extensions, except that GCC won't die -// (because it won't see this pragma). -#pragma clang diagnostic ignored "-Wc++11-extensions" -#define OVERRIDE override -#elif defined(__GNUC__) && __cplusplus >= 201103 && \ - (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40700 -// GCC 4.7 supports explicit virtual overrides when C++11 support is enabled. -#define OVERRIDE override -#else -#define OVERRIDE -#endif - // Annotate a function indicating the caller must examine the return value. // Use like: // int foo() WARN_UNUSED_RESULT; diff --git a/webrtc/base/thread_checker_unittest.cc b/webrtc/base/thread_checker_unittest.cc index 03053ad02..3c496314f 100644 --- a/webrtc/base/thread_checker_unittest.cc +++ b/webrtc/base/thread_checker_unittest.cc @@ -61,9 +61,7 @@ class CallDoStuffOnThread : public Thread { SetName("call_do_stuff_on_thread", NULL); } - virtual void Run() OVERRIDE { - thread_checker_class_->DoStuff(); - } + void Run() override { thread_checker_class_->DoStuff(); } // New method. Needed since Thread::Join is protected, and it is called by // the TEST. @@ -87,9 +85,7 @@ class DeleteThreadCheckerClassOnThread : public Thread { SetName("delete_thread_checker_class_on_thread", NULL); } - virtual void Run() OVERRIDE { - thread_checker_class_.reset(); - } + void Run() override { thread_checker_class_.reset(); } // New method. Needed since Thread::Join is protected, and it is called by // the TEST. diff --git a/webrtc/common_audio/blocker_unittest.cc b/webrtc/common_audio/blocker_unittest.cc index 6b97ed93a..9e9988612 100644 --- a/webrtc/common_audio/blocker_unittest.cc +++ b/webrtc/common_audio/blocker_unittest.cc @@ -17,11 +17,11 @@ namespace { // Callback Function to add 3 to every sample in the signal. class PlusThreeBlockerCallback : public webrtc::BlockerCallback { public: - virtual void ProcessBlock(const float* const* input, - int num_frames, - int num_input_channels, - int num_output_channels, - float* const* output) OVERRIDE { + void ProcessBlock(const float* const* input, + int num_frames, + int num_input_channels, + int num_output_channels, + float* const* output) override { for (int i = 0; i < num_output_channels; ++i) { for (int j = 0; j < num_frames; ++j) { output[i][j] = input[i][j] + 3; @@ -33,11 +33,11 @@ class PlusThreeBlockerCallback : public webrtc::BlockerCallback { // No-op Callback Function. class CopyBlockerCallback : public webrtc::BlockerCallback { public: - virtual void ProcessBlock(const float* const* input, - int num_frames, - int num_input_channels, - int num_output_channels, - float* const* output) OVERRIDE { + void ProcessBlock(const float* const* input, + int num_frames, + int num_input_channels, + int num_output_channels, + float* const* output) override { for (int i = 0; i < num_output_channels; ++i) { for (int j = 0; j < num_frames; ++j) { output[i][j] = input[i][j]; diff --git a/webrtc/common_audio/fir_filter.cc b/webrtc/common_audio/fir_filter.cc index f1a3baa64..c65123541 100644 --- a/webrtc/common_audio/fir_filter.cc +++ b/webrtc/common_audio/fir_filter.cc @@ -25,7 +25,7 @@ class FIRFilterC : public FIRFilter { FIRFilterC(const float* coefficients, size_t coefficients_length); - virtual void Filter(const float* in, size_t length, float* out) OVERRIDE; + void Filter(const float* in, size_t length, float* out) override; private: size_t coefficients_length_; diff --git a/webrtc/common_audio/fir_filter_neon.h b/webrtc/common_audio/fir_filter_neon.h index 930110926..d7399ad97 100644 --- a/webrtc/common_audio/fir_filter_neon.h +++ b/webrtc/common_audio/fir_filter_neon.h @@ -23,7 +23,7 @@ class FIRFilterNEON : public FIRFilter { size_t coefficients_length, size_t max_input_length); - virtual void Filter(const float* in, size_t length, float* out) OVERRIDE; + void Filter(const float* in, size_t length, float* out) override; private: size_t coefficients_length_; diff --git a/webrtc/common_audio/fir_filter_sse.h b/webrtc/common_audio/fir_filter_sse.h index 4e67b0425..d3968310b 100644 --- a/webrtc/common_audio/fir_filter_sse.h +++ b/webrtc/common_audio/fir_filter_sse.h @@ -23,7 +23,7 @@ class FIRFilterSSE2 : public FIRFilter { size_t coefficients_length, size_t max_input_length); - virtual void Filter(const float* in, size_t length, float* out) OVERRIDE; + void Filter(const float* in, size_t length, float* out) override; private: size_t coefficients_length_; diff --git a/webrtc/common_audio/resampler/sinusoidal_linear_chirp_source.h b/webrtc/common_audio/resampler/sinusoidal_linear_chirp_source.h index 7e9fe75e3..d6b8ce31e 100644 --- a/webrtc/common_audio/resampler/sinusoidal_linear_chirp_source.h +++ b/webrtc/common_audio/resampler/sinusoidal_linear_chirp_source.h @@ -31,7 +31,7 @@ class SinusoidalLinearChirpSource : public SincResamplerCallback { virtual ~SinusoidalLinearChirpSource() {} - virtual void Run(int frames, float* destination) OVERRIDE; + void Run(int frames, float* destination) override; double Frequency(int position); diff --git a/webrtc/common_types.cc b/webrtc/common_types.cc index bffc3ee51..73afa43d9 100644 --- a/webrtc/common_types.cc +++ b/webrtc/common_types.cc @@ -12,11 +12,19 @@ #include +#include "webrtc/base/checks.h" + namespace webrtc { -int InStream::Rewind() { return -1; } +int InStream::Rewind() { + DCHECK(false); + return -1; +} -int OutStream::Rewind() { return -1; } +int OutStream::Rewind() { + DCHECK(false); + return -1; +} StreamDataCounters::StreamDataCounters() : first_packet_time_ms(-1) {} diff --git a/webrtc/common_types.h b/webrtc/common_types.h index fbf9a6d1e..bdba653e3 100644 --- a/webrtc/common_types.h +++ b/webrtc/common_types.h @@ -56,6 +56,8 @@ class Config; class InStream { public: + // Reads |length| bytes from file to |buf|. Returns the number of bytes read + // or -1 on error. virtual int Read(void *buf, size_t len) = 0; virtual int Rewind(); virtual ~InStream() {} @@ -66,6 +68,8 @@ protected: class OutStream { public: + // Writes |length| bytes from |buf| to file. The actual writing may happen + // some time later. Call Flush() to force a write. virtual bool Write(const void *buf, size_t len) = 0; virtual int Rewind(); virtual ~OutStream() {} diff --git a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc index c2a9ce3f1..03e7ba06b 100644 --- a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc +++ b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc @@ -46,7 +46,7 @@ class AudioEncoderCngTest : public ::testing::Test { config_.payload_type = kCngPayloadType; } - virtual void TearDown() OVERRIDE { + void TearDown() override { EXPECT_CALL(*mock_vad_, Die()).Times(1); cng_.reset(); // Don't expect the cng_ object to delete the AudioEncoder object. But it @@ -407,7 +407,7 @@ class AudioEncoderCngDeathTest : public AudioEncoderCngTest { // Override AudioEncoderCngTest::TearDown, since that one expects a call to // the destructor of |mock_vad_|. In this case, that object is already // deleted. - virtual void TearDown() OVERRIDE { + void TearDown() override { cng_.reset(); // Don't expect the cng_ object to delete the AudioEncoder object. But it // will be deleted with the test fixture. This is why we explicitly delete diff --git a/webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h b/webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h index 2f5167622..1d3c2f3fa 100644 --- a/webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h +++ b/webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h @@ -44,22 +44,22 @@ class AudioEncoderCng final : public AudioEncoder { explicit AudioEncoderCng(const Config& config); - virtual ~AudioEncoderCng(); + ~AudioEncoderCng() override; - virtual int SampleRateHz() const OVERRIDE; - virtual int NumChannels() const OVERRIDE; + int SampleRateHz() const override; + int NumChannels() const override; int RtpTimestampRateHz() const override; - virtual int Num10MsFramesInNextPacket() const OVERRIDE; - virtual int Max10MsFramesInAPacket() const OVERRIDE; + int Num10MsFramesInNextPacket() const override; + int Max10MsFramesInAPacket() const override; void SetTargetBitrate(int bits_per_second) override; void SetProjectedPacketLossRate(double fraction) override; protected: - virtual void EncodeInternal(uint32_t rtp_timestamp, - const int16_t* audio, - size_t max_encoded_bytes, - uint8_t* encoded, - EncodedInfo* info) OVERRIDE; + void EncodeInternal(uint32_t rtp_timestamp, + const int16_t* audio, + size_t max_encoded_bytes, + uint8_t* encoded, + EncodedInfo* info) override; private: // Deleter for use with scoped_ptr. E.g., use as diff --git a/webrtc/modules/audio_coding/codecs/g711/include/audio_encoder_pcm.h b/webrtc/modules/audio_coding/codecs/g711/include/audio_encoder_pcm.h index 903b22008..3967c5e00 100644 --- a/webrtc/modules/audio_coding/codecs/g711/include/audio_encoder_pcm.h +++ b/webrtc/modules/audio_coding/codecs/g711/include/audio_encoder_pcm.h @@ -30,21 +30,21 @@ class AudioEncoderPcm : public AudioEncoder { : frame_size_ms(20), num_channels(1), payload_type(pt) {} }; - virtual ~AudioEncoderPcm(); + ~AudioEncoderPcm() override; - virtual int SampleRateHz() const OVERRIDE; - virtual int NumChannels() const OVERRIDE; - virtual int Num10MsFramesInNextPacket() const OVERRIDE; - virtual int Max10MsFramesInAPacket() const OVERRIDE; + int SampleRateHz() const override; + int NumChannels() const override; + int Num10MsFramesInNextPacket() const override; + int Max10MsFramesInAPacket() const override; protected: AudioEncoderPcm(const Config& config, int sample_rate_hz); - virtual void EncodeInternal(uint32_t rtp_timestamp, - const int16_t* audio, - size_t max_encoded_bytes, - uint8_t* encoded, - EncodedInfo* info) OVERRIDE; + void EncodeInternal(uint32_t rtp_timestamp, + const int16_t* audio, + size_t max_encoded_bytes, + uint8_t* encoded, + EncodedInfo* info) override; virtual int16_t EncodeCall(const int16_t* audio, size_t input_len, @@ -70,9 +70,9 @@ class AudioEncoderPcmA : public AudioEncoderPcm { : AudioEncoderPcm(config, kSampleRateHz) {} protected: - virtual int16_t EncodeCall(const int16_t* audio, - size_t input_len, - uint8_t* encoded) OVERRIDE; + int16_t EncodeCall(const int16_t* audio, + size_t input_len, + uint8_t* encoded) override; private: static const int kSampleRateHz = 8000; @@ -88,9 +88,9 @@ class AudioEncoderPcmU : public AudioEncoderPcm { : AudioEncoderPcm(config, kSampleRateHz) {} protected: - virtual int16_t EncodeCall(const int16_t* audio, - size_t input_len, - uint8_t* encoded) OVERRIDE; + int16_t EncodeCall(const int16_t* audio, + size_t input_len, + uint8_t* encoded) override; private: static const int kSampleRateHz = 8000; diff --git a/webrtc/modules/audio_coding/codecs/g722/include/audio_encoder_g722.h b/webrtc/modules/audio_coding/codecs/g722/include/audio_encoder_g722.h index 65a0d4ba7..229c06e46 100644 --- a/webrtc/modules/audio_coding/codecs/g722/include/audio_encoder_g722.h +++ b/webrtc/modules/audio_coding/codecs/g722/include/audio_encoder_g722.h @@ -28,20 +28,20 @@ class AudioEncoderG722 : public AudioEncoder { }; explicit AudioEncoderG722(const Config& config); - virtual ~AudioEncoderG722(); + ~AudioEncoderG722() override; - virtual int SampleRateHz() const OVERRIDE; + int SampleRateHz() const override; int RtpTimestampRateHz() const override; - virtual int NumChannels() const OVERRIDE; - virtual int Num10MsFramesInNextPacket() const OVERRIDE; - virtual int Max10MsFramesInAPacket() const OVERRIDE; + int NumChannels() const override; + int Num10MsFramesInNextPacket() const override; + int Max10MsFramesInAPacket() const override; protected: - virtual void EncodeInternal(uint32_t rtp_timestamp, - const int16_t* audio, - size_t max_encoded_bytes, - uint8_t* encoded, - EncodedInfo* info) OVERRIDE; + void EncodeInternal(uint32_t rtp_timestamp, + const int16_t* audio, + size_t max_encoded_bytes, + uint8_t* encoded, + EncodedInfo* info) override; private: // The encoder state for one channel. diff --git a/webrtc/modules/audio_coding/codecs/ilbc/interface/audio_encoder_ilbc.h b/webrtc/modules/audio_coding/codecs/ilbc/interface/audio_encoder_ilbc.h index 25c397a14..fc3aa0d4b 100644 --- a/webrtc/modules/audio_coding/codecs/ilbc/interface/audio_encoder_ilbc.h +++ b/webrtc/modules/audio_coding/codecs/ilbc/interface/audio_encoder_ilbc.h @@ -29,19 +29,19 @@ class AudioEncoderIlbc : public AudioEncoder { }; explicit AudioEncoderIlbc(const Config& config); - virtual ~AudioEncoderIlbc(); + ~AudioEncoderIlbc() override; - virtual int SampleRateHz() const OVERRIDE; - virtual int NumChannels() const OVERRIDE; - virtual int Num10MsFramesInNextPacket() const OVERRIDE; - virtual int Max10MsFramesInAPacket() const OVERRIDE; + int SampleRateHz() const override; + int NumChannels() const override; + int Num10MsFramesInNextPacket() const override; + int Max10MsFramesInAPacket() const override; protected: - virtual void EncodeInternal(uint32_t rtp_timestamp, - const int16_t* audio, - size_t max_encoded_bytes, - uint8_t* encoded, - EncodedInfo* info) OVERRIDE; + void EncodeInternal(uint32_t rtp_timestamp, + const int16_t* audio, + size_t max_encoded_bytes, + uint8_t* encoded, + EncodedInfo* info) override; private: static const int kMaxSamplesPerPacket = 480; diff --git a/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h b/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h index 38d590371..c918eafc4 100644 --- a/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h +++ b/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h @@ -66,42 +66,42 @@ class AudioEncoderDecoderIsacT : public AudioEncoder, public AudioDecoder { explicit AudioEncoderDecoderIsacT(const Config& config); explicit AudioEncoderDecoderIsacT(const ConfigAdaptive& config); - virtual ~AudioEncoderDecoderIsacT() OVERRIDE; + ~AudioEncoderDecoderIsacT() override; // AudioEncoder public methods. - virtual int SampleRateHz() const OVERRIDE; - virtual int NumChannels() const OVERRIDE; - virtual int Num10MsFramesInNextPacket() const OVERRIDE; - virtual int Max10MsFramesInAPacket() const OVERRIDE; + int SampleRateHz() const override; + int NumChannels() const override; + int Num10MsFramesInNextPacket() const override; + int Max10MsFramesInAPacket() const override; // AudioDecoder methods. - virtual int Decode(const uint8_t* encoded, - size_t encoded_len, - int sample_rate_hz, - int16_t* decoded, - SpeechType* speech_type) OVERRIDE; - virtual int DecodeRedundant(const uint8_t* encoded, - size_t encoded_len, - int sample_rate_hz, - int16_t* decoded, - SpeechType* speech_type) OVERRIDE; - virtual bool HasDecodePlc() const OVERRIDE; - virtual int DecodePlc(int num_frames, int16_t* decoded) OVERRIDE; - virtual int Init() OVERRIDE; - virtual int IncomingPacket(const uint8_t* payload, - size_t payload_len, - uint16_t rtp_sequence_number, - uint32_t rtp_timestamp, - uint32_t arrival_timestamp) OVERRIDE; - virtual int ErrorCode() OVERRIDE; + int Decode(const uint8_t* encoded, + size_t encoded_len, + int sample_rate_hz, + int16_t* decoded, + SpeechType* speech_type) override; + int DecodeRedundant(const uint8_t* encoded, + size_t encoded_len, + int sample_rate_hz, + int16_t* decoded, + SpeechType* speech_type) override; + bool HasDecodePlc() const override; + int DecodePlc(int num_frames, int16_t* decoded) override; + int Init() override; + int IncomingPacket(const uint8_t* payload, + size_t payload_len, + uint16_t rtp_sequence_number, + uint32_t rtp_timestamp, + uint32_t arrival_timestamp) override; + int ErrorCode() override; protected: // AudioEncoder protected method. - virtual void EncodeInternal(uint32_t rtp_timestamp, - const int16_t* audio, - size_t max_encoded_bytes, - uint8_t* encoded, - EncodedInfo* info) OVERRIDE; + void EncodeInternal(uint32_t rtp_timestamp, + const int16_t* audio, + size_t max_encoded_bytes, + uint8_t* encoded, + EncodedInfo* info) override; private: // This value is taken from STREAM_SIZE_MAX_60 for iSAC float (60 ms) and diff --git a/webrtc/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc b/webrtc/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc index d93fae3c3..bb7625756 100644 --- a/webrtc/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc +++ b/webrtc/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc @@ -23,8 +23,8 @@ static const int kIsacOutputSamplingKhz = 16; class IsacSpeedTest : public AudioCodecSpeedTest { protected: IsacSpeedTest(); - virtual void SetUp() OVERRIDE; - virtual void TearDown() OVERRIDE; + void SetUp() override; + void TearDown() override; virtual float EncodeABlock(int16_t* in_data, uint8_t* bit_stream, int max_bytes, int* encoded_bytes); virtual float DecodeABlock(const uint8_t* bit_stream, int encoded_bytes, diff --git a/webrtc/modules/audio_coding/codecs/opus/interface/audio_encoder_opus.h b/webrtc/modules/audio_coding/codecs/opus/interface/audio_encoder_opus.h index 93aca6c6c..417faf806 100644 --- a/webrtc/modules/audio_coding/codecs/opus/interface/audio_encoder_opus.h +++ b/webrtc/modules/audio_coding/codecs/opus/interface/audio_encoder_opus.h @@ -43,23 +43,23 @@ class AudioEncoderOpus final : public AudioEncoder { }; explicit AudioEncoderOpus(const Config& config); - virtual ~AudioEncoderOpus() OVERRIDE; + ~AudioEncoderOpus() override; - virtual int SampleRateHz() const OVERRIDE; - virtual int NumChannels() const OVERRIDE; - virtual int Num10MsFramesInNextPacket() const OVERRIDE; - virtual int Max10MsFramesInAPacket() const OVERRIDE; + int SampleRateHz() const override; + int NumChannels() const override; + int Num10MsFramesInNextPacket() const override; + int Max10MsFramesInAPacket() const override; void SetTargetBitrate(int bits_per_second) override; void SetProjectedPacketLossRate(double fraction) override; double packet_loss_rate() const { return packet_loss_rate_; } ApplicationMode application() const { return application_; } protected: - virtual void EncodeInternal(uint32_t rtp_timestamp, - const int16_t* audio, - size_t max_encoded_bytes, - uint8_t* encoded, - EncodedInfo* info) OVERRIDE; + void EncodeInternal(uint32_t rtp_timestamp, + const int16_t* audio, + size_t max_encoded_bytes, + uint8_t* encoded, + EncodedInfo* info) override; private: const int num_10ms_frames_per_packet_; diff --git a/webrtc/modules/audio_coding/codecs/opus/opus_speed_test.cc b/webrtc/modules/audio_coding/codecs/opus/opus_speed_test.cc index ebe4a3536..b39de499a 100644 --- a/webrtc/modules/audio_coding/codecs/opus/opus_speed_test.cc +++ b/webrtc/modules/audio_coding/codecs/opus/opus_speed_test.cc @@ -21,8 +21,8 @@ static const int kOpusSamplingKhz = 48; class OpusSpeedTest : public AudioCodecSpeedTest { protected: OpusSpeedTest(); - virtual void SetUp() OVERRIDE; - virtual void TearDown() OVERRIDE; + void SetUp() override; + void TearDown() override; virtual float EncodeABlock(int16_t* in_data, uint8_t* bit_stream, int max_bytes, int* encoded_bytes); virtual float DecodeABlock(const uint8_t* bit_stream, int encoded_bytes, diff --git a/webrtc/modules/audio_coding/codecs/pcm16b/include/audio_encoder_pcm16b.h b/webrtc/modules/audio_coding/codecs/pcm16b/include/audio_encoder_pcm16b.h index a5a040ffa..99ecd249c 100644 --- a/webrtc/modules/audio_coding/codecs/pcm16b/include/audio_encoder_pcm16b.h +++ b/webrtc/modules/audio_coding/codecs/pcm16b/include/audio_encoder_pcm16b.h @@ -28,9 +28,9 @@ class AudioEncoderPcm16B : public AudioEncoderPcm { : AudioEncoderPcm(config, config.sample_rate_hz) {} protected: - virtual int16_t EncodeCall(const int16_t* audio, - size_t input_len, - uint8_t* encoded) OVERRIDE; + int16_t EncodeCall(const int16_t* audio, + size_t input_len, + uint8_t* encoded) override; }; } // namespace webrtc diff --git a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h index beea1cf9f..39f1615d8 100644 --- a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h +++ b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h @@ -33,22 +33,22 @@ class AudioEncoderCopyRed : public AudioEncoder { // Caller keeps ownership of the AudioEncoder object. explicit AudioEncoderCopyRed(const Config& config); - virtual ~AudioEncoderCopyRed(); + ~AudioEncoderCopyRed() override; - virtual int SampleRateHz() const OVERRIDE; + int SampleRateHz() const override; int RtpTimestampRateHz() const override; - virtual int NumChannels() const OVERRIDE; - virtual int Num10MsFramesInNextPacket() const OVERRIDE; - virtual int Max10MsFramesInAPacket() const OVERRIDE; + int NumChannels() const override; + int Num10MsFramesInNextPacket() const override; + int Max10MsFramesInAPacket() const override; void SetTargetBitrate(int bits_per_second) override; void SetProjectedPacketLossRate(double fraction) override; protected: - virtual void EncodeInternal(uint32_t rtp_timestamp, - const int16_t* audio, - size_t max_encoded_bytes, - uint8_t* encoded, - EncodedInfo* info) OVERRIDE; + void EncodeInternal(uint32_t rtp_timestamp, + const int16_t* audio, + size_t max_encoded_bytes, + uint8_t* encoded, + EncodedInfo* info) override; private: AudioEncoder* speech_encoder_; diff --git a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc index b3a76a5c0..ea3ad436a 100644 --- a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc +++ b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc @@ -46,7 +46,7 @@ class AudioEncoderCopyRedTest : public ::testing::Test { .WillRepeatedly(Return(sample_rate_hz_)); } - virtual void TearDown() OVERRIDE { + void TearDown() override { red_.reset(); // Don't expect the red_ object to delete the AudioEncoder object. But it // will be deleted with the test fixture. This is why we explicitly delete diff --git a/webrtc/modules/audio_coding/main/acm2/acm_receive_test_oldapi.h b/webrtc/modules/audio_coding/main/acm2/acm_receive_test_oldapi.h index 63c35e433..5e5ff9a0a 100644 --- a/webrtc/modules/audio_coding/main/acm2/acm_receive_test_oldapi.h +++ b/webrtc/modules/audio_coding/main/acm2/acm_receive_test_oldapi.h @@ -75,7 +75,7 @@ class AcmReceiveTestToggleOutputFreqOldApi : public AcmReceiveTestOldApi { NumOutputChannels exptected_output_channels); protected: - void AfterGetAudio() OVERRIDE; + void AfterGetAudio() override; const int output_freq_hz_1_; const int output_freq_hz_2_; diff --git a/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest.cc b/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest.cc index 2eb1bf93f..602c31ad6 100644 --- a/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest.cc +++ b/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest.cc @@ -55,7 +55,7 @@ class AcmReceiverTest : public AudioPacketizationCallback, ~AcmReceiverTest() {} - virtual void SetUp() OVERRIDE { + void SetUp() override { ASSERT_TRUE(receiver_.get() != NULL); ASSERT_TRUE(acm_.get() != NULL); for (int n = 0; n < ACMCodecDB::kNumCodecs; n++) { @@ -72,8 +72,7 @@ class AcmReceiverTest : public AudioPacketizationCallback, rtp_header_.type.Audio.isCNG = false; } - virtual void TearDown() OVERRIDE { - } + void TearDown() override {} void InsertOnePacketOfSilence(int codec_id) { CodecInst codec; @@ -115,13 +114,12 @@ class AcmReceiverTest : public AudioPacketizationCallback, } } - virtual int32_t SendData( - FrameType frame_type, - uint8_t payload_type, - uint32_t timestamp, - const uint8_t* payload_data, - size_t payload_len_bytes, - const RTPFragmentationHeader* fragmentation) OVERRIDE { + int32_t SendData(FrameType frame_type, + uint8_t payload_type, + uint32_t timestamp, + const uint8_t* payload_data, + size_t payload_len_bytes, + const RTPFragmentationHeader* fragmentation) override { if (frame_type == kFrameEmpty) return 0; diff --git a/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc b/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc index e9096ff93..aeacc063e 100644 --- a/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc +++ b/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc @@ -54,7 +54,7 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback, ~AcmReceiverTestOldApi() {} - virtual void SetUp() OVERRIDE { + void SetUp() override { ASSERT_TRUE(receiver_.get() != NULL); ASSERT_TRUE(acm_.get() != NULL); for (int n = 0; n < ACMCodecDB::kNumCodecs; n++) { @@ -75,8 +75,7 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback, rtp_header_.type.Audio.isCNG = false; } - virtual void TearDown() OVERRIDE { - } + void TearDown() override {} void InsertOnePacketOfSilence(int codec_id) { CodecInst codec; @@ -115,13 +114,12 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback, } } - virtual int SendData( - FrameType frame_type, - uint8_t payload_type, - uint32_t timestamp, - const uint8_t* payload_data, - size_t payload_len_bytes, - const RTPFragmentationHeader* fragmentation) OVERRIDE { + int SendData(FrameType frame_type, + uint8_t payload_type, + uint32_t timestamp, + const uint8_t* payload_data, + size_t payload_len_bytes, + const RTPFragmentationHeader* fragmentation) override { if (frame_type == kFrameEmpty) return 0; diff --git a/webrtc/modules/audio_coding/main/acm2/acm_send_test.h b/webrtc/modules/audio_coding/main/acm2/acm_send_test.h index 769a327f1..4c4db5bd1 100644 --- a/webrtc/modules/audio_coding/main/acm2/acm_send_test.h +++ b/webrtc/modules/audio_coding/main/acm2/acm_send_test.h @@ -41,16 +41,15 @@ class AcmSendTest : public AudioPacketizationCallback, public PacketSource { // Returns the next encoded packet. Returns NULL if the test duration was // exceeded. Ownership of the packet is handed over to the caller. // Inherited from PacketSource. - virtual Packet* NextPacket() OVERRIDE; + Packet* NextPacket() override; // Inherited from AudioPacketizationCallback. - virtual int32_t SendData( - FrameType frame_type, - uint8_t payload_type, - uint32_t timestamp, - const uint8_t* payload_data, - size_t payload_len_bytes, - const RTPFragmentationHeader* fragmentation) OVERRIDE; + int32_t SendData(FrameType frame_type, + uint8_t payload_type, + uint32_t timestamp, + const uint8_t* payload_data, + size_t payload_len_bytes, + const RTPFragmentationHeader* fragmentation) override; private: static const int kBlockSizeMs = 10; diff --git a/webrtc/modules/audio_coding/main/acm2/acm_send_test_oldapi.h b/webrtc/modules/audio_coding/main/acm2/acm_send_test_oldapi.h index 05a29df2b..52cb415eb 100644 --- a/webrtc/modules/audio_coding/main/acm2/acm_send_test_oldapi.h +++ b/webrtc/modules/audio_coding/main/acm2/acm_send_test_oldapi.h @@ -46,13 +46,12 @@ class AcmSendTestOldApi : public AudioPacketizationCallback, Packet* NextPacket(); // Inherited from AudioPacketizationCallback. - virtual int32_t SendData( - FrameType frame_type, - uint8_t payload_type, - uint32_t timestamp, - const uint8_t* payload_data, - size_t payload_len_bytes, - const RTPFragmentationHeader* fragmentation) OVERRIDE; + int32_t SendData(FrameType frame_type, + uint8_t payload_type, + uint32_t timestamp, + const uint8_t* payload_data, + size_t payload_len_bytes, + const RTPFragmentationHeader* fragmentation) override; AudioCodingModule* acm() { return acm_.get(); } diff --git a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.h b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.h index 10423a72a..ef69ba53c 100644 --- a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.h +++ b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.h @@ -43,59 +43,58 @@ class AudioCodingModuleImpl : public AudioCodingModule { // // Initialize send codec. - virtual int InitializeSender() OVERRIDE; + int InitializeSender() override; // Reset send codec. - virtual int ResetEncoder() OVERRIDE; + int ResetEncoder() override; // Can be called multiple times for Codec, CNG, RED. - virtual int RegisterSendCodec(const CodecInst& send_codec) OVERRIDE; + int RegisterSendCodec(const CodecInst& send_codec) override; // Get current send codec. - virtual int SendCodec(CodecInst* current_codec) const OVERRIDE; + int SendCodec(CodecInst* current_codec) const override; // Get current send frequency. - virtual int SendFrequency() const OVERRIDE; + int SendFrequency() const override; // Get encode bit-rate. // Adaptive rate codecs return their current encode target rate, while other // codecs return there long-term average or their fixed rate. - virtual int SendBitrate() const OVERRIDE; + int SendBitrate() const override; // Set available bandwidth, inform the encoder about the // estimated bandwidth received from the remote party. - virtual int SetReceivedEstimatedBandwidth(int bw) OVERRIDE; + int SetReceivedEstimatedBandwidth(int bw) override; // Register a transport callback which will be // called to deliver the encoded buffers. - virtual int RegisterTransportCallback( - AudioPacketizationCallback* transport) OVERRIDE; + int RegisterTransportCallback(AudioPacketizationCallback* transport) override; // Add 10 ms of raw (PCM) audio data to the encoder. - virtual int Add10MsData(const AudioFrame& audio_frame) OVERRIDE; + int Add10MsData(const AudioFrame& audio_frame) override; ///////////////////////////////////////// // (RED) Redundant Coding // // Configure RED status i.e. on/off. - virtual int SetREDStatus(bool enable_red) OVERRIDE; + int SetREDStatus(bool enable_red) override; // Get RED status. - virtual bool REDStatus() const OVERRIDE; + bool REDStatus() const override; ///////////////////////////////////////// // (FEC) Forward Error Correction (codec internal) // // Configure FEC status i.e. on/off. - virtual int SetCodecFEC(bool enabled_codec_fec) OVERRIDE; + int SetCodecFEC(bool enabled_codec_fec) override; // Get FEC status. - virtual bool CodecFEC() const OVERRIDE; + bool CodecFEC() const override; // Set target packet loss rate - virtual int SetPacketLossRate(int loss_rate) OVERRIDE; + int SetPacketLossRate(int loss_rate) override; ///////////////////////////////////////// // (VAD) Voice Activity Detection @@ -103,98 +102,97 @@ class AudioCodingModuleImpl : public AudioCodingModule { // (CNG) Comfort Noise Generation // - virtual int SetVAD(bool enable_dtx = true, - bool enable_vad = false, - ACMVADMode mode = VADNormal) OVERRIDE; + int SetVAD(bool enable_dtx = true, + bool enable_vad = false, + ACMVADMode mode = VADNormal) override; - virtual int VAD(bool* dtx_enabled, - bool* vad_enabled, - ACMVADMode* mode) const OVERRIDE; + int VAD(bool* dtx_enabled, + bool* vad_enabled, + ACMVADMode* mode) const override; - virtual int RegisterVADCallback(ACMVADCallback* vad_callback) OVERRIDE; + int RegisterVADCallback(ACMVADCallback* vad_callback) override; ///////////////////////////////////////// // Receiver // // Initialize receiver, resets codec database etc. - virtual int InitializeReceiver() OVERRIDE; + int InitializeReceiver() override; // Reset the decoder state. - virtual int ResetDecoder() OVERRIDE; + int ResetDecoder() override; // Get current receive frequency. - virtual int ReceiveFrequency() const OVERRIDE; + int ReceiveFrequency() const override; // Get current playout frequency. - virtual int PlayoutFrequency() const OVERRIDE; + int PlayoutFrequency() const override; // Register possible receive codecs, can be called multiple times, // for codecs, CNG, DTMF, RED. - virtual int RegisterReceiveCodec(const CodecInst& receive_codec) OVERRIDE; + int RegisterReceiveCodec(const CodecInst& receive_codec) override; // Get current received codec. - virtual int ReceiveCodec(CodecInst* current_codec) const OVERRIDE; + int ReceiveCodec(CodecInst* current_codec) const override; // Incoming packet from network parsed and ready for decode. - virtual int IncomingPacket(const uint8_t* incoming_payload, - const size_t payload_length, - const WebRtcRTPHeader& rtp_info) OVERRIDE; + int IncomingPacket(const uint8_t* incoming_payload, + const size_t payload_length, + const WebRtcRTPHeader& rtp_info) override; // Incoming payloads, without rtp-info, the rtp-info will be created in ACM. // One usage for this API is when pre-encoded files are pushed in ACM. - virtual int IncomingPayload(const uint8_t* incoming_payload, - const size_t payload_length, - uint8_t payload_type, - uint32_t timestamp) OVERRIDE; + int IncomingPayload(const uint8_t* incoming_payload, + const size_t payload_length, + uint8_t payload_type, + uint32_t timestamp) override; // Minimum playout delay. - virtual int SetMinimumPlayoutDelay(int time_ms) OVERRIDE; + int SetMinimumPlayoutDelay(int time_ms) override; // Maximum playout delay. - virtual int SetMaximumPlayoutDelay(int time_ms) OVERRIDE; + int SetMaximumPlayoutDelay(int time_ms) override; // Smallest latency NetEq will maintain. - virtual int LeastRequiredDelayMs() const OVERRIDE; + int LeastRequiredDelayMs() const override; // Impose an initial delay on playout. ACM plays silence until |delay_ms| // audio is accumulated in NetEq buffer, then starts decoding payloads. - virtual int SetInitialPlayoutDelay(int delay_ms) OVERRIDE; + int SetInitialPlayoutDelay(int delay_ms) override; // TODO(turajs): DTMF playout is always activated in NetEq these APIs should // be removed, as well as all VoE related APIs and methods. // // Configure Dtmf playout status i.e on/off playout the incoming outband Dtmf // tone. - virtual int SetDtmfPlayoutStatus(bool enable) OVERRIDE { return 0; } + int SetDtmfPlayoutStatus(bool enable) override { return 0; } // Get Dtmf playout status. - virtual bool DtmfPlayoutStatus() const OVERRIDE { return true; } + bool DtmfPlayoutStatus() const override { return true; } // Estimate the Bandwidth based on the incoming stream, needed // for one way audio where the RTCP send the BW estimate. // This is also done in the RTP module . - virtual int DecoderEstimatedBandwidth() const OVERRIDE; + int DecoderEstimatedBandwidth() const override; // Set playout mode voice, fax. - virtual int SetPlayoutMode(AudioPlayoutMode mode) OVERRIDE; + int SetPlayoutMode(AudioPlayoutMode mode) override; // Get playout mode voice, fax. - virtual AudioPlayoutMode PlayoutMode() const OVERRIDE; + AudioPlayoutMode PlayoutMode() const override; // Get playout timestamp. - virtual int PlayoutTimestamp(uint32_t* timestamp) OVERRIDE; + int PlayoutTimestamp(uint32_t* timestamp) override; // Get 10 milliseconds of raw audio data to play out, and // automatic resample to the requested frequency if > 0. - virtual int PlayoutData10Ms(int desired_freq_hz, - AudioFrame* audio_frame) OVERRIDE; + int PlayoutData10Ms(int desired_freq_hz, AudioFrame* audio_frame) override; ///////////////////////////////////////// // Statistics // - virtual int GetNetworkStatistics(NetworkStatistics* statistics) OVERRIDE; + int GetNetworkStatistics(NetworkStatistics* statistics) override; // GET RED payload for iSAC. The method id called when 'this' ACM is // the default ACM. @@ -204,40 +202,37 @@ class AudioCodingModuleImpl : public AudioCodingModule { uint8_t* payload, int16_t* length_bytes); - virtual int ReplaceInternalDTXWithWebRtc(bool use_webrtc_dtx) OVERRIDE; + int ReplaceInternalDTXWithWebRtc(bool use_webrtc_dtx) override; - virtual int IsInternalDTXReplacedWithWebRtc(bool* uses_webrtc_dtx) OVERRIDE; + int IsInternalDTXReplacedWithWebRtc(bool* uses_webrtc_dtx) override; - virtual int SetISACMaxRate(int max_bit_per_sec) OVERRIDE; + int SetISACMaxRate(int max_bit_per_sec) override; - virtual int SetISACMaxPayloadSize(int max_size_bytes) OVERRIDE; + int SetISACMaxPayloadSize(int max_size_bytes) override; - virtual int ConfigISACBandwidthEstimator( - int frame_size_ms, - int rate_bit_per_sec, - bool enforce_frame_size = false) OVERRIDE; + int ConfigISACBandwidthEstimator(int frame_size_ms, + int rate_bit_per_sec, + bool enforce_frame_size = false) override; int SetOpusApplication(OpusApplicationMode application) override; // If current send codec is Opus, informs it about the maximum playback rate // the receiver will render. - virtual int SetOpusMaxPlaybackRate(int frequency_hz) OVERRIDE; + int SetOpusMaxPlaybackRate(int frequency_hz) override; int EnableOpusDtx() override; int DisableOpusDtx() override; - virtual int UnregisterReceiveCodec(uint8_t payload_type) OVERRIDE; + int UnregisterReceiveCodec(uint8_t payload_type) override; - virtual int EnableNack(size_t max_nack_list_size) OVERRIDE; + int EnableNack(size_t max_nack_list_size) override; - virtual void DisableNack() OVERRIDE; + void DisableNack() override; - virtual std::vector GetNackList( - int64_t round_trip_time_ms) const OVERRIDE; + std::vector GetNackList(int64_t round_trip_time_ms) const override; - virtual void GetDecodingCallStatistics( - AudioDecodingCallStats* stats) const OVERRIDE; + void GetDecodingCallStatistics(AudioDecodingCallStats* stats) const override; private: struct InputData { @@ -372,62 +367,57 @@ class AudioCodingImpl : public AudioCoding { playout_frequency_hz_ = config.playout_frequency_hz; } - virtual ~AudioCodingImpl() OVERRIDE {}; + ~AudioCodingImpl() override{}; - virtual bool RegisterSendCodec(AudioEncoder* send_codec) OVERRIDE; + bool RegisterSendCodec(AudioEncoder* send_codec) override; - virtual bool RegisterSendCodec(int encoder_type, - uint8_t payload_type, - int frame_size_samples = 0) OVERRIDE; + bool RegisterSendCodec(int encoder_type, + uint8_t payload_type, + int frame_size_samples = 0) override; - virtual const AudioEncoder* GetSenderInfo() const OVERRIDE; + const AudioEncoder* GetSenderInfo() const override; - virtual const CodecInst* GetSenderCodecInst() OVERRIDE; + const CodecInst* GetSenderCodecInst() override; - virtual int Add10MsAudio(const AudioFrame& audio_frame) OVERRIDE; + int Add10MsAudio(const AudioFrame& audio_frame) override; - virtual const ReceiverInfo* GetReceiverInfo() const OVERRIDE; + const ReceiverInfo* GetReceiverInfo() const override; - virtual bool RegisterReceiveCodec(AudioDecoder* receive_codec) OVERRIDE; + bool RegisterReceiveCodec(AudioDecoder* receive_codec) override; - virtual bool RegisterReceiveCodec(int decoder_type, - uint8_t payload_type) OVERRIDE; + bool RegisterReceiveCodec(int decoder_type, uint8_t payload_type) override; - virtual bool InsertPacket(const uint8_t* incoming_payload, - size_t payload_len_bytes, - const WebRtcRTPHeader& rtp_info) OVERRIDE; + bool InsertPacket(const uint8_t* incoming_payload, + size_t payload_len_bytes, + const WebRtcRTPHeader& rtp_info) override; - virtual bool InsertPayload(const uint8_t* incoming_payload, - size_t payload_len_byte, - uint8_t payload_type, - uint32_t timestamp) OVERRIDE; + bool InsertPayload(const uint8_t* incoming_payload, + size_t payload_len_byte, + uint8_t payload_type, + uint32_t timestamp) override; - virtual bool SetMinimumPlayoutDelay(int time_ms) OVERRIDE; + bool SetMinimumPlayoutDelay(int time_ms) override; - virtual bool SetMaximumPlayoutDelay(int time_ms) OVERRIDE; + bool SetMaximumPlayoutDelay(int time_ms) override; - virtual int LeastRequiredDelayMs() const OVERRIDE; + int LeastRequiredDelayMs() const override; - virtual bool PlayoutTimestamp(uint32_t* timestamp) OVERRIDE; + bool PlayoutTimestamp(uint32_t* timestamp) override; - virtual bool Get10MsAudio(AudioFrame* audio_frame) OVERRIDE; + bool Get10MsAudio(AudioFrame* audio_frame) override; - virtual bool GetNetworkStatistics( - NetworkStatistics* network_statistics) OVERRIDE; + bool GetNetworkStatistics(NetworkStatistics* network_statistics) override; - virtual bool EnableNack(size_t max_nack_list_size) OVERRIDE; + bool EnableNack(size_t max_nack_list_size) override; - virtual void DisableNack() OVERRIDE; + void DisableNack() override; - virtual bool SetVad(bool enable_dtx, - bool enable_vad, - ACMVADMode vad_mode) OVERRIDE; + bool SetVad(bool enable_dtx, bool enable_vad, ACMVADMode vad_mode) override; - virtual std::vector GetNackList( - int round_trip_time_ms) const OVERRIDE; + std::vector GetNackList(int round_trip_time_ms) const override; - virtual void GetDecodingCallStatistics( - AudioDecodingCallStats* call_stats) const OVERRIDE; + void GetDecodingCallStatistics( + AudioDecodingCallStats* call_stats) const override; private: // Temporary method to be used during redesign phase. diff --git a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc index b37ef9d55..852776722 100644 --- a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc +++ b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc @@ -81,13 +81,12 @@ class PacketizationCallbackStub : public AudioPacketizationCallback { : num_calls_(0), crit_sect_(CriticalSectionWrapper::CreateCriticalSection()) {} - virtual int32_t SendData( - FrameType frame_type, - uint8_t payload_type, - uint32_t timestamp, - const uint8_t* payload_data, - size_t payload_len_bytes, - const RTPFragmentationHeader* fragmentation) OVERRIDE { + int32_t SendData(FrameType frame_type, + uint8_t payload_type, + uint32_t timestamp, + const uint8_t* payload_data, + size_t payload_len_bytes, + const RTPFragmentationHeader* fragmentation) override { CriticalSectionScoped lock(crit_sect_.get()); ++num_calls_; last_payload_vec_.assign(payload_data, payload_data + payload_len_bytes); @@ -124,9 +123,9 @@ class AudioCodingModuleTest : public ::testing::Test { ~AudioCodingModuleTest() {} - void TearDown() OVERRIDE {} + void TearDown() override {} - void SetUp() OVERRIDE { + void SetUp() override { rtp_utility_->Populate(&rtp_header_); input_frame_.sample_rate_hz_ = kSampleRateHz; @@ -308,7 +307,7 @@ class AudioCodingModuleMtTest : public AudioCodingModuleTest { config_.clock = fake_clock_.get(); } - virtual void SetUp() OVERRIDE { + void SetUp() override { AudioCodingModuleTest::SetUp(); CreateAcm(); StartThreads(); @@ -321,7 +320,7 @@ class AudioCodingModuleMtTest : public AudioCodingModuleTest { ASSERT_TRUE(pull_audio_thread_->Start(thread_id)); } - virtual void TearDown() OVERRIDE { + void TearDown() override { AudioCodingModuleTest::TearDown(); pull_audio_thread_->Stop(); send_thread_->Stop(); @@ -436,7 +435,7 @@ class AcmIsacMtTest : public AudioCodingModuleMtTest { ~AcmIsacMtTest() {} - virtual void SetUp() OVERRIDE { + void SetUp() override { AudioCodingModuleTest::SetUp(); CreateAcm(); @@ -459,7 +458,7 @@ class AcmIsacMtTest : public AudioCodingModuleMtTest { StartThreads(); } - virtual void RegisterCodec() OVERRIDE { + void RegisterCodec() override { static_assert(kSampleRateHz == 16000, "test designed for iSAC 16 kHz"); // Register iSAC codec in ACM, effectively unregistering the PCM16B codec @@ -469,7 +468,7 @@ class AcmIsacMtTest : public AudioCodingModuleMtTest { acm_->RegisterReceiveCodec(acm2::ACMCodecDB::kISAC, kPayloadType)); } - virtual void InsertPacket() OVERRIDE { + void InsertPacket() override { int num_calls = packet_cb_.num_calls(); // Store locally for thread safety. if (num_calls > last_packet_number_) { // Get the new payload out from the callback handler. @@ -486,14 +485,14 @@ class AcmIsacMtTest : public AudioCodingModuleMtTest { &last_payload_vec_[0], last_payload_vec_.size(), rtp_header_)); } - virtual void InsertAudio() OVERRIDE { + void InsertAudio() override { memcpy(input_frame_.data_, audio_loop_.GetNextBlock(), kNumSamples10ms); AudioCodingModuleTest::InsertAudio(); } // This method is the same as AudioCodingModuleMtTest::TestDone(), but here // it is using the constants defined in this class (i.e., shorter test run). - virtual bool TestDone() OVERRIDE { + bool TestDone() override { if (packet_cb_.num_calls() > kNumPackets) { CriticalSectionScoped lock(crit_sect_.get()); if (pull_audio_count_ > kNumPullCalls) { @@ -708,7 +707,7 @@ class AcmSenderBitExactness : public ::testing::Test, // Returns a pointer to the next packet. Returns NULL if the source is // depleted (i.e., the test duration is exceeded), or if an error occurred. // Inherited from test::PacketSource. - virtual test::Packet* NextPacket() OVERRIDE { + test::Packet* NextPacket() override { // Get the next packet from AcmSendTest. Ownership of |packet| is // transferred to this method. test::Packet* packet = send_test_->NextPacket(); diff --git a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc index 122d0272b..14a73fd21 100644 --- a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc +++ b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc @@ -86,13 +86,12 @@ class PacketizationCallbackStubOldApi : public AudioPacketizationCallback { last_payload_type_(-1), crit_sect_(CriticalSectionWrapper::CreateCriticalSection()) {} - virtual int32_t SendData( - FrameType frame_type, - uint8_t payload_type, - uint32_t timestamp, - const uint8_t* payload_data, - size_t payload_len_bytes, - const RTPFragmentationHeader* fragmentation) OVERRIDE { + int32_t SendData(FrameType frame_type, + uint8_t payload_type, + uint32_t timestamp, + const uint8_t* payload_data, + size_t payload_len_bytes, + const RTPFragmentationHeader* fragmentation) override { CriticalSectionScoped lock(crit_sect_.get()); ++num_calls_; last_frame_type_ = frame_type; @@ -855,7 +854,7 @@ class AcmSenderBitExactnessOldApi : public ::testing::Test, // Returns a pointer to the next packet. Returns NULL if the source is // depleted (i.e., the test duration is exceeded), or if an error occurred. // Inherited from test::PacketSource. - test::Packet* NextPacket() OVERRIDE { + test::Packet* NextPacket() override { // Get the next packet from AcmSendTest. Ownership of |packet| is // transferred to this method. test::Packet* packet = send_test_->NextPacket(); @@ -1185,7 +1184,7 @@ class AcmSwitchingOutputFrequencyOldApi : public ::testing::Test, } // Inherited from test::PacketSource. - test::Packet* NextPacket() OVERRIDE { + test::Packet* NextPacket() override { // Check if it is time to terminate the test. The packet source is of type // ConstantPcmPacketSource, which is infinite, so we must end the test // "manually". diff --git a/webrtc/modules/audio_coding/main/test/Channel.h b/webrtc/modules/audio_coding/main/test/Channel.h index 55167d359..c4ad7d120 100644 --- a/webrtc/modules/audio_coding/main/test/Channel.h +++ b/webrtc/modules/audio_coding/main/test/Channel.h @@ -50,13 +50,12 @@ class Channel : public AudioPacketizationCallback { Channel(int16_t chID = -1); ~Channel(); - virtual int32_t SendData( - FrameType frameType, - uint8_t payloadType, - uint32_t timeStamp, - const uint8_t* payloadData, - size_t payloadSize, - const RTPFragmentationHeader* fragmentation) OVERRIDE; + int32_t SendData(FrameType frameType, + uint8_t payloadType, + uint32_t timeStamp, + const uint8_t* payloadData, + size_t payloadSize, + const RTPFragmentationHeader* fragmentation) override; void RegisterReceiverACM(AudioCodingModule *acm); diff --git a/webrtc/modules/audio_coding/main/test/EncodeDecodeTest.h b/webrtc/modules/audio_coding/main/test/EncodeDecodeTest.h index 4ee4fa275..44fb0b2d7 100644 --- a/webrtc/modules/audio_coding/main/test/EncodeDecodeTest.h +++ b/webrtc/modules/audio_coding/main/test/EncodeDecodeTest.h @@ -29,13 +29,12 @@ class TestPacketization : public AudioPacketizationCallback { public: TestPacketization(RTPStream *rtpStream, uint16_t frequency); ~TestPacketization(); - virtual int32_t SendData( - const FrameType frameType, - const uint8_t payloadType, - const uint32_t timeStamp, - const uint8_t* payloadData, - const size_t payloadSize, - const RTPFragmentationHeader* fragmentation) OVERRIDE; + int32_t SendData(const FrameType frameType, + const uint8_t payloadType, + const uint32_t timeStamp, + const uint8_t* payloadData, + const size_t payloadSize, + const RTPFragmentationHeader* fragmentation) override; private: static void MakeRTPheader(uint8_t* rtpHeader, uint8_t payloadType, @@ -103,7 +102,7 @@ class EncodeDecodeTest : public ACMTest { public: EncodeDecodeTest(); explicit EncodeDecodeTest(int testMode); - virtual void Perform() OVERRIDE; + void Perform() override; uint16_t _playoutFreq; uint8_t _testMode; diff --git a/webrtc/modules/audio_coding/main/test/PacketLossTest.h b/webrtc/modules/audio_coding/main/test/PacketLossTest.h index 70fa9ff21..d25dea264 100644 --- a/webrtc/modules/audio_coding/main/test/PacketLossTest.h +++ b/webrtc/modules/audio_coding/main/test/PacketLossTest.h @@ -23,7 +23,8 @@ class ReceiverWithPacketLoss : public Receiver { void Setup(AudioCodingModule *acm, RTPStream *rtpStream, std::string out_file_name, int channels, int loss_rate, int burst_length); - bool IncomingPacket() OVERRIDE; + bool IncomingPacket() override; + protected: bool PacketLost(); int loss_rate_; diff --git a/webrtc/modules/audio_coding/main/test/RTPFile.h b/webrtc/modules/audio_coding/main/test/RTPFile.h index 9a2d43a14..346440b1b 100644 --- a/webrtc/modules/audio_coding/main/test/RTPFile.h +++ b/webrtc/modules/audio_coding/main/test/RTPFile.h @@ -65,14 +65,19 @@ class RTPBuffer : public RTPStream { ~RTPBuffer(); - virtual void Write(const uint8_t payloadType, const uint32_t timeStamp, - const int16_t seqNo, const uint8_t* payloadData, - const size_t payloadSize, uint32_t frequency) OVERRIDE; + void Write(const uint8_t payloadType, + const uint32_t timeStamp, + const int16_t seqNo, + const uint8_t* payloadData, + const size_t payloadSize, + uint32_t frequency) override; - virtual size_t Read(WebRtcRTPHeader* rtpInfo, uint8_t* payloadData, - size_t payloadSize, uint32_t* offset) OVERRIDE; + size_t Read(WebRtcRTPHeader* rtpInfo, + uint8_t* payloadData, + size_t payloadSize, + uint32_t* offset) override; - virtual bool EndOfFile() const OVERRIDE; + bool EndOfFile() const override; private: RWLockWrapper* _queueRWLock; @@ -97,16 +102,19 @@ class RTPFile : public RTPStream { void ReadHeader(); - virtual void Write(const uint8_t payloadType, const uint32_t timeStamp, - const int16_t seqNo, const uint8_t* payloadData, - const size_t payloadSize, uint32_t frequency) OVERRIDE; + void Write(const uint8_t payloadType, + const uint32_t timeStamp, + const int16_t seqNo, + const uint8_t* payloadData, + const size_t payloadSize, + uint32_t frequency) override; - virtual size_t Read(WebRtcRTPHeader* rtpInfo, uint8_t* payloadData, - size_t payloadSize, uint32_t* offset) OVERRIDE; + size_t Read(WebRtcRTPHeader* rtpInfo, + uint8_t* payloadData, + size_t payloadSize, + uint32_t* offset) override; - virtual bool EndOfFile() const OVERRIDE { - return _rtpEOF; - } + bool EndOfFile() const override { return _rtpEOF; } private: FILE* _rtpFile; diff --git a/webrtc/modules/audio_coding/main/test/TestAllCodecs.h b/webrtc/modules/audio_coding/main/test/TestAllCodecs.h index 4292d77ca..1cdc0cba9 100644 --- a/webrtc/modules/audio_coding/main/test/TestAllCodecs.h +++ b/webrtc/modules/audio_coding/main/test/TestAllCodecs.h @@ -28,13 +28,12 @@ class TestPack : public AudioPacketizationCallback { void RegisterReceiverACM(AudioCodingModule* acm); - virtual int32_t SendData( - FrameType frame_type, - uint8_t payload_type, - uint32_t timestamp, - const uint8_t* payload_data, - size_t payload_size, - const RTPFragmentationHeader* fragmentation) OVERRIDE; + int32_t SendData(FrameType frame_type, + uint8_t payload_type, + uint32_t timestamp, + const uint8_t* payload_data, + size_t payload_size, + const RTPFragmentationHeader* fragmentation) override; size_t payload_size(); uint32_t timestamp_diff(); @@ -55,7 +54,7 @@ class TestAllCodecs : public ACMTest { explicit TestAllCodecs(int test_mode); ~TestAllCodecs(); - virtual void Perform() OVERRIDE; + void Perform() override; private: // The default value of '-1' indicates that the registration is based only on diff --git a/webrtc/modules/audio_coding/main/test/TestStereo.h b/webrtc/modules/audio_coding/main/test/TestStereo.h index 89914ccfc..c6412c794 100644 --- a/webrtc/modules/audio_coding/main/test/TestStereo.h +++ b/webrtc/modules/audio_coding/main/test/TestStereo.h @@ -35,13 +35,12 @@ class TestPackStereo : public AudioPacketizationCallback { void RegisterReceiverACM(AudioCodingModule* acm); - virtual int32_t SendData( - const FrameType frame_type, - const uint8_t payload_type, - const uint32_t timestamp, - const uint8_t* payload_data, - const size_t payload_size, - const RTPFragmentationHeader* fragmentation) OVERRIDE; + int32_t SendData(const FrameType frame_type, + const uint8_t payload_type, + const uint32_t timestamp, + const uint8_t* payload_data, + const size_t payload_size, + const RTPFragmentationHeader* fragmentation) override; uint16_t payload_size(); uint32_t timestamp_diff(); @@ -66,7 +65,8 @@ class TestStereo : public ACMTest { explicit TestStereo(int test_mode); ~TestStereo(); - virtual void Perform() OVERRIDE; + void Perform() override; + private: // The default value of '-1' indicates that the registration is based only on // codec name and a sampling frequncy matching is not required. This is useful diff --git a/webrtc/modules/audio_coding/neteq/accelerate.h b/webrtc/modules/audio_coding/neteq/accelerate.h index 2da999326..6e3aa4634 100644 --- a/webrtc/modules/audio_coding/neteq/accelerate.h +++ b/webrtc/modules/audio_coding/neteq/accelerate.h @@ -49,16 +49,18 @@ class Accelerate : public TimeStretch { protected: // Sets the parameters |best_correlation| and |peak_index| to suitable // values when the signal contains no active speech. - virtual void SetParametersForPassiveSpeech(size_t len, - int16_t* best_correlation, - int* peak_index) const OVERRIDE; + void SetParametersForPassiveSpeech(size_t len, + int16_t* best_correlation, + int* peak_index) const override; // Checks the criteria for performing the time-stretching operation and, // if possible, performs the time-stretching. - virtual ReturnCodes CheckCriteriaAndStretch( - const int16_t* input, size_t input_length, size_t peak_index, - int16_t best_correlation, bool active_speech, - AudioMultiVector* output) const OVERRIDE; + ReturnCodes CheckCriteriaAndStretch(const int16_t* input, + size_t input_length, + size_t peak_index, + int16_t best_correlation, + bool active_speech, + AudioMultiVector* output) const override; private: DISALLOW_COPY_AND_ASSIGN(Accelerate); diff --git a/webrtc/modules/audio_coding/neteq/audio_decoder_impl.h b/webrtc/modules/audio_coding/neteq/audio_decoder_impl.h index 7d36a395b..7e80a368d 100644 --- a/webrtc/modules/audio_coding/neteq/audio_decoder_impl.h +++ b/webrtc/modules/audio_coding/neteq/audio_decoder_impl.h @@ -233,7 +233,7 @@ class AudioDecoderCng : public AudioDecoder { uint32_t rtp_timestamp, uint32_t arrival_timestamp) { return -1; } - virtual CNG_dec_inst* CngDecoderInstance() OVERRIDE { return dec_state_; } + CNG_dec_inst* CngDecoderInstance() override { return dec_state_; } private: CNG_dec_inst* dec_state_; diff --git a/webrtc/modules/audio_coding/neteq/decision_logic_fax.h b/webrtc/modules/audio_coding/neteq/decision_logic_fax.h index 01a948fa4..97c481db8 100644 --- a/webrtc/modules/audio_coding/neteq/decision_logic_fax.h +++ b/webrtc/modules/audio_coding/neteq/decision_logic_fax.h @@ -47,13 +47,13 @@ class DecisionLogicFax : public DecisionLogic { // should be set to true. The output variable |reset_decoder| will be set to // true if a reset is required; otherwise it is left unchanged (i.e., it can // remain true if it was true before the call). - virtual Operations GetDecisionSpecialized(const SyncBuffer& sync_buffer, - const Expand& expand, - int decoder_frame_length, - const RTPHeader* packet_header, - Modes prev_mode, - bool play_dtmf, - bool* reset_decoder) OVERRIDE; + Operations GetDecisionSpecialized(const SyncBuffer& sync_buffer, + const Expand& expand, + int decoder_frame_length, + const RTPHeader* packet_header, + Modes prev_mode, + bool play_dtmf, + bool* reset_decoder) override; private: DISALLOW_COPY_AND_ASSIGN(DecisionLogicFax); diff --git a/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc b/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc index 8a382e959..28e901ea2 100644 --- a/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc +++ b/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc @@ -378,7 +378,7 @@ TEST_F(LargeTimestampJumpTest, JumpLongerThanHalfRangeAndWrap) { class ShortTimestampJumpTest : public LargeTimestampJumpTest { protected: - void UpdateState(NetEqOutputType output_type) OVERRIDE { + void UpdateState(NetEqOutputType output_type) override { switch (test_state_) { case kInitialPhase: { if (output_type == kOutputNormal) { diff --git a/webrtc/modules/audio_coding/neteq/neteq_impl.h b/webrtc/modules/audio_coding/neteq/neteq_impl.h index b82b43e26..ac4689bbc 100644 --- a/webrtc/modules/audio_coding/neteq/neteq_impl.h +++ b/webrtc/modules/audio_coding/neteq/neteq_impl.h @@ -79,10 +79,10 @@ class NetEqImpl : public webrtc::NetEq { // of the time when the packet was received, and should be measured with // the same tick rate as the RTP timestamp of the current payload. // Returns 0 on success, -1 on failure. - virtual int InsertPacket(const WebRtcRTPHeader& rtp_header, - const uint8_t* payload, - size_t length_bytes, - uint32_t receive_timestamp) OVERRIDE; + int InsertPacket(const WebRtcRTPHeader& rtp_header, + const uint8_t* payload, + size_t length_bytes, + uint32_t receive_timestamp) override; // Inserts a sync-packet into packet queue. Sync-packets are decoded to // silence and are intended to keep AV-sync intact in an event of long packet @@ -93,8 +93,8 @@ class NetEqImpl : public webrtc::NetEq { // type, i.e. they cannot have DTMF or CNG payload type, nor a codec change // can be implied by inserting a sync-packet. // Returns kOk on success, kFail on failure. - virtual int InsertSyncPacket(const WebRtcRTPHeader& rtp_header, - uint32_t receive_timestamp) OVERRIDE; + int InsertSyncPacket(const WebRtcRTPHeader& rtp_header, + uint32_t receive_timestamp) override; // Instructs NetEq to deliver 10 ms of audio data. The data is written to // |output_audio|, which can hold (at least) |max_length| elements. @@ -104,97 +104,98 @@ class NetEqImpl : public webrtc::NetEq { // the samples are interleaved. // The speech type is written to |type|, if |type| is not NULL. // Returns kOK on success, or kFail in case of an error. - virtual int GetAudio(size_t max_length, int16_t* output_audio, - int* samples_per_channel, int* num_channels, - NetEqOutputType* type) OVERRIDE; + int GetAudio(size_t max_length, + int16_t* output_audio, + int* samples_per_channel, + int* num_channels, + NetEqOutputType* type) override; // Associates |rtp_payload_type| with |codec| and stores the information in // the codec database. Returns kOK on success, kFail on failure. - virtual int RegisterPayloadType(enum NetEqDecoder codec, - uint8_t rtp_payload_type) OVERRIDE; + int RegisterPayloadType(enum NetEqDecoder codec, + uint8_t rtp_payload_type) override; // Provides an externally created decoder object |decoder| to insert in the // decoder database. The decoder implements a decoder of type |codec| and // associates it with |rtp_payload_type|. Returns kOK on success, kFail on // failure. - virtual int RegisterExternalDecoder(AudioDecoder* decoder, - enum NetEqDecoder codec, - uint8_t rtp_payload_type) OVERRIDE; + int RegisterExternalDecoder(AudioDecoder* decoder, + enum NetEqDecoder codec, + uint8_t rtp_payload_type) override; // Removes |rtp_payload_type| from the codec database. Returns 0 on success, // -1 on failure. - virtual int RemovePayloadType(uint8_t rtp_payload_type) OVERRIDE; + int RemovePayloadType(uint8_t rtp_payload_type) override; - virtual bool SetMinimumDelay(int delay_ms) OVERRIDE; + bool SetMinimumDelay(int delay_ms) override; - virtual bool SetMaximumDelay(int delay_ms) OVERRIDE; + bool SetMaximumDelay(int delay_ms) override; - virtual int LeastRequiredDelayMs() const OVERRIDE; + int LeastRequiredDelayMs() const override; - virtual int SetTargetDelay() OVERRIDE { return kNotImplemented; } + int SetTargetDelay() override { return kNotImplemented; } - virtual int TargetDelay() OVERRIDE { return kNotImplemented; } + int TargetDelay() override { return kNotImplemented; } - virtual int CurrentDelay() OVERRIDE { return kNotImplemented; } + int CurrentDelay() override { return kNotImplemented; } // Sets the playout mode to |mode|. // Deprecated. // TODO(henrik.lundin) Delete. - virtual void SetPlayoutMode(NetEqPlayoutMode mode) OVERRIDE; + void SetPlayoutMode(NetEqPlayoutMode mode) override; // Returns the current playout mode. // Deprecated. // TODO(henrik.lundin) Delete. - virtual NetEqPlayoutMode PlayoutMode() const OVERRIDE; + NetEqPlayoutMode PlayoutMode() const override; // Writes the current network statistics to |stats|. The statistics are reset // after the call. - virtual int NetworkStatistics(NetEqNetworkStatistics* stats) OVERRIDE; + int NetworkStatistics(NetEqNetworkStatistics* stats) override; // Writes the last packet waiting times (in ms) to |waiting_times|. The number // of values written is no more than 100, but may be smaller if the interface // is polled again before 100 packets has arrived. - virtual void WaitingTimes(std::vector* waiting_times) OVERRIDE; + void WaitingTimes(std::vector* waiting_times) override; // Writes the current RTCP statistics to |stats|. The statistics are reset // and a new report period is started with the call. - virtual void GetRtcpStatistics(RtcpStatistics* stats) OVERRIDE; + void GetRtcpStatistics(RtcpStatistics* stats) override; // Same as RtcpStatistics(), but does not reset anything. - virtual void GetRtcpStatisticsNoReset(RtcpStatistics* stats) OVERRIDE; + void GetRtcpStatisticsNoReset(RtcpStatistics* stats) override; // Enables post-decode VAD. When enabled, GetAudio() will return // kOutputVADPassive when the signal contains no speech. - virtual void EnableVad() OVERRIDE; + void EnableVad() override; // Disables post-decode VAD. - virtual void DisableVad() OVERRIDE; + void DisableVad() override; - virtual bool GetPlayoutTimestamp(uint32_t* timestamp) OVERRIDE; + bool GetPlayoutTimestamp(uint32_t* timestamp) override; - virtual int SetTargetNumberOfChannels() OVERRIDE { return kNotImplemented; } + int SetTargetNumberOfChannels() override { return kNotImplemented; } - virtual int SetTargetSampleRate() OVERRIDE { return kNotImplemented; } + int SetTargetSampleRate() override { return kNotImplemented; } // Returns the error code for the last occurred error. If no error has // occurred, 0 is returned. - virtual int LastError() const OVERRIDE; + int LastError() const override; // Returns the error code last returned by a decoder (audio or comfort noise). // When LastError() returns kDecoderErrorCode or kComfortNoiseErrorCode, check // this method to get the decoder's error code. - virtual int LastDecoderError() OVERRIDE; + int LastDecoderError() override; // Flushes both the packet buffer and the sync buffer. - virtual void FlushBuffers() OVERRIDE; + void FlushBuffers() override; - virtual void PacketBufferStatistics(int* current_num_packets, - int* max_num_packets) const OVERRIDE; + void PacketBufferStatistics(int* current_num_packets, + int* max_num_packets) const override; // Get sequence number and timestamp of the latest RTP. // This method is to facilitate NACK. - virtual int DecodedRtpInfo(int* sequence_number, - uint32_t* timestamp) const OVERRIDE; + int DecodedRtpInfo(int* sequence_number, uint32_t* timestamp) const override; // This accessor method is only intended for testing purposes. const SyncBuffer* sync_buffer_for_test() const; diff --git a/webrtc/modules/audio_coding/neteq/test/NETEQTEST_DummyRTPpacket.h b/webrtc/modules/audio_coding/neteq/test/NETEQTEST_DummyRTPpacket.h index 9f09c9482..1ac6c9a14 100644 --- a/webrtc/modules/audio_coding/neteq/test/NETEQTEST_DummyRTPpacket.h +++ b/webrtc/modules/audio_coding/neteq/test/NETEQTEST_DummyRTPpacket.h @@ -15,9 +15,9 @@ class NETEQTEST_DummyRTPpacket : public NETEQTEST_RTPpacket { public: - virtual int readFromFile(FILE* fp) OVERRIDE; - virtual int writeToFile(FILE* fp) OVERRIDE; - virtual void parseHeader() OVERRIDE; + int readFromFile(FILE* fp) override; + int writeToFile(FILE* fp) override; + void parseHeader() override; }; #endif // NETEQTEST_DUMMYRTPPACKET_H diff --git a/webrtc/modules/audio_coding/neteq/test/neteq_isac_quality_test.cc b/webrtc/modules/audio_coding/neteq/test/neteq_isac_quality_test.cc index b672a0c2b..7abf5a1fa 100644 --- a/webrtc/modules/audio_coding/neteq/test/neteq_isac_quality_test.cc +++ b/webrtc/modules/audio_coding/neteq/test/neteq_isac_quality_test.cc @@ -88,8 +88,8 @@ static const bool runtime_dummy = class NetEqIsacQualityTest : public NetEqQualityTest { protected: NetEqIsacQualityTest(); - virtual void SetUp() OVERRIDE; - virtual void TearDown() OVERRIDE; + void SetUp() override; + void TearDown() override; virtual int EncodeBlock(int16_t* in_data, int block_size_samples, uint8_t* payload, int max_bytes); private: diff --git a/webrtc/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc b/webrtc/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc index e1f53af8a..55ef0c7c0 100644 --- a/webrtc/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc +++ b/webrtc/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc @@ -116,8 +116,8 @@ DEFINE_bool(dtx, true, "Whether to enable DTX for encoding."); class NetEqOpusFecQualityTest : public NetEqQualityTest { protected: NetEqOpusFecQualityTest(); - virtual void SetUp() OVERRIDE; - virtual void TearDown() OVERRIDE; + void SetUp() override; + void TearDown() override; virtual int EncodeBlock(int16_t* in_data, int block_size_samples, uint8_t* payload, int max_bytes); private: diff --git a/webrtc/modules/audio_coding/neteq/tools/audio_checksum.h b/webrtc/modules/audio_coding/neteq/tools/audio_checksum.h index 173713a3b..b4a6a817b 100644 --- a/webrtc/modules/audio_coding/neteq/tools/audio_checksum.h +++ b/webrtc/modules/audio_coding/neteq/tools/audio_checksum.h @@ -26,7 +26,7 @@ class AudioChecksum : public AudioSink { public: AudioChecksum() : finished_(false) {} - virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE { + bool WriteArray(const int16_t* audio, size_t num_samples) override { if (finished_) return false; diff --git a/webrtc/modules/audio_coding/neteq/tools/audio_sink.h b/webrtc/modules/audio_coding/neteq/tools/audio_sink.h index 474ec1c46..b7b3ed111 100644 --- a/webrtc/modules/audio_coding/neteq/tools/audio_sink.h +++ b/webrtc/modules/audio_coding/neteq/tools/audio_sink.h @@ -47,7 +47,7 @@ class AudioSinkFork : public AudioSink { AudioSinkFork(AudioSink* left, AudioSink* right) : left_sink_(left), right_sink_(right) {} - virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE { + bool WriteArray(const int16_t* audio, size_t num_samples) override { return left_sink_->WriteArray(audio, num_samples) && right_sink_->WriteArray(audio, num_samples); } diff --git a/webrtc/modules/audio_coding/neteq/tools/constant_pcm_packet_source.h b/webrtc/modules/audio_coding/neteq/tools/constant_pcm_packet_source.h index fcf4f1320..b780fbfac 100644 --- a/webrtc/modules/audio_coding/neteq/tools/constant_pcm_packet_source.h +++ b/webrtc/modules/audio_coding/neteq/tools/constant_pcm_packet_source.h @@ -33,7 +33,7 @@ class ConstantPcmPacketSource : public PacketSource { // Returns a pointer to the next packet. Will never return NULL. That is, // the source is infinite. - Packet* NextPacket() OVERRIDE; + Packet* NextPacket() override; private: void WriteHeader(uint8_t* packet_memory); diff --git a/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.h b/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.h index 6207fded8..cb40b1cc8 100644 --- a/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.h +++ b/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.h @@ -33,13 +33,13 @@ class LossModel { class NoLoss : public LossModel { public: - virtual bool Lost() OVERRIDE; + bool Lost() override; }; class UniformLoss : public LossModel { public: UniformLoss(double loss_rate); - virtual bool Lost() OVERRIDE; + bool Lost() override; void set_loss_rate(double loss_rate) { loss_rate_ = loss_rate; } private: @@ -49,7 +49,7 @@ class UniformLoss : public LossModel { class GilbertElliotLoss : public LossModel { public: GilbertElliotLoss(double prob_trans_11, double prob_trans_01); - virtual bool Lost() OVERRIDE; + bool Lost() override; private: // Prob. of losing current packet, when previous packet is lost. @@ -69,8 +69,8 @@ class NetEqQualityTest : public ::testing::Test { int channels, std::string in_filename, std::string out_filename); - virtual void SetUp() OVERRIDE; - virtual void TearDown() OVERRIDE; + void SetUp() override; + void TearDown() override; // EncodeBlock(...) does the following: // 1. encodes a block of audio, saved in |in_data| and has a length of diff --git a/webrtc/modules/audio_coding/neteq/tools/output_audio_file.h b/webrtc/modules/audio_coding/neteq/tools/output_audio_file.h index 1d6128076..ff30f673d 100644 --- a/webrtc/modules/audio_coding/neteq/tools/output_audio_file.h +++ b/webrtc/modules/audio_coding/neteq/tools/output_audio_file.h @@ -34,7 +34,7 @@ class OutputAudioFile : public AudioSink { fclose(out_file_); } - virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE { + bool WriteArray(const int16_t* audio, size_t num_samples) override { assert(out_file_); return fwrite(audio, sizeof(*audio), num_samples, out_file_) == num_samples; } diff --git a/webrtc/modules/audio_coding/neteq/tools/output_wav_file.h b/webrtc/modules/audio_coding/neteq/tools/output_wav_file.h index 1f72162c6..1b1ed4282 100644 --- a/webrtc/modules/audio_coding/neteq/tools/output_wav_file.h +++ b/webrtc/modules/audio_coding/neteq/tools/output_wav_file.h @@ -27,7 +27,7 @@ class OutputWavFile : public AudioSink { OutputWavFile(const std::string& file_name, int sample_rate_hz) : wav_writer_(file_name, sample_rate_hz, 1) {} - virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE { + bool WriteArray(const int16_t* audio, size_t num_samples) override { wav_writer_.WriteSamples(audio, num_samples); return true; } diff --git a/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h b/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h index 70b5216e6..d71168595 100644 --- a/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h +++ b/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h @@ -41,7 +41,7 @@ class RtpFileSource : public PacketSource { // Returns a pointer to the next packet. Returns NULL if end of file was // reached, or if a the data was corrupt. - virtual Packet* NextPacket() OVERRIDE; + Packet* NextPacket() override; private: static const int kFirstLineLength = 40; diff --git a/webrtc/modules/audio_coding/neteq/tools/rtp_generator.h b/webrtc/modules/audio_coding/neteq/tools/rtp_generator.h index 228043614..e09f6e4ca 100644 --- a/webrtc/modules/audio_coding/neteq/tools/rtp_generator.h +++ b/webrtc/modules/audio_coding/neteq/tools/rtp_generator.h @@ -70,7 +70,7 @@ class TimestampJumpRtpGenerator : public RtpGenerator { uint32_t GetRtpHeader(uint8_t payload_type, size_t payload_length_samples, - WebRtcRTPHeader* rtp_header) OVERRIDE; + WebRtcRTPHeader* rtp_header) override; private: uint32_t jump_from_timestamp_; diff --git a/webrtc/modules/audio_conference_mixer/interface/audio_conference_mixer.h b/webrtc/modules/audio_conference_mixer/interface/audio_conference_mixer.h index c9cc6ef71..b9be6c649 100644 --- a/webrtc/modules/audio_conference_mixer/interface/audio_conference_mixer.h +++ b/webrtc/modules/audio_conference_mixer/interface/audio_conference_mixer.h @@ -40,8 +40,8 @@ public: virtual ~AudioConferenceMixer() {} // Module functions - virtual int64_t TimeUntilNextProcess() OVERRIDE = 0; - virtual int32_t Process() OVERRIDE = 0; + int64_t TimeUntilNextProcess() override = 0; + int32_t Process() override = 0; // Register/unregister a callback class for receiving the mixed audio. virtual int32_t RegisterMixedStreamCallback( diff --git a/webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.h b/webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.h index e3367f201..b1a812a11 100644 --- a/webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.h +++ b/webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.h @@ -64,26 +64,27 @@ public: bool Init(); // Module functions - virtual int64_t TimeUntilNextProcess() OVERRIDE; - virtual int32_t Process() OVERRIDE; + int64_t TimeUntilNextProcess() override; + int32_t Process() override; // AudioConferenceMixer functions - virtual int32_t RegisterMixedStreamCallback( - AudioMixerOutputReceiver& mixReceiver) OVERRIDE; - virtual int32_t UnRegisterMixedStreamCallback() OVERRIDE; - virtual int32_t RegisterMixerStatusCallback( + int32_t RegisterMixedStreamCallback( + AudioMixerOutputReceiver& mixReceiver) override; + int32_t UnRegisterMixedStreamCallback() override; + int32_t RegisterMixerStatusCallback( AudioMixerStatusReceiver& mixerStatusCallback, - const uint32_t amountOf10MsBetweenCallbacks) OVERRIDE; - virtual int32_t UnRegisterMixerStatusCallback() OVERRIDE; - virtual int32_t SetMixabilityStatus(MixerParticipant& participant, - bool mixable) OVERRIDE; - virtual int32_t MixabilityStatus(MixerParticipant& participant, - bool& mixable) OVERRIDE; - virtual int32_t SetMinimumMixingFrequency(Frequency freq) OVERRIDE; - virtual int32_t SetAnonymousMixabilityStatus( - MixerParticipant& participant, const bool mixable) OVERRIDE; - virtual int32_t AnonymousMixabilityStatus( - MixerParticipant& participant, bool& mixable) OVERRIDE; + const uint32_t amountOf10MsBetweenCallbacks) override; + int32_t UnRegisterMixerStatusCallback() override; + int32_t SetMixabilityStatus(MixerParticipant& participant, + bool mixable) override; + int32_t MixabilityStatus(MixerParticipant& participant, + bool& mixable) override; + int32_t SetMinimumMixingFrequency(Frequency freq) override; + int32_t SetAnonymousMixabilityStatus(MixerParticipant& participant, + const bool mixable) override; + int32_t AnonymousMixabilityStatus(MixerParticipant& participant, + bool& mixable) override; + private: enum{DEFAULT_AUDIO_FRAME_POOLSIZE = 50}; diff --git a/webrtc/modules/audio_device/audio_device_impl.h b/webrtc/modules/audio_device/audio_device_impl.h index 010d6439b..294d3ba9c 100644 --- a/webrtc/modules/audio_device/audio_device_impl.h +++ b/webrtc/modules/audio_device/audio_device_impl.h @@ -43,8 +43,8 @@ public: virtual ~AudioDeviceModuleImpl(); public: // RefCountedModule - virtual int64_t TimeUntilNextProcess() OVERRIDE; - virtual int32_t Process() OVERRIDE; + int64_t TimeUntilNextProcess() override; + int32_t Process() override; public: // Factory methods (resource allocation/deallocation) @@ -53,155 +53,142 @@ public: const AudioLayer audioLayer = kPlatformDefaultAudio); // Retrieve the currently utilized audio layer - virtual int32_t ActiveAudioLayer(AudioLayer* audioLayer) const OVERRIDE; + int32_t ActiveAudioLayer(AudioLayer* audioLayer) const override; // Error handling - virtual ErrorCode LastError() const OVERRIDE; - virtual int32_t RegisterEventObserver( - AudioDeviceObserver* eventCallback) OVERRIDE; + ErrorCode LastError() const override; + int32_t RegisterEventObserver(AudioDeviceObserver* eventCallback) override; // Full-duplex transportation of PCM audio - virtual int32_t RegisterAudioCallback( - AudioTransport* audioCallback) OVERRIDE; + int32_t RegisterAudioCallback(AudioTransport* audioCallback) override; // Main initializaton and termination - virtual int32_t Init() OVERRIDE; - virtual int32_t Terminate() OVERRIDE; - virtual bool Initialized() const OVERRIDE; + int32_t Init() override; + int32_t Terminate() override; + bool Initialized() const override; // Device enumeration - virtual int16_t PlayoutDevices() OVERRIDE; - virtual int16_t RecordingDevices() OVERRIDE; - virtual int32_t PlayoutDeviceName( - uint16_t index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]) OVERRIDE; - virtual int32_t RecordingDeviceName( - uint16_t index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]) OVERRIDE; + int16_t PlayoutDevices() override; + int16_t RecordingDevices() override; + int32_t PlayoutDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]) override; + int32_t RecordingDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]) override; // Device selection - virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE; - virtual int32_t SetPlayoutDevice(WindowsDeviceType device) OVERRIDE; - virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE; - virtual int32_t SetRecordingDevice(WindowsDeviceType device) OVERRIDE; + int32_t SetPlayoutDevice(uint16_t index) override; + int32_t SetPlayoutDevice(WindowsDeviceType device) override; + int32_t SetRecordingDevice(uint16_t index) override; + int32_t SetRecordingDevice(WindowsDeviceType device) override; // Audio transport initialization - virtual int32_t PlayoutIsAvailable(bool* available) OVERRIDE; - virtual int32_t InitPlayout() OVERRIDE; - virtual bool PlayoutIsInitialized() const OVERRIDE; - virtual int32_t RecordingIsAvailable(bool* available) OVERRIDE; - virtual int32_t InitRecording() OVERRIDE; - virtual bool RecordingIsInitialized() const OVERRIDE; + int32_t PlayoutIsAvailable(bool* available) override; + int32_t InitPlayout() override; + bool PlayoutIsInitialized() const override; + int32_t RecordingIsAvailable(bool* available) override; + int32_t InitRecording() override; + bool RecordingIsInitialized() const override; // Audio transport control - virtual int32_t StartPlayout() OVERRIDE; - virtual int32_t StopPlayout() OVERRIDE; - virtual bool Playing() const OVERRIDE; - virtual int32_t StartRecording() OVERRIDE; - virtual int32_t StopRecording() OVERRIDE; - virtual bool Recording() const OVERRIDE; + int32_t StartPlayout() override; + int32_t StopPlayout() override; + bool Playing() const override; + int32_t StartRecording() override; + int32_t StopRecording() override; + bool Recording() const override; // Microphone Automatic Gain Control (AGC) - virtual int32_t SetAGC(bool enable) OVERRIDE; - virtual bool AGC() const OVERRIDE; + int32_t SetAGC(bool enable) override; + bool AGC() const override; // Volume control based on the Windows Wave API (Windows only) - virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, - uint16_t volumeRight) OVERRIDE; - virtual int32_t WaveOutVolume(uint16_t* volumeLeft, - uint16_t* volumeRight) const OVERRIDE; + int32_t SetWaveOutVolume(uint16_t volumeLeft, + uint16_t volumeRight) override; + int32_t WaveOutVolume(uint16_t* volumeLeft, + uint16_t* volumeRight) const override; // Audio mixer initialization - virtual int32_t InitSpeaker() OVERRIDE; - virtual bool SpeakerIsInitialized() const OVERRIDE; - virtual int32_t InitMicrophone() OVERRIDE; - virtual bool MicrophoneIsInitialized() const OVERRIDE; + int32_t InitSpeaker() override; + bool SpeakerIsInitialized() const override; + int32_t InitMicrophone() override; + bool MicrophoneIsInitialized() const override; // Speaker volume controls - virtual int32_t SpeakerVolumeIsAvailable(bool* available) OVERRIDE; - virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE; - virtual int32_t SpeakerVolume(uint32_t* volume) const OVERRIDE; - virtual int32_t MaxSpeakerVolume(uint32_t* maxVolume) const OVERRIDE; - virtual int32_t MinSpeakerVolume(uint32_t* minVolume) const OVERRIDE; - virtual int32_t SpeakerVolumeStepSize( - uint16_t* stepSize) const OVERRIDE; + int32_t SpeakerVolumeIsAvailable(bool* available) override; + int32_t SetSpeakerVolume(uint32_t volume) override; + int32_t SpeakerVolume(uint32_t* volume) const override; + int32_t MaxSpeakerVolume(uint32_t* maxVolume) const override; + int32_t MinSpeakerVolume(uint32_t* minVolume) const override; + int32_t SpeakerVolumeStepSize(uint16_t* stepSize) const override; // Microphone volume controls - virtual int32_t MicrophoneVolumeIsAvailable(bool* available) OVERRIDE; - virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE; - virtual int32_t MicrophoneVolume(uint32_t* volume) const OVERRIDE; - virtual int32_t MaxMicrophoneVolume( - uint32_t* maxVolume) const OVERRIDE; - virtual int32_t MinMicrophoneVolume( - uint32_t* minVolume) const OVERRIDE; - virtual int32_t MicrophoneVolumeStepSize( - uint16_t* stepSize) const OVERRIDE; + int32_t MicrophoneVolumeIsAvailable(bool* available) override; + int32_t SetMicrophoneVolume(uint32_t volume) override; + int32_t MicrophoneVolume(uint32_t* volume) const override; + int32_t MaxMicrophoneVolume(uint32_t* maxVolume) const override; + int32_t MinMicrophoneVolume(uint32_t* minVolume) const override; + int32_t MicrophoneVolumeStepSize(uint16_t* stepSize) const override; // Speaker mute control - virtual int32_t SpeakerMuteIsAvailable(bool* available) OVERRIDE; - virtual int32_t SetSpeakerMute(bool enable) OVERRIDE; - virtual int32_t SpeakerMute(bool* enabled) const OVERRIDE; + int32_t SpeakerMuteIsAvailable(bool* available) override; + int32_t SetSpeakerMute(bool enable) override; + int32_t SpeakerMute(bool* enabled) const override; // Microphone mute control - virtual int32_t MicrophoneMuteIsAvailable(bool* available) OVERRIDE; - virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE; - virtual int32_t MicrophoneMute(bool* enabled) const OVERRIDE; + int32_t MicrophoneMuteIsAvailable(bool* available) override; + int32_t SetMicrophoneMute(bool enable) override; + int32_t MicrophoneMute(bool* enabled) const override; // Microphone boost control - virtual int32_t MicrophoneBoostIsAvailable(bool* available) OVERRIDE; - virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE; - virtual int32_t MicrophoneBoost(bool* enabled) const OVERRIDE; + int32_t MicrophoneBoostIsAvailable(bool* available) override; + int32_t SetMicrophoneBoost(bool enable) override; + int32_t MicrophoneBoost(bool* enabled) const override; // Stereo support - virtual int32_t StereoPlayoutIsAvailable(bool* available) const OVERRIDE; - virtual int32_t SetStereoPlayout(bool enable) OVERRIDE; - virtual int32_t StereoPlayout(bool* enabled) const OVERRIDE; - virtual int32_t StereoRecordingIsAvailable(bool* available) const OVERRIDE; - virtual int32_t SetStereoRecording(bool enable) OVERRIDE; - virtual int32_t StereoRecording(bool* enabled) const OVERRIDE; - virtual int32_t SetRecordingChannel(const ChannelType channel) OVERRIDE; - virtual int32_t RecordingChannel(ChannelType* channel) const OVERRIDE; + int32_t StereoPlayoutIsAvailable(bool* available) const override; + int32_t SetStereoPlayout(bool enable) override; + int32_t StereoPlayout(bool* enabled) const override; + int32_t StereoRecordingIsAvailable(bool* available) const override; + int32_t SetStereoRecording(bool enable) override; + int32_t StereoRecording(bool* enabled) const override; + int32_t SetRecordingChannel(const ChannelType channel) override; + int32_t RecordingChannel(ChannelType* channel) const override; // Delay information and control - virtual int32_t SetPlayoutBuffer(const BufferType type, - uint16_t sizeMS = 0) OVERRIDE; - virtual int32_t PlayoutBuffer(BufferType* type, - uint16_t* sizeMS) const OVERRIDE; - virtual int32_t PlayoutDelay(uint16_t* delayMS) const OVERRIDE; - virtual int32_t RecordingDelay(uint16_t* delayMS) const OVERRIDE; + int32_t SetPlayoutBuffer(const BufferType type, + uint16_t sizeMS = 0) override; + int32_t PlayoutBuffer(BufferType* type, uint16_t* sizeMS) const override; + int32_t PlayoutDelay(uint16_t* delayMS) const override; + int32_t RecordingDelay(uint16_t* delayMS) const override; // CPU load - virtual int32_t CPULoad(uint16_t* load) const OVERRIDE; + int32_t CPULoad(uint16_t* load) const override; // Recording of raw PCM data - virtual int32_t StartRawOutputFileRecording( - const char pcmFileNameUTF8[kAdmMaxFileNameSize]) OVERRIDE; - virtual int32_t StopRawOutputFileRecording() OVERRIDE; - virtual int32_t StartRawInputFileRecording( - const char pcmFileNameUTF8[kAdmMaxFileNameSize]) OVERRIDE; - virtual int32_t StopRawInputFileRecording() OVERRIDE; + int32_t StartRawOutputFileRecording( + const char pcmFileNameUTF8[kAdmMaxFileNameSize]) override; + int32_t StopRawOutputFileRecording() override; + int32_t StartRawInputFileRecording( + const char pcmFileNameUTF8[kAdmMaxFileNameSize]) override; + int32_t StopRawInputFileRecording() override; // Native sample rate controls (samples/sec) - virtual int32_t SetRecordingSampleRate( - const uint32_t samplesPerSec) OVERRIDE; - virtual int32_t RecordingSampleRate( - uint32_t* samplesPerSec) const OVERRIDE; - virtual int32_t SetPlayoutSampleRate( - const uint32_t samplesPerSec) OVERRIDE; - virtual int32_t PlayoutSampleRate( - uint32_t* samplesPerSec) const OVERRIDE; + int32_t SetRecordingSampleRate(const uint32_t samplesPerSec) override; + int32_t RecordingSampleRate(uint32_t* samplesPerSec) const override; + int32_t SetPlayoutSampleRate(const uint32_t samplesPerSec) override; + int32_t PlayoutSampleRate(uint32_t* samplesPerSec) const override; // Mobile device specific functions - virtual int32_t ResetAudioDevice() OVERRIDE; - virtual int32_t SetLoudspeakerStatus(bool enable) OVERRIDE; - virtual int32_t GetLoudspeakerStatus(bool* enabled) const OVERRIDE; + int32_t ResetAudioDevice() override; + int32_t SetLoudspeakerStatus(bool enable) override; + int32_t GetLoudspeakerStatus(bool* enabled) const override; - virtual bool BuiltInAECIsAvailable() const OVERRIDE; + bool BuiltInAECIsAvailable() const override; - virtual int32_t EnableBuiltInAEC(bool enable) OVERRIDE; - virtual bool BuiltInAECIsEnabled() const OVERRIDE; + int32_t EnableBuiltInAEC(bool enable) override; + bool BuiltInAECIsEnabled() const override; public: int32_t Id() {return _id;} diff --git a/webrtc/modules/audio_device/dummy/audio_device_dummy.h b/webrtc/modules/audio_device/dummy/audio_device_dummy.h index 41e52e954..75c599e69 100644 --- a/webrtc/modules/audio_device/dummy/audio_device_dummy.h +++ b/webrtc/modules/audio_device/dummy/audio_device_dummy.h @@ -23,124 +23,123 @@ class AudioDeviceDummy : public AudioDeviceGeneric { virtual ~AudioDeviceDummy() {} // Retrieve the currently utilized audio layer - virtual int32_t ActiveAudioLayer( - AudioDeviceModule::AudioLayer& audioLayer) const OVERRIDE; + int32_t ActiveAudioLayer( + AudioDeviceModule::AudioLayer& audioLayer) const override; // Main initializaton and termination - virtual int32_t Init() OVERRIDE; - virtual int32_t Terminate() OVERRIDE; - virtual bool Initialized() const OVERRIDE; + int32_t Init() override; + int32_t Terminate() override; + bool Initialized() const override; // Device enumeration - virtual int16_t PlayoutDevices() OVERRIDE; - virtual int16_t RecordingDevices() OVERRIDE; - virtual int32_t PlayoutDeviceName(uint16_t index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]) OVERRIDE; - virtual int32_t RecordingDeviceName(uint16_t index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]) OVERRIDE; + int16_t PlayoutDevices() override; + int16_t RecordingDevices() override; + int32_t PlayoutDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]) override; + int32_t RecordingDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]) override; // Device selection - virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE; - virtual int32_t SetPlayoutDevice( - AudioDeviceModule::WindowsDeviceType device) OVERRIDE; - virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE; - virtual int32_t SetRecordingDevice( - AudioDeviceModule::WindowsDeviceType device) OVERRIDE; + int32_t SetPlayoutDevice(uint16_t index) override; + int32_t SetPlayoutDevice( + AudioDeviceModule::WindowsDeviceType device) override; + int32_t SetRecordingDevice(uint16_t index) override; + int32_t SetRecordingDevice( + AudioDeviceModule::WindowsDeviceType device) override; // Audio transport initialization - virtual int32_t PlayoutIsAvailable(bool& available) OVERRIDE; - virtual int32_t InitPlayout() OVERRIDE; - virtual bool PlayoutIsInitialized() const OVERRIDE; - virtual int32_t RecordingIsAvailable(bool& available) OVERRIDE; - virtual int32_t InitRecording() OVERRIDE; - virtual bool RecordingIsInitialized() const OVERRIDE; + int32_t PlayoutIsAvailable(bool& available) override; + int32_t InitPlayout() override; + bool PlayoutIsInitialized() const override; + int32_t RecordingIsAvailable(bool& available) override; + int32_t InitRecording() override; + bool RecordingIsInitialized() const override; // Audio transport control - virtual int32_t StartPlayout() OVERRIDE; - virtual int32_t StopPlayout() OVERRIDE; - virtual bool Playing() const OVERRIDE; - virtual int32_t StartRecording() OVERRIDE; - virtual int32_t StopRecording() OVERRIDE; - virtual bool Recording() const OVERRIDE; + int32_t StartPlayout() override; + int32_t StopPlayout() override; + bool Playing() const override; + int32_t StartRecording() override; + int32_t StopRecording() override; + bool Recording() const override; // Microphone Automatic Gain Control (AGC) - virtual int32_t SetAGC(bool enable) OVERRIDE; - virtual bool AGC() const OVERRIDE; + int32_t SetAGC(bool enable) override; + bool AGC() const override; // Volume control based on the Windows Wave API (Windows only) - virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, - uint16_t volumeRight) OVERRIDE; - virtual int32_t WaveOutVolume(uint16_t& volumeLeft, - uint16_t& volumeRight) const OVERRIDE; + int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight) override; + int32_t WaveOutVolume(uint16_t& volumeLeft, + uint16_t& volumeRight) const override; // Audio mixer initialization - virtual int32_t InitSpeaker() OVERRIDE; - virtual bool SpeakerIsInitialized() const OVERRIDE; - virtual int32_t InitMicrophone() OVERRIDE; - virtual bool MicrophoneIsInitialized() const OVERRIDE; + int32_t InitSpeaker() override; + bool SpeakerIsInitialized() const override; + int32_t InitMicrophone() override; + bool MicrophoneIsInitialized() const override; // Speaker volume controls - virtual int32_t SpeakerVolumeIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE; - virtual int32_t SpeakerVolume(uint32_t& volume) const OVERRIDE; - virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const OVERRIDE; - virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const OVERRIDE; - virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const OVERRIDE; + int32_t SpeakerVolumeIsAvailable(bool& available) override; + int32_t SetSpeakerVolume(uint32_t volume) override; + int32_t SpeakerVolume(uint32_t& volume) const override; + int32_t MaxSpeakerVolume(uint32_t& maxVolume) const override; + int32_t MinSpeakerVolume(uint32_t& minVolume) const override; + int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const override; // Microphone volume controls - virtual int32_t MicrophoneVolumeIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE; - virtual int32_t MicrophoneVolume(uint32_t& volume) const OVERRIDE; - virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const OVERRIDE; - virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const OVERRIDE; - virtual int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const OVERRIDE; + int32_t MicrophoneVolumeIsAvailable(bool& available) override; + int32_t SetMicrophoneVolume(uint32_t volume) override; + int32_t MicrophoneVolume(uint32_t& volume) const override; + int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const override; + int32_t MinMicrophoneVolume(uint32_t& minVolume) const override; + int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const override; // Speaker mute control - virtual int32_t SpeakerMuteIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetSpeakerMute(bool enable) OVERRIDE; - virtual int32_t SpeakerMute(bool& enabled) const OVERRIDE; + int32_t SpeakerMuteIsAvailable(bool& available) override; + int32_t SetSpeakerMute(bool enable) override; + int32_t SpeakerMute(bool& enabled) const override; // Microphone mute control - virtual int32_t MicrophoneMuteIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE; - virtual int32_t MicrophoneMute(bool& enabled) const OVERRIDE; + int32_t MicrophoneMuteIsAvailable(bool& available) override; + int32_t SetMicrophoneMute(bool enable) override; + int32_t MicrophoneMute(bool& enabled) const override; // Microphone boost control - virtual int32_t MicrophoneBoostIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE; - virtual int32_t MicrophoneBoost(bool& enabled) const OVERRIDE; + int32_t MicrophoneBoostIsAvailable(bool& available) override; + int32_t SetMicrophoneBoost(bool enable) override; + int32_t MicrophoneBoost(bool& enabled) const override; // Stereo support - virtual int32_t StereoPlayoutIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetStereoPlayout(bool enable) OVERRIDE; - virtual int32_t StereoPlayout(bool& enabled) const OVERRIDE; - virtual int32_t StereoRecordingIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetStereoRecording(bool enable) OVERRIDE; - virtual int32_t StereoRecording(bool& enabled) const OVERRIDE; + int32_t StereoPlayoutIsAvailable(bool& available) override; + int32_t SetStereoPlayout(bool enable) override; + int32_t StereoPlayout(bool& enabled) const override; + int32_t StereoRecordingIsAvailable(bool& available) override; + int32_t SetStereoRecording(bool enable) override; + int32_t StereoRecording(bool& enabled) const override; // Delay information and control - virtual int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, - uint16_t sizeMS) OVERRIDE; - virtual int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, - uint16_t& sizeMS) const OVERRIDE; - virtual int32_t PlayoutDelay(uint16_t& delayMS) const OVERRIDE; - virtual int32_t RecordingDelay(uint16_t& delayMS) const OVERRIDE; + int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, + uint16_t sizeMS) override; + int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, + uint16_t& sizeMS) const override; + int32_t PlayoutDelay(uint16_t& delayMS) const override; + int32_t RecordingDelay(uint16_t& delayMS) const override; // CPU load - virtual int32_t CPULoad(uint16_t& load) const OVERRIDE; + int32_t CPULoad(uint16_t& load) const override; - virtual bool PlayoutWarning() const OVERRIDE; - virtual bool PlayoutError() const OVERRIDE; - virtual bool RecordingWarning() const OVERRIDE; - virtual bool RecordingError() const OVERRIDE; - virtual void ClearPlayoutWarning() OVERRIDE; - virtual void ClearPlayoutError() OVERRIDE; - virtual void ClearRecordingWarning() OVERRIDE; - virtual void ClearRecordingError() OVERRIDE; + bool PlayoutWarning() const override; + bool PlayoutError() const override; + bool RecordingWarning() const override; + bool RecordingError() const override; + void ClearPlayoutWarning() override; + void ClearPlayoutError() override; + void ClearRecordingWarning() override; + void ClearRecordingError() override; - virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) OVERRIDE; + void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) override; }; } // namespace webrtc diff --git a/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h b/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h index e05e30bc3..90aa6c28d 100644 --- a/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h +++ b/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h @@ -24,7 +24,7 @@ public: AudioDeviceUtilityDummy(const int32_t id) {} virtual ~AudioDeviceUtilityDummy() {} - virtual int32_t Init() OVERRIDE; + int32_t Init() override; }; } // namespace webrtc diff --git a/webrtc/modules/audio_device/dummy/file_audio_device.h b/webrtc/modules/audio_device/dummy/file_audio_device.h index 6f417eb2e..14936f522 100644 --- a/webrtc/modules/audio_device/dummy/file_audio_device.h +++ b/webrtc/modules/audio_device/dummy/file_audio_device.h @@ -40,124 +40,123 @@ class FileAudioDevice : public AudioDeviceGeneric { virtual ~FileAudioDevice(); // Retrieve the currently utilized audio layer - virtual int32_t ActiveAudioLayer( - AudioDeviceModule::AudioLayer& audioLayer) const OVERRIDE; + int32_t ActiveAudioLayer( + AudioDeviceModule::AudioLayer& audioLayer) const override; // Main initializaton and termination - virtual int32_t Init() OVERRIDE; - virtual int32_t Terminate() OVERRIDE; - virtual bool Initialized() const OVERRIDE; + int32_t Init() override; + int32_t Terminate() override; + bool Initialized() const override; // Device enumeration - virtual int16_t PlayoutDevices() OVERRIDE; - virtual int16_t RecordingDevices() OVERRIDE; - virtual int32_t PlayoutDeviceName(uint16_t index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]) OVERRIDE; - virtual int32_t RecordingDeviceName(uint16_t index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]) OVERRIDE; + int16_t PlayoutDevices() override; + int16_t RecordingDevices() override; + int32_t PlayoutDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]) override; + int32_t RecordingDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]) override; // Device selection - virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE; - virtual int32_t SetPlayoutDevice( - AudioDeviceModule::WindowsDeviceType device) OVERRIDE; - virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE; - virtual int32_t SetRecordingDevice( - AudioDeviceModule::WindowsDeviceType device) OVERRIDE; + int32_t SetPlayoutDevice(uint16_t index) override; + int32_t SetPlayoutDevice( + AudioDeviceModule::WindowsDeviceType device) override; + int32_t SetRecordingDevice(uint16_t index) override; + int32_t SetRecordingDevice( + AudioDeviceModule::WindowsDeviceType device) override; // Audio transport initialization - virtual int32_t PlayoutIsAvailable(bool& available) OVERRIDE; - virtual int32_t InitPlayout() OVERRIDE; - virtual bool PlayoutIsInitialized() const OVERRIDE; - virtual int32_t RecordingIsAvailable(bool& available) OVERRIDE; - virtual int32_t InitRecording() OVERRIDE; - virtual bool RecordingIsInitialized() const OVERRIDE; + int32_t PlayoutIsAvailable(bool& available) override; + int32_t InitPlayout() override; + bool PlayoutIsInitialized() const override; + int32_t RecordingIsAvailable(bool& available) override; + int32_t InitRecording() override; + bool RecordingIsInitialized() const override; // Audio transport control - virtual int32_t StartPlayout() OVERRIDE; - virtual int32_t StopPlayout() OVERRIDE; - virtual bool Playing() const OVERRIDE; - virtual int32_t StartRecording() OVERRIDE; - virtual int32_t StopRecording() OVERRIDE; - virtual bool Recording() const OVERRIDE; + int32_t StartPlayout() override; + int32_t StopPlayout() override; + bool Playing() const override; + int32_t StartRecording() override; + int32_t StopRecording() override; + bool Recording() const override; // Microphone Automatic Gain Control (AGC) - virtual int32_t SetAGC(bool enable) OVERRIDE; - virtual bool AGC() const OVERRIDE; + int32_t SetAGC(bool enable) override; + bool AGC() const override; // Volume control based on the Windows Wave API (Windows only) - virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, - uint16_t volumeRight) OVERRIDE; - virtual int32_t WaveOutVolume(uint16_t& volumeLeft, - uint16_t& volumeRight) const OVERRIDE; + int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight) override; + int32_t WaveOutVolume(uint16_t& volumeLeft, + uint16_t& volumeRight) const override; // Audio mixer initialization - virtual int32_t InitSpeaker() OVERRIDE; - virtual bool SpeakerIsInitialized() const OVERRIDE; - virtual int32_t InitMicrophone() OVERRIDE; - virtual bool MicrophoneIsInitialized() const OVERRIDE; + int32_t InitSpeaker() override; + bool SpeakerIsInitialized() const override; + int32_t InitMicrophone() override; + bool MicrophoneIsInitialized() const override; // Speaker volume controls - virtual int32_t SpeakerVolumeIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE; - virtual int32_t SpeakerVolume(uint32_t& volume) const OVERRIDE; - virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const OVERRIDE; - virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const OVERRIDE; - virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const OVERRIDE; + int32_t SpeakerVolumeIsAvailable(bool& available) override; + int32_t SetSpeakerVolume(uint32_t volume) override; + int32_t SpeakerVolume(uint32_t& volume) const override; + int32_t MaxSpeakerVolume(uint32_t& maxVolume) const override; + int32_t MinSpeakerVolume(uint32_t& minVolume) const override; + int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const override; // Microphone volume controls - virtual int32_t MicrophoneVolumeIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE; - virtual int32_t MicrophoneVolume(uint32_t& volume) const OVERRIDE; - virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const OVERRIDE; - virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const OVERRIDE; - virtual int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const OVERRIDE; + int32_t MicrophoneVolumeIsAvailable(bool& available) override; + int32_t SetMicrophoneVolume(uint32_t volume) override; + int32_t MicrophoneVolume(uint32_t& volume) const override; + int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const override; + int32_t MinMicrophoneVolume(uint32_t& minVolume) const override; + int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const override; // Speaker mute control - virtual int32_t SpeakerMuteIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetSpeakerMute(bool enable) OVERRIDE; - virtual int32_t SpeakerMute(bool& enabled) const OVERRIDE; + int32_t SpeakerMuteIsAvailable(bool& available) override; + int32_t SetSpeakerMute(bool enable) override; + int32_t SpeakerMute(bool& enabled) const override; // Microphone mute control - virtual int32_t MicrophoneMuteIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE; - virtual int32_t MicrophoneMute(bool& enabled) const OVERRIDE; + int32_t MicrophoneMuteIsAvailable(bool& available) override; + int32_t SetMicrophoneMute(bool enable) override; + int32_t MicrophoneMute(bool& enabled) const override; // Microphone boost control - virtual int32_t MicrophoneBoostIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE; - virtual int32_t MicrophoneBoost(bool& enabled) const OVERRIDE; + int32_t MicrophoneBoostIsAvailable(bool& available) override; + int32_t SetMicrophoneBoost(bool enable) override; + int32_t MicrophoneBoost(bool& enabled) const override; // Stereo support - virtual int32_t StereoPlayoutIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetStereoPlayout(bool enable) OVERRIDE; - virtual int32_t StereoPlayout(bool& enabled) const OVERRIDE; - virtual int32_t StereoRecordingIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetStereoRecording(bool enable) OVERRIDE; - virtual int32_t StereoRecording(bool& enabled) const OVERRIDE; + int32_t StereoPlayoutIsAvailable(bool& available) override; + int32_t SetStereoPlayout(bool enable) override; + int32_t StereoPlayout(bool& enabled) const override; + int32_t StereoRecordingIsAvailable(bool& available) override; + int32_t SetStereoRecording(bool enable) override; + int32_t StereoRecording(bool& enabled) const override; // Delay information and control - virtual int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, - uint16_t sizeMS) OVERRIDE; - virtual int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, - uint16_t& sizeMS) const OVERRIDE; - virtual int32_t PlayoutDelay(uint16_t& delayMS) const OVERRIDE; - virtual int32_t RecordingDelay(uint16_t& delayMS) const OVERRIDE; + int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, + uint16_t sizeMS) override; + int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, + uint16_t& sizeMS) const override; + int32_t PlayoutDelay(uint16_t& delayMS) const override; + int32_t RecordingDelay(uint16_t& delayMS) const override; // CPU load - virtual int32_t CPULoad(uint16_t& load) const OVERRIDE; + int32_t CPULoad(uint16_t& load) const override; - virtual bool PlayoutWarning() const OVERRIDE; - virtual bool PlayoutError() const OVERRIDE; - virtual bool RecordingWarning() const OVERRIDE; - virtual bool RecordingError() const OVERRIDE; - virtual void ClearPlayoutWarning() OVERRIDE; - virtual void ClearPlayoutError() OVERRIDE; - virtual void ClearRecordingWarning() OVERRIDE; - virtual void ClearRecordingError() OVERRIDE; + bool PlayoutWarning() const override; + bool PlayoutError() const override; + bool RecordingWarning() const override; + bool RecordingError() const override; + void ClearPlayoutWarning() override; + void ClearPlayoutError() override; + void ClearRecordingWarning() override; + void ClearRecordingError() override; - virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) OVERRIDE; + void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) override; private: static bool RecThreadFunc(void*); diff --git a/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h b/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h index 1d75c8e94..d5be88cf1 100644 --- a/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h +++ b/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h @@ -35,131 +35,126 @@ public: virtual ~AudioDeviceLinuxALSA(); // Retrieve the currently utilized audio layer - virtual int32_t ActiveAudioLayer( - AudioDeviceModule::AudioLayer& audioLayer) const OVERRIDE; + int32_t ActiveAudioLayer( + AudioDeviceModule::AudioLayer& audioLayer) const override; // Main initializaton and termination - virtual int32_t Init() OVERRIDE; - virtual int32_t Terminate() OVERRIDE; - virtual bool Initialized() const OVERRIDE; + int32_t Init() override; + int32_t Terminate() override; + bool Initialized() const override; // Device enumeration - virtual int16_t PlayoutDevices() OVERRIDE; - virtual int16_t RecordingDevices() OVERRIDE; - virtual int32_t PlayoutDeviceName( - uint16_t index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]) OVERRIDE; - virtual int32_t RecordingDeviceName( - uint16_t index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]) OVERRIDE; + int16_t PlayoutDevices() override; + int16_t RecordingDevices() override; + int32_t PlayoutDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]) override; + int32_t RecordingDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]) override; // Device selection - virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE; - virtual int32_t SetPlayoutDevice( - AudioDeviceModule::WindowsDeviceType device) OVERRIDE; - virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE; - virtual int32_t SetRecordingDevice( - AudioDeviceModule::WindowsDeviceType device) OVERRIDE; + int32_t SetPlayoutDevice(uint16_t index) override; + int32_t SetPlayoutDevice( + AudioDeviceModule::WindowsDeviceType device) override; + int32_t SetRecordingDevice(uint16_t index) override; + int32_t SetRecordingDevice( + AudioDeviceModule::WindowsDeviceType device) override; // Audio transport initialization - virtual int32_t PlayoutIsAvailable(bool& available) OVERRIDE; - virtual int32_t InitPlayout() OVERRIDE; - virtual bool PlayoutIsInitialized() const OVERRIDE; - virtual int32_t RecordingIsAvailable(bool& available) OVERRIDE; - virtual int32_t InitRecording() OVERRIDE; - virtual bool RecordingIsInitialized() const OVERRIDE; + int32_t PlayoutIsAvailable(bool& available) override; + int32_t InitPlayout() override; + bool PlayoutIsInitialized() const override; + int32_t RecordingIsAvailable(bool& available) override; + int32_t InitRecording() override; + bool RecordingIsInitialized() const override; // Audio transport control - virtual int32_t StartPlayout() OVERRIDE; - virtual int32_t StopPlayout() OVERRIDE; - virtual bool Playing() const OVERRIDE; - virtual int32_t StartRecording() OVERRIDE; - virtual int32_t StopRecording() OVERRIDE; - virtual bool Recording() const OVERRIDE; + int32_t StartPlayout() override; + int32_t StopPlayout() override; + bool Playing() const override; + int32_t StartRecording() override; + int32_t StopRecording() override; + bool Recording() const override; // Microphone Automatic Gain Control (AGC) - virtual int32_t SetAGC(bool enable) OVERRIDE; - virtual bool AGC() const OVERRIDE; + int32_t SetAGC(bool enable) override; + bool AGC() const override; // Volume control based on the Windows Wave API (Windows only) - virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, - uint16_t volumeRight) OVERRIDE; - virtual int32_t WaveOutVolume(uint16_t& volumeLeft, - uint16_t& volumeRight) const OVERRIDE; + int32_t SetWaveOutVolume(uint16_t volumeLeft, + uint16_t volumeRight) override; + int32_t WaveOutVolume(uint16_t& volumeLeft, + uint16_t& volumeRight) const override; // Audio mixer initialization - virtual int32_t InitSpeaker() OVERRIDE; - virtual bool SpeakerIsInitialized() const OVERRIDE; - virtual int32_t InitMicrophone() OVERRIDE; - virtual bool MicrophoneIsInitialized() const OVERRIDE; + int32_t InitSpeaker() override; + bool SpeakerIsInitialized() const override; + int32_t InitMicrophone() override; + bool MicrophoneIsInitialized() const override; // Speaker volume controls - virtual int32_t SpeakerVolumeIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE; - virtual int32_t SpeakerVolume(uint32_t& volume) const OVERRIDE; - virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const OVERRIDE; - virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const OVERRIDE; - virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const OVERRIDE; + int32_t SpeakerVolumeIsAvailable(bool& available) override; + int32_t SetSpeakerVolume(uint32_t volume) override; + int32_t SpeakerVolume(uint32_t& volume) const override; + int32_t MaxSpeakerVolume(uint32_t& maxVolume) const override; + int32_t MinSpeakerVolume(uint32_t& minVolume) const override; + int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const override; // Microphone volume controls - virtual int32_t MicrophoneVolumeIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE; - virtual int32_t MicrophoneVolume(uint32_t& volume) const OVERRIDE; - virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const OVERRIDE; - virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const OVERRIDE; - virtual int32_t MicrophoneVolumeStepSize( - uint16_t& stepSize) const OVERRIDE; + int32_t MicrophoneVolumeIsAvailable(bool& available) override; + int32_t SetMicrophoneVolume(uint32_t volume) override; + int32_t MicrophoneVolume(uint32_t& volume) const override; + int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const override; + int32_t MinMicrophoneVolume(uint32_t& minVolume) const override; + int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const override; // Speaker mute control - virtual int32_t SpeakerMuteIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetSpeakerMute(bool enable) OVERRIDE; - virtual int32_t SpeakerMute(bool& enabled) const OVERRIDE; + int32_t SpeakerMuteIsAvailable(bool& available) override; + int32_t SetSpeakerMute(bool enable) override; + int32_t SpeakerMute(bool& enabled) const override; // Microphone mute control - virtual int32_t MicrophoneMuteIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE; - virtual int32_t MicrophoneMute(bool& enabled) const OVERRIDE; + int32_t MicrophoneMuteIsAvailable(bool& available) override; + int32_t SetMicrophoneMute(bool enable) override; + int32_t MicrophoneMute(bool& enabled) const override; // Microphone boost control - virtual int32_t MicrophoneBoostIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE; - virtual int32_t MicrophoneBoost(bool& enabled) const OVERRIDE; + int32_t MicrophoneBoostIsAvailable(bool& available) override; + int32_t SetMicrophoneBoost(bool enable) override; + int32_t MicrophoneBoost(bool& enabled) const override; // Stereo support - virtual int32_t StereoPlayoutIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetStereoPlayout(bool enable) OVERRIDE; - virtual int32_t StereoPlayout(bool& enabled) const OVERRIDE; - virtual int32_t StereoRecordingIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetStereoRecording(bool enable) OVERRIDE; - virtual int32_t StereoRecording(bool& enabled) const OVERRIDE; + int32_t StereoPlayoutIsAvailable(bool& available) override; + int32_t SetStereoPlayout(bool enable) override; + int32_t StereoPlayout(bool& enabled) const override; + int32_t StereoRecordingIsAvailable(bool& available) override; + int32_t SetStereoRecording(bool enable) override; + int32_t StereoRecording(bool& enabled) const override; // Delay information and control - virtual int32_t SetPlayoutBuffer( - const AudioDeviceModule::BufferType type, - uint16_t sizeMS) OVERRIDE; - virtual int32_t PlayoutBuffer( - AudioDeviceModule::BufferType& type, - uint16_t& sizeMS) const OVERRIDE; - virtual int32_t PlayoutDelay(uint16_t& delayMS) const OVERRIDE; - virtual int32_t RecordingDelay(uint16_t& delayMS) const OVERRIDE; + int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, + uint16_t sizeMS) override; + int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, + uint16_t& sizeMS) const override; + int32_t PlayoutDelay(uint16_t& delayMS) const override; + int32_t RecordingDelay(uint16_t& delayMS) const override; // CPU load - virtual int32_t CPULoad(uint16_t& load) const OVERRIDE; + int32_t CPULoad(uint16_t& load) const override; public: - virtual bool PlayoutWarning() const OVERRIDE; - virtual bool PlayoutError() const OVERRIDE; - virtual bool RecordingWarning() const OVERRIDE; - virtual bool RecordingError() const OVERRIDE; - virtual void ClearPlayoutWarning() OVERRIDE; - virtual void ClearPlayoutError() OVERRIDE; - virtual void ClearRecordingWarning() OVERRIDE; - virtual void ClearRecordingError() OVERRIDE; + bool PlayoutWarning() const override; + bool PlayoutError() const override; + bool RecordingWarning() const override; + bool RecordingError() const override; + void ClearPlayoutWarning() override; + void ClearPlayoutError() override; + void ClearRecordingWarning() override; + void ClearRecordingError() override; public: - virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) OVERRIDE; + void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) override; private: int32_t GetDevicesInfo(const int32_t function, diff --git a/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h b/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h index cde7e4643..1644df90b 100644 --- a/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h +++ b/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h @@ -96,130 +96,126 @@ public: virtual ~AudioDeviceLinuxPulse(); // Retrieve the currently utilized audio layer - virtual int32_t ActiveAudioLayer( - AudioDeviceModule::AudioLayer& audioLayer) const OVERRIDE; + int32_t ActiveAudioLayer( + AudioDeviceModule::AudioLayer& audioLayer) const override; // Main initializaton and termination - virtual int32_t Init() OVERRIDE; - virtual int32_t Terminate() OVERRIDE; - virtual bool Initialized() const OVERRIDE; + int32_t Init() override; + int32_t Terminate() override; + bool Initialized() const override; // Device enumeration - virtual int16_t PlayoutDevices() OVERRIDE; - virtual int16_t RecordingDevices() OVERRIDE; - virtual int32_t PlayoutDeviceName( - uint16_t index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]) OVERRIDE; - virtual int32_t RecordingDeviceName( - uint16_t index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]) OVERRIDE; + int16_t PlayoutDevices() override; + int16_t RecordingDevices() override; + int32_t PlayoutDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]) override; + int32_t RecordingDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]) override; // Device selection - virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE; - virtual int32_t SetPlayoutDevice( - AudioDeviceModule::WindowsDeviceType device) OVERRIDE; - virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE; - virtual int32_t SetRecordingDevice( - AudioDeviceModule::WindowsDeviceType device) OVERRIDE; + int32_t SetPlayoutDevice(uint16_t index) override; + int32_t SetPlayoutDevice( + AudioDeviceModule::WindowsDeviceType device) override; + int32_t SetRecordingDevice(uint16_t index) override; + int32_t SetRecordingDevice( + AudioDeviceModule::WindowsDeviceType device) override; // Audio transport initialization - virtual int32_t PlayoutIsAvailable(bool& available) OVERRIDE; - virtual int32_t InitPlayout() OVERRIDE; - virtual bool PlayoutIsInitialized() const OVERRIDE; - virtual int32_t RecordingIsAvailable(bool& available) OVERRIDE; - virtual int32_t InitRecording() OVERRIDE; - virtual bool RecordingIsInitialized() const OVERRIDE; + int32_t PlayoutIsAvailable(bool& available) override; + int32_t InitPlayout() override; + bool PlayoutIsInitialized() const override; + int32_t RecordingIsAvailable(bool& available) override; + int32_t InitRecording() override; + bool RecordingIsInitialized() const override; // Audio transport control - virtual int32_t StartPlayout() OVERRIDE; - virtual int32_t StopPlayout() OVERRIDE; - virtual bool Playing() const OVERRIDE; - virtual int32_t StartRecording() OVERRIDE; - virtual int32_t StopRecording() OVERRIDE; - virtual bool Recording() const OVERRIDE; + int32_t StartPlayout() override; + int32_t StopPlayout() override; + bool Playing() const override; + int32_t StartRecording() override; + int32_t StopRecording() override; + bool Recording() const override; // Microphone Automatic Gain Control (AGC) - virtual int32_t SetAGC(bool enable) OVERRIDE; - virtual bool AGC() const OVERRIDE; + int32_t SetAGC(bool enable) override; + bool AGC() const override; // Volume control based on the Windows Wave API (Windows only) - virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, - uint16_t volumeRight) OVERRIDE; - virtual int32_t WaveOutVolume(uint16_t& volumeLeft, - uint16_t& volumeRight) const OVERRIDE; + int32_t SetWaveOutVolume(uint16_t volumeLeft, + uint16_t volumeRight) override; + int32_t WaveOutVolume(uint16_t& volumeLeft, + uint16_t& volumeRight) const override; // Audio mixer initialization - virtual int32_t InitSpeaker() OVERRIDE; - virtual bool SpeakerIsInitialized() const OVERRIDE; - virtual int32_t InitMicrophone() OVERRIDE; - virtual bool MicrophoneIsInitialized() const OVERRIDE; + int32_t InitSpeaker() override; + bool SpeakerIsInitialized() const override; + int32_t InitMicrophone() override; + bool MicrophoneIsInitialized() const override; // Speaker volume controls - virtual int32_t SpeakerVolumeIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE; - virtual int32_t SpeakerVolume(uint32_t& volume) const OVERRIDE; - virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const OVERRIDE; - virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const OVERRIDE; - virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const OVERRIDE; + int32_t SpeakerVolumeIsAvailable(bool& available) override; + int32_t SetSpeakerVolume(uint32_t volume) override; + int32_t SpeakerVolume(uint32_t& volume) const override; + int32_t MaxSpeakerVolume(uint32_t& maxVolume) const override; + int32_t MinSpeakerVolume(uint32_t& minVolume) const override; + int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const override; // Microphone volume controls - virtual int32_t MicrophoneVolumeIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE; - virtual int32_t MicrophoneVolume(uint32_t& volume) const OVERRIDE; - virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const OVERRIDE; - virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const OVERRIDE; - virtual int32_t MicrophoneVolumeStepSize( - uint16_t& stepSize) const OVERRIDE; + int32_t MicrophoneVolumeIsAvailable(bool& available) override; + int32_t SetMicrophoneVolume(uint32_t volume) override; + int32_t MicrophoneVolume(uint32_t& volume) const override; + int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const override; + int32_t MinMicrophoneVolume(uint32_t& minVolume) const override; + int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const override; // Speaker mute control - virtual int32_t SpeakerMuteIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetSpeakerMute(bool enable) OVERRIDE; - virtual int32_t SpeakerMute(bool& enabled) const OVERRIDE; + int32_t SpeakerMuteIsAvailable(bool& available) override; + int32_t SetSpeakerMute(bool enable) override; + int32_t SpeakerMute(bool& enabled) const override; // Microphone mute control - virtual int32_t MicrophoneMuteIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE; - virtual int32_t MicrophoneMute(bool& enabled) const OVERRIDE; + int32_t MicrophoneMuteIsAvailable(bool& available) override; + int32_t SetMicrophoneMute(bool enable) override; + int32_t MicrophoneMute(bool& enabled) const override; // Microphone boost control - virtual int32_t MicrophoneBoostIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE; - virtual int32_t MicrophoneBoost(bool& enabled) const OVERRIDE; + int32_t MicrophoneBoostIsAvailable(bool& available) override; + int32_t SetMicrophoneBoost(bool enable) override; + int32_t MicrophoneBoost(bool& enabled) const override; // Stereo support - virtual int32_t StereoPlayoutIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetStereoPlayout(bool enable) OVERRIDE; - virtual int32_t StereoPlayout(bool& enabled) const OVERRIDE; - virtual int32_t StereoRecordingIsAvailable(bool& available) OVERRIDE; - virtual int32_t SetStereoRecording(bool enable) OVERRIDE; - virtual int32_t StereoRecording(bool& enabled) const OVERRIDE; + int32_t StereoPlayoutIsAvailable(bool& available) override; + int32_t SetStereoPlayout(bool enable) override; + int32_t StereoPlayout(bool& enabled) const override; + int32_t StereoRecordingIsAvailable(bool& available) override; + int32_t SetStereoRecording(bool enable) override; + int32_t StereoRecording(bool& enabled) const override; // Delay information and control - virtual int32_t - SetPlayoutBuffer(const AudioDeviceModule::BufferType type, - uint16_t sizeMS) OVERRIDE; - virtual int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, - uint16_t& sizeMS) const OVERRIDE; - virtual int32_t PlayoutDelay(uint16_t& delayMS) const OVERRIDE; - virtual int32_t RecordingDelay(uint16_t& delayMS) const OVERRIDE; + int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, + uint16_t sizeMS) override; + int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, + uint16_t& sizeMS) const override; + int32_t PlayoutDelay(uint16_t& delayMS) const override; + int32_t RecordingDelay(uint16_t& delayMS) const override; // CPU load - virtual int32_t CPULoad(uint16_t& load) const OVERRIDE; + int32_t CPULoad(uint16_t& load) const override; public: - virtual bool PlayoutWarning() const OVERRIDE; - virtual bool PlayoutError() const OVERRIDE; - virtual bool RecordingWarning() const OVERRIDE; - virtual bool RecordingError() const OVERRIDE; - virtual void ClearPlayoutWarning() OVERRIDE; - virtual void ClearPlayoutError() OVERRIDE; - virtual void ClearRecordingWarning() OVERRIDE; - virtual void ClearRecordingError() OVERRIDE; + bool PlayoutWarning() const override; + bool PlayoutError() const override; + bool RecordingWarning() const override; + bool RecordingError() const override; + void ClearPlayoutWarning() override; + void ClearPlayoutError() override; + void ClearRecordingWarning() override; + void ClearRecordingError() override; public: - virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) OVERRIDE; + void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) override; private: void Lock() EXCLUSIVE_LOCK_FUNCTION(_critSect) { diff --git a/webrtc/modules/audio_device/linux/audio_device_utility_linux.h b/webrtc/modules/audio_device/linux/audio_device_utility_linux.h index 0dc264665..f29e211ac 100644 --- a/webrtc/modules/audio_device/linux/audio_device_utility_linux.h +++ b/webrtc/modules/audio_device/linux/audio_device_utility_linux.h @@ -24,7 +24,7 @@ public: AudioDeviceUtilityLinux(const int32_t id); virtual ~AudioDeviceUtilityLinux(); - virtual int32_t Init() OVERRIDE; + int32_t Init() override; private: CriticalSectionWrapper& _critSect; diff --git a/webrtc/modules/audio_processing/audio_processing_impl.cc b/webrtc/modules/audio_processing/audio_processing_impl.cc index 5029bc712..200aa8bd0 100644 --- a/webrtc/modules/audio_processing/audio_processing_impl.cc +++ b/webrtc/modules/audio_processing/audio_processing_impl.cc @@ -75,60 +75,49 @@ class GainControlForNewAgc : public GainControl, public VolumeCallbacks { } // GainControl implementation. - virtual int Enable(bool enable) OVERRIDE { + int Enable(bool enable) override { return real_gain_control_->Enable(enable); } - virtual bool is_enabled() const OVERRIDE { - return real_gain_control_->is_enabled(); - } - virtual int set_stream_analog_level(int level) OVERRIDE { + bool is_enabled() const override { return real_gain_control_->is_enabled(); } + int set_stream_analog_level(int level) override { volume_ = level; return AudioProcessing::kNoError; } - virtual int stream_analog_level() OVERRIDE { - return volume_; - } - virtual int set_mode(Mode mode) OVERRIDE { return AudioProcessing::kNoError; } - virtual Mode mode() const OVERRIDE { return GainControl::kAdaptiveAnalog; } - virtual int set_target_level_dbfs(int level) OVERRIDE { + int stream_analog_level() override { return volume_; } + int set_mode(Mode mode) override { return AudioProcessing::kNoError; } + Mode mode() const override { return GainControl::kAdaptiveAnalog; } + int set_target_level_dbfs(int level) override { return AudioProcessing::kNoError; } - virtual int target_level_dbfs() const OVERRIDE { + int target_level_dbfs() const override { return real_gain_control_->target_level_dbfs(); } - virtual int set_compression_gain_db(int gain) OVERRIDE { + int set_compression_gain_db(int gain) override { return AudioProcessing::kNoError; } - virtual int compression_gain_db() const OVERRIDE { + int compression_gain_db() const override { return real_gain_control_->compression_gain_db(); } - virtual int enable_limiter(bool enable) OVERRIDE { - return AudioProcessing::kNoError; - } - virtual bool is_limiter_enabled() const OVERRIDE { + int enable_limiter(bool enable) override { return AudioProcessing::kNoError; } + bool is_limiter_enabled() const override { return real_gain_control_->is_limiter_enabled(); } - virtual int set_analog_level_limits(int minimum, - int maximum) OVERRIDE { + int set_analog_level_limits(int minimum, int maximum) override { return AudioProcessing::kNoError; } - virtual int analog_level_minimum() const OVERRIDE { + int analog_level_minimum() const override { return real_gain_control_->analog_level_minimum(); } - virtual int analog_level_maximum() const OVERRIDE { + int analog_level_maximum() const override { return real_gain_control_->analog_level_maximum(); } - virtual bool stream_is_saturated() const OVERRIDE { + bool stream_is_saturated() const override { return real_gain_control_->stream_is_saturated(); } // VolumeCallbacks implementation. - virtual void SetMicVolume(int volume) OVERRIDE { - volume_ = volume; - } - virtual int GetMicVolume() OVERRIDE { - return volume_; - } + void SetMicVolume(int volume) override { volume_ = volume; } + int GetMicVolume() override { return volume_; } private: GainControl* real_gain_control_; diff --git a/webrtc/modules/audio_processing/audio_processing_impl.h b/webrtc/modules/audio_processing/audio_processing_impl.h index d82ef020b..68abdf646 100644 --- a/webrtc/modules/audio_processing/audio_processing_impl.h +++ b/webrtc/modules/audio_processing/audio_processing_impl.h @@ -91,57 +91,55 @@ class AudioProcessingImpl : public AudioProcessing { virtual ~AudioProcessingImpl(); // AudioProcessing methods. - virtual int Initialize() OVERRIDE; - virtual int Initialize(int input_sample_rate_hz, - int output_sample_rate_hz, - int reverse_sample_rate_hz, - ChannelLayout input_layout, - ChannelLayout output_layout, - ChannelLayout reverse_layout) OVERRIDE; - virtual void SetExtraOptions(const Config& config) OVERRIDE; - virtual int set_sample_rate_hz(int rate) OVERRIDE; - virtual int input_sample_rate_hz() const OVERRIDE; - virtual int sample_rate_hz() const OVERRIDE; - virtual int proc_sample_rate_hz() const OVERRIDE; - virtual int proc_split_sample_rate_hz() const OVERRIDE; - virtual int num_input_channels() const OVERRIDE; - virtual int num_output_channels() const OVERRIDE; - virtual int num_reverse_channels() const OVERRIDE; - virtual void set_output_will_be_muted(bool muted) OVERRIDE; - virtual bool output_will_be_muted() const OVERRIDE; - virtual int ProcessStream(AudioFrame* frame) OVERRIDE; - virtual int ProcessStream(const float* const* src, - int samples_per_channel, - int input_sample_rate_hz, - ChannelLayout input_layout, - int output_sample_rate_hz, - ChannelLayout output_layout, - float* const* dest) OVERRIDE; - virtual int AnalyzeReverseStream(AudioFrame* frame) OVERRIDE; - virtual int AnalyzeReverseStream(const float* const* data, - int samples_per_channel, - int sample_rate_hz, - ChannelLayout layout) OVERRIDE; - virtual int set_stream_delay_ms(int delay) OVERRIDE; - virtual int stream_delay_ms() const OVERRIDE; - virtual bool was_stream_delay_set() const OVERRIDE; - virtual void set_delay_offset_ms(int offset) OVERRIDE; - virtual int delay_offset_ms() const OVERRIDE; - virtual void set_stream_key_pressed(bool key_pressed) OVERRIDE; - virtual bool stream_key_pressed() const OVERRIDE; - virtual int StartDebugRecording( - const char filename[kMaxFilenameSize]) OVERRIDE; - virtual int StartDebugRecording(FILE* handle) OVERRIDE; - virtual int StartDebugRecordingForPlatformFile( - rtc::PlatformFile handle) OVERRIDE; - virtual int StopDebugRecording() OVERRIDE; - virtual EchoCancellation* echo_cancellation() const OVERRIDE; - virtual EchoControlMobile* echo_control_mobile() const OVERRIDE; - virtual GainControl* gain_control() const OVERRIDE; - virtual HighPassFilter* high_pass_filter() const OVERRIDE; - virtual LevelEstimator* level_estimator() const OVERRIDE; - virtual NoiseSuppression* noise_suppression() const OVERRIDE; - virtual VoiceDetection* voice_detection() const OVERRIDE; + int Initialize() override; + int Initialize(int input_sample_rate_hz, + int output_sample_rate_hz, + int reverse_sample_rate_hz, + ChannelLayout input_layout, + ChannelLayout output_layout, + ChannelLayout reverse_layout) override; + void SetExtraOptions(const Config& config) override; + int set_sample_rate_hz(int rate) override; + int input_sample_rate_hz() const override; + int sample_rate_hz() const override; + int proc_sample_rate_hz() const override; + int proc_split_sample_rate_hz() const override; + int num_input_channels() const override; + int num_output_channels() const override; + int num_reverse_channels() const override; + void set_output_will_be_muted(bool muted) override; + bool output_will_be_muted() const override; + int ProcessStream(AudioFrame* frame) override; + int ProcessStream(const float* const* src, + int samples_per_channel, + int input_sample_rate_hz, + ChannelLayout input_layout, + int output_sample_rate_hz, + ChannelLayout output_layout, + float* const* dest) override; + int AnalyzeReverseStream(AudioFrame* frame) override; + int AnalyzeReverseStream(const float* const* data, + int samples_per_channel, + int sample_rate_hz, + ChannelLayout layout) override; + int set_stream_delay_ms(int delay) override; + int stream_delay_ms() const override; + bool was_stream_delay_set() const override; + void set_delay_offset_ms(int offset) override; + int delay_offset_ms() const override; + void set_stream_key_pressed(bool key_pressed) override; + bool stream_key_pressed() const override; + int StartDebugRecording(const char filename[kMaxFilenameSize]) override; + int StartDebugRecording(FILE* handle) override; + int StartDebugRecordingForPlatformFile(rtc::PlatformFile handle) override; + int StopDebugRecording() override; + EchoCancellation* echo_cancellation() const override; + EchoControlMobile* echo_control_mobile() const override; + GainControl* gain_control() const override; + HighPassFilter* high_pass_filter() const override; + LevelEstimator* level_estimator() const override; + NoiseSuppression* noise_suppression() const override; + VoiceDetection* voice_detection() const override; protected: // Overridden in a mock. diff --git a/webrtc/modules/audio_processing/echo_cancellation_impl.h b/webrtc/modules/audio_processing/echo_cancellation_impl.h index 454593895..ed3d7b509 100644 --- a/webrtc/modules/audio_processing/echo_cancellation_impl.h +++ b/webrtc/modules/audio_processing/echo_cancellation_impl.h @@ -30,39 +30,40 @@ class EchoCancellationImpl : public EchoCancellation, int ProcessCaptureAudio(AudioBuffer* audio); // EchoCancellation implementation. - virtual bool is_enabled() const OVERRIDE; - virtual int stream_drift_samples() const OVERRIDE; + bool is_enabled() const override; + int stream_drift_samples() const override; // ProcessingComponent implementation. - virtual int Initialize() OVERRIDE; - virtual void SetExtraOptions(const Config& config) OVERRIDE; + int Initialize() override; + void SetExtraOptions(const Config& config) override; private: // EchoCancellation implementation. - virtual int Enable(bool enable) OVERRIDE; - virtual int enable_drift_compensation(bool enable) OVERRIDE; - virtual bool is_drift_compensation_enabled() const OVERRIDE; - virtual void set_stream_drift_samples(int drift) OVERRIDE; - virtual int set_suppression_level(SuppressionLevel level) OVERRIDE; - virtual SuppressionLevel suppression_level() const OVERRIDE; - virtual int enable_metrics(bool enable) OVERRIDE; - virtual bool are_metrics_enabled() const OVERRIDE; - virtual bool stream_has_echo() const OVERRIDE; - virtual int GetMetrics(Metrics* metrics) OVERRIDE; - virtual int enable_delay_logging(bool enable) OVERRIDE; - virtual bool is_delay_logging_enabled() const OVERRIDE; - virtual int GetDelayMetrics(int* median, int* std) OVERRIDE; - virtual int GetDelayMetrics(int* median, int* std, - float* fraction_poor_delays) OVERRIDE; - virtual struct AecCore* aec_core() const OVERRIDE; + int Enable(bool enable) override; + int enable_drift_compensation(bool enable) override; + bool is_drift_compensation_enabled() const override; + void set_stream_drift_samples(int drift) override; + int set_suppression_level(SuppressionLevel level) override; + SuppressionLevel suppression_level() const override; + int enable_metrics(bool enable) override; + bool are_metrics_enabled() const override; + bool stream_has_echo() const override; + int GetMetrics(Metrics* metrics) override; + int enable_delay_logging(bool enable) override; + bool is_delay_logging_enabled() const override; + int GetDelayMetrics(int* median, int* std) override; + int GetDelayMetrics(int* median, + int* std, + float* fraction_poor_delays) override; + struct AecCore* aec_core() const override; // ProcessingComponent implementation. - virtual void* CreateHandle() const OVERRIDE; - virtual int InitializeHandle(void* handle) const OVERRIDE; - virtual int ConfigureHandle(void* handle) const OVERRIDE; - virtual void DestroyHandle(void* handle) const OVERRIDE; - virtual int num_handles_required() const OVERRIDE; - virtual int GetHandleError(void* handle) const OVERRIDE; + void* CreateHandle() const override; + int InitializeHandle(void* handle) const override; + int ConfigureHandle(void* handle) const override; + void DestroyHandle(void* handle) const override; + int num_handles_required() const override; + int GetHandleError(void* handle) const override; const AudioProcessing* apm_; CriticalSectionWrapper* crit_; diff --git a/webrtc/modules/audio_processing/echo_control_mobile_impl.h b/webrtc/modules/audio_processing/echo_control_mobile_impl.h index 4f5b5931a..f399f480b 100644 --- a/webrtc/modules/audio_processing/echo_control_mobile_impl.h +++ b/webrtc/modules/audio_processing/echo_control_mobile_impl.h @@ -30,28 +30,28 @@ class EchoControlMobileImpl : public EchoControlMobile, int ProcessCaptureAudio(AudioBuffer* audio); // EchoControlMobile implementation. - virtual bool is_enabled() const OVERRIDE; + bool is_enabled() const override; // ProcessingComponent implementation. - virtual int Initialize() OVERRIDE; + int Initialize() override; private: // EchoControlMobile implementation. - virtual int Enable(bool enable) OVERRIDE; - virtual int set_routing_mode(RoutingMode mode) OVERRIDE; - virtual RoutingMode routing_mode() const OVERRIDE; - virtual int enable_comfort_noise(bool enable) OVERRIDE; - virtual bool is_comfort_noise_enabled() const OVERRIDE; - virtual int SetEchoPath(const void* echo_path, size_t size_bytes) OVERRIDE; - virtual int GetEchoPath(void* echo_path, size_t size_bytes) const OVERRIDE; + int Enable(bool enable) override; + int set_routing_mode(RoutingMode mode) override; + RoutingMode routing_mode() const override; + int enable_comfort_noise(bool enable) override; + bool is_comfort_noise_enabled() const override; + int SetEchoPath(const void* echo_path, size_t size_bytes) override; + int GetEchoPath(void* echo_path, size_t size_bytes) const override; // ProcessingComponent implementation. - virtual void* CreateHandle() const OVERRIDE; - virtual int InitializeHandle(void* handle) const OVERRIDE; - virtual int ConfigureHandle(void* handle) const OVERRIDE; - virtual void DestroyHandle(void* handle) const OVERRIDE; - virtual int num_handles_required() const OVERRIDE; - virtual int GetHandleError(void* handle) const OVERRIDE; + void* CreateHandle() const override; + int InitializeHandle(void* handle) const override; + int ConfigureHandle(void* handle) const override; + void DestroyHandle(void* handle) const override; + int num_handles_required() const override; + int GetHandleError(void* handle) const override; const AudioProcessing* apm_; CriticalSectionWrapper* crit_; diff --git a/webrtc/modules/audio_processing/gain_control_impl.h b/webrtc/modules/audio_processing/gain_control_impl.h index 811598700..d64894367 100644 --- a/webrtc/modules/audio_processing/gain_control_impl.h +++ b/webrtc/modules/audio_processing/gain_control_impl.h @@ -33,36 +33,36 @@ class GainControlImpl : public GainControl, int ProcessCaptureAudio(AudioBuffer* audio); // ProcessingComponent implementation. - virtual int Initialize() OVERRIDE; + int Initialize() override; // GainControl implementation. - virtual bool is_enabled() const OVERRIDE; - virtual int stream_analog_level() OVERRIDE; + bool is_enabled() const override; + int stream_analog_level() override; private: // GainControl implementation. - virtual int Enable(bool enable) OVERRIDE; - virtual int set_stream_analog_level(int level) OVERRIDE; - virtual int set_mode(Mode mode) OVERRIDE; - virtual Mode mode() const OVERRIDE; - virtual int set_target_level_dbfs(int level) OVERRIDE; - virtual int target_level_dbfs() const OVERRIDE; - virtual int set_compression_gain_db(int gain) OVERRIDE; - virtual int compression_gain_db() const OVERRIDE; - virtual int enable_limiter(bool enable) OVERRIDE; - virtual bool is_limiter_enabled() const OVERRIDE; - virtual int set_analog_level_limits(int minimum, int maximum) OVERRIDE; - virtual int analog_level_minimum() const OVERRIDE; - virtual int analog_level_maximum() const OVERRIDE; - virtual bool stream_is_saturated() const OVERRIDE; + int Enable(bool enable) override; + int set_stream_analog_level(int level) override; + int set_mode(Mode mode) override; + Mode mode() const override; + int set_target_level_dbfs(int level) override; + int target_level_dbfs() const override; + int set_compression_gain_db(int gain) override; + int compression_gain_db() const override; + int enable_limiter(bool enable) override; + bool is_limiter_enabled() const override; + int set_analog_level_limits(int minimum, int maximum) override; + int analog_level_minimum() const override; + int analog_level_maximum() const override; + bool stream_is_saturated() const override; // ProcessingComponent implementation. - virtual void* CreateHandle() const OVERRIDE; - virtual int InitializeHandle(void* handle) const OVERRIDE; - virtual int ConfigureHandle(void* handle) const OVERRIDE; - virtual void DestroyHandle(void* handle) const OVERRIDE; - virtual int num_handles_required() const OVERRIDE; - virtual int GetHandleError(void* handle) const OVERRIDE; + void* CreateHandle() const override; + int InitializeHandle(void* handle) const override; + int ConfigureHandle(void* handle) const override; + void DestroyHandle(void* handle) const override; + int num_handles_required() const override; + int GetHandleError(void* handle) const override; const AudioProcessing* apm_; CriticalSectionWrapper* crit_; diff --git a/webrtc/modules/audio_processing/high_pass_filter_impl.h b/webrtc/modules/audio_processing/high_pass_filter_impl.h index 6f91f3bc0..90b393e90 100644 --- a/webrtc/modules/audio_processing/high_pass_filter_impl.h +++ b/webrtc/modules/audio_processing/high_pass_filter_impl.h @@ -28,19 +28,19 @@ class HighPassFilterImpl : public HighPassFilter, int ProcessCaptureAudio(AudioBuffer* audio); // HighPassFilter implementation. - virtual bool is_enabled() const OVERRIDE; + bool is_enabled() const override; private: // HighPassFilter implementation. - virtual int Enable(bool enable) OVERRIDE; + int Enable(bool enable) override; // ProcessingComponent implementation. - virtual void* CreateHandle() const OVERRIDE; - virtual int InitializeHandle(void* handle) const OVERRIDE; - virtual int ConfigureHandle(void* handle) const OVERRIDE; - virtual void DestroyHandle(void* handle) const OVERRIDE; - virtual int num_handles_required() const OVERRIDE; - virtual int GetHandleError(void* handle) const OVERRIDE; + void* CreateHandle() const override; + int InitializeHandle(void* handle) const override; + int ConfigureHandle(void* handle) const override; + void DestroyHandle(void* handle) const override; + int num_handles_required() const override; + int GetHandleError(void* handle) const override; const AudioProcessing* apm_; CriticalSectionWrapper* crit_; diff --git a/webrtc/modules/audio_processing/level_estimator_impl.h b/webrtc/modules/audio_processing/level_estimator_impl.h index b38337d4d..0d0050c7e 100644 --- a/webrtc/modules/audio_processing/level_estimator_impl.h +++ b/webrtc/modules/audio_processing/level_estimator_impl.h @@ -30,20 +30,20 @@ class LevelEstimatorImpl : public LevelEstimator, int ProcessStream(AudioBuffer* audio); // LevelEstimator implementation. - virtual bool is_enabled() const OVERRIDE; + bool is_enabled() const override; private: // LevelEstimator implementation. - virtual int Enable(bool enable) OVERRIDE; - virtual int RMS() OVERRIDE; + int Enable(bool enable) override; + int RMS() override; // ProcessingComponent implementation. - virtual void* CreateHandle() const OVERRIDE; - virtual int InitializeHandle(void* handle) const OVERRIDE; - virtual int ConfigureHandle(void* handle) const OVERRIDE; - virtual void DestroyHandle(void* handle) const OVERRIDE; - virtual int num_handles_required() const OVERRIDE; - virtual int GetHandleError(void* handle) const OVERRIDE; + void* CreateHandle() const override; + int InitializeHandle(void* handle) const override; + int ConfigureHandle(void* handle) const override; + void DestroyHandle(void* handle) const override; + int num_handles_required() const override; + int GetHandleError(void* handle) const override; CriticalSectionWrapper* crit_; }; diff --git a/webrtc/modules/audio_processing/noise_suppression_impl.h b/webrtc/modules/audio_processing/noise_suppression_impl.h index 14abe66b6..33a0e060a 100644 --- a/webrtc/modules/audio_processing/noise_suppression_impl.h +++ b/webrtc/modules/audio_processing/noise_suppression_impl.h @@ -30,22 +30,22 @@ class NoiseSuppressionImpl : public NoiseSuppression, int ProcessCaptureAudio(AudioBuffer* audio); // NoiseSuppression implementation. - virtual bool is_enabled() const OVERRIDE; - virtual float speech_probability() const OVERRIDE; + bool is_enabled() const override; + float speech_probability() const override; private: // NoiseSuppression implementation. - virtual int Enable(bool enable) OVERRIDE; - virtual int set_level(Level level) OVERRIDE; - virtual Level level() const OVERRIDE; + int Enable(bool enable) override; + int set_level(Level level) override; + Level level() const override; // ProcessingComponent implementation. - virtual void* CreateHandle() const OVERRIDE; - virtual int InitializeHandle(void* handle) const OVERRIDE; - virtual int ConfigureHandle(void* handle) const OVERRIDE; - virtual void DestroyHandle(void* handle) const OVERRIDE; - virtual int num_handles_required() const OVERRIDE; - virtual int GetHandleError(void* handle) const OVERRIDE; + void* CreateHandle() const override; + int InitializeHandle(void* handle) const override; + int ConfigureHandle(void* handle) const override; + void DestroyHandle(void* handle) const override; + int num_handles_required() const override; + int GetHandleError(void* handle) const override; const AudioProcessing* apm_; CriticalSectionWrapper* crit_; diff --git a/webrtc/modules/audio_processing/voice_detection_impl.h b/webrtc/modules/audio_processing/voice_detection_impl.h index 1dfdf20ae..32f031edf 100644 --- a/webrtc/modules/audio_processing/voice_detection_impl.h +++ b/webrtc/modules/audio_processing/voice_detection_impl.h @@ -28,28 +28,28 @@ class VoiceDetectionImpl : public VoiceDetection, int ProcessCaptureAudio(AudioBuffer* audio); // VoiceDetection implementation. - virtual bool is_enabled() const OVERRIDE; + bool is_enabled() const override; // ProcessingComponent implementation. - virtual int Initialize() OVERRIDE; + int Initialize() override; private: // VoiceDetection implementation. - virtual int Enable(bool enable) OVERRIDE; - virtual int set_stream_has_voice(bool has_voice) OVERRIDE; - virtual bool stream_has_voice() const OVERRIDE; - virtual int set_likelihood(Likelihood likelihood) OVERRIDE; - virtual Likelihood likelihood() const OVERRIDE; - virtual int set_frame_size_ms(int size) OVERRIDE; - virtual int frame_size_ms() const OVERRIDE; + int Enable(bool enable) override; + int set_stream_has_voice(bool has_voice) override; + bool stream_has_voice() const override; + int set_likelihood(Likelihood likelihood) override; + Likelihood likelihood() const override; + int set_frame_size_ms(int size) override; + int frame_size_ms() const override; // ProcessingComponent implementation. - virtual void* CreateHandle() const OVERRIDE; - virtual int InitializeHandle(void* handle) const OVERRIDE; - virtual int ConfigureHandle(void* handle) const OVERRIDE; - virtual void DestroyHandle(void* handle) const OVERRIDE; - virtual int num_handles_required() const OVERRIDE; - virtual int GetHandleError(void* handle) const OVERRIDE; + void* CreateHandle() const override; + int InitializeHandle(void* handle) const override; + int ConfigureHandle(void* handle) const override; + void DestroyHandle(void* handle) const override; + int num_handles_required() const override; + int GetHandleError(void* handle) const override; const AudioProcessing* apm_; CriticalSectionWrapper* crit_; diff --git a/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc b/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc index 586d8da30..477276b3b 100644 --- a/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc +++ b/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc @@ -27,14 +27,13 @@ class BitrateControllerImpl::RtcpBandwidthObserverImpl virtual ~RtcpBandwidthObserverImpl() { } // Received RTCP REMB or TMMBR. - virtual void OnReceivedEstimatedBitrate(uint32_t bitrate) OVERRIDE { + void OnReceivedEstimatedBitrate(uint32_t bitrate) override { owner_->OnReceivedEstimatedBitrate(bitrate); } // Received RTCP receiver block. - virtual void OnReceivedRtcpReceiverReport( - const ReportBlockList& report_blocks, - int64_t rtt, - int64_t now_ms) OVERRIDE { + void OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks, + int64_t rtt, + int64_t now_ms) override { if (report_blocks.empty()) return; diff --git a/webrtc/modules/bitrate_controller/bitrate_controller_impl.h b/webrtc/modules/bitrate_controller/bitrate_controller_impl.h index 1646f7502..f089be9d6 100644 --- a/webrtc/modules/bitrate_controller/bitrate_controller_impl.h +++ b/webrtc/modules/bitrate_controller/bitrate_controller_impl.h @@ -32,23 +32,23 @@ class BitrateControllerImpl : public BitrateController { BitrateControllerImpl(Clock* clock, BitrateObserver* observer); virtual ~BitrateControllerImpl(); - virtual bool AvailableBandwidth(uint32_t* bandwidth) const override; + bool AvailableBandwidth(uint32_t* bandwidth) const override; - virtual RtcpBandwidthObserver* CreateRtcpBandwidthObserver() override; + RtcpBandwidthObserver* CreateRtcpBandwidthObserver() override; - virtual void SetStartBitrate(int start_bitrate_bps) override; - virtual void SetMinMaxBitrate(int min_bitrate_bps, + void SetStartBitrate(int start_bitrate_bps) override; + void SetMinMaxBitrate(int min_bitrate_bps, int max_bitrate_bps) override; - virtual void SetReservedBitrate(uint32_t reserved_bitrate_bps) override; + void SetReservedBitrate(uint32_t reserved_bitrate_bps) override; - virtual int64_t TimeUntilNextProcess() override; - virtual int32_t Process() override; + int64_t TimeUntilNextProcess() override; + int32_t Process() override; // Current bitrate actually being sent. - virtual void SetBitrateSent(uint32_t bitrate_sent_bps) override; + void SetBitrateSent(uint32_t bitrate_sent_bps) override; - virtual void SetCodecMode(webrtc::VideoCodecMode mode) override; + void SetCodecMode(webrtc::VideoCodecMode mode) override; private: class RtcpBandwidthObserverImpl; diff --git a/webrtc/modules/bitrate_controller/remb_suppressor_unittest.cc b/webrtc/modules/bitrate_controller/remb_suppressor_unittest.cc index 7ce99a199..834ec5fe0 100644 --- a/webrtc/modules/bitrate_controller/remb_suppressor_unittest.cc +++ b/webrtc/modules/bitrate_controller/remb_suppressor_unittest.cc @@ -20,7 +20,7 @@ class TestSuppressor : public webrtc::RembSuppressor { explicit TestSuppressor(webrtc::Clock* clock) : RembSuppressor(clock) {} virtual ~TestSuppressor() {} - virtual bool Enabled() OVERRIDE { return true; } + bool Enabled() override { return true; } }; class RembSuppressorTest : public ::testing::Test { diff --git a/webrtc/modules/desktop_capture/cropping_window_capturer.h b/webrtc/modules/desktop_capture/cropping_window_capturer.h index 4c3006692..e0f598c7e 100644 --- a/webrtc/modules/desktop_capture/cropping_window_capturer.h +++ b/webrtc/modules/desktop_capture/cropping_window_capturer.h @@ -28,19 +28,19 @@ class CroppingWindowCapturer : public WindowCapturer, virtual ~CroppingWindowCapturer(); // DesktopCapturer implementation. - virtual void Start(DesktopCapturer::Callback* callback) OVERRIDE; - virtual void Capture(const DesktopRegion& region) OVERRIDE; - virtual void SetExcludedWindow(WindowId window) OVERRIDE; + void Start(DesktopCapturer::Callback* callback) override; + void Capture(const DesktopRegion& region) override; + void SetExcludedWindow(WindowId window) override; // WindowCapturer implementation. - virtual bool GetWindowList(WindowList* windows) OVERRIDE; - virtual bool SelectWindow(WindowId id) OVERRIDE; - virtual bool BringSelectedWindowToFront() OVERRIDE; + bool GetWindowList(WindowList* windows) override; + bool SelectWindow(WindowId id) override; + bool BringSelectedWindowToFront() override; // DesktopCapturer::Callback implementation, passed to |screen_capturer_| to // intercept the capture result. - virtual SharedMemory* CreateSharedMemory(size_t size) OVERRIDE; - virtual void OnCaptureCompleted(DesktopFrame* frame) OVERRIDE; + SharedMemory* CreateSharedMemory(size_t size) override; + void OnCaptureCompleted(DesktopFrame* frame) override; protected: explicit CroppingWindowCapturer(const DesktopCaptureOptions& options); diff --git a/webrtc/modules/desktop_capture/cropping_window_capturer_win.cc b/webrtc/modules/desktop_capture/cropping_window_capturer_win.cc index fc1858e03..deffe665e 100644 --- a/webrtc/modules/desktop_capture/cropping_window_capturer_win.cc +++ b/webrtc/modules/desktop_capture/cropping_window_capturer_win.cc @@ -113,8 +113,8 @@ class CroppingWindowCapturerWin : public CroppingWindowCapturer { : CroppingWindowCapturer(options) {} private: - virtual bool ShouldUseScreenCapturer() OVERRIDE; - virtual DesktopRect GetWindowRectInVirtualScreen() OVERRIDE; + bool ShouldUseScreenCapturer() override; + DesktopRect GetWindowRectInVirtualScreen() override; // The region from GetWindowRgn in the desktop coordinate if the region is // rectangular, or the rect from GetWindowRect if the region is not set. diff --git a/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h b/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h index d40248637..b16cf4584 100644 --- a/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h +++ b/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h @@ -32,19 +32,19 @@ class DesktopAndCursorComposer : public DesktopCapturer, virtual ~DesktopAndCursorComposer(); // DesktopCapturer interface. - virtual void Start(DesktopCapturer::Callback* callback) OVERRIDE; - virtual void Capture(const DesktopRegion& region) OVERRIDE; - virtual void SetExcludedWindow(WindowId window) OVERRIDE; + void Start(DesktopCapturer::Callback* callback) override; + void Capture(const DesktopRegion& region) override; + void SetExcludedWindow(WindowId window) override; private: // DesktopCapturer::Callback interface. - virtual SharedMemory* CreateSharedMemory(size_t size) OVERRIDE; - virtual void OnCaptureCompleted(DesktopFrame* frame) OVERRIDE; + SharedMemory* CreateSharedMemory(size_t size) override; + void OnCaptureCompleted(DesktopFrame* frame) override; // MouseCursorMonitor::Callback interface. - virtual void OnMouseCursor(MouseCursor* cursor) OVERRIDE; - virtual void OnMouseCursorPosition(MouseCursorMonitor::CursorState state, - const DesktopVector& position) OVERRIDE; + void OnMouseCursor(MouseCursor* cursor) override; + void OnMouseCursorPosition(MouseCursorMonitor::CursorState state, + const DesktopVector& position) override; rtc::scoped_ptr desktop_capturer_; rtc::scoped_ptr mouse_monitor_; diff --git a/webrtc/modules/desktop_capture/desktop_and_cursor_composer_unittest.cc b/webrtc/modules/desktop_capture/desktop_and_cursor_composer_unittest.cc index f1129ab0b..7fdfa1c4b 100644 --- a/webrtc/modules/desktop_capture/desktop_and_cursor_composer_unittest.cc +++ b/webrtc/modules/desktop_capture/desktop_and_cursor_composer_unittest.cc @@ -74,11 +74,9 @@ class FakeScreenCapturer : public DesktopCapturer { public: FakeScreenCapturer() {} - virtual void Start(Callback* callback) OVERRIDE { - callback_ = callback; - } + void Start(Callback* callback) override { callback_ = callback; } - virtual void Capture(const DesktopRegion& region) OVERRIDE { + void Capture(const DesktopRegion& region) override { callback_->OnCaptureCompleted(next_frame_.release()); } @@ -107,11 +105,9 @@ class FakeMouseMonitor : public MouseCursorMonitor { hotspot_ = hotspot; } - virtual void Init(Callback* callback, Mode mode) OVERRIDE { - callback_ = callback; - } + void Init(Callback* callback, Mode mode) override { callback_ = callback; } - virtual void Capture() OVERRIDE { + void Capture() override { if (changed_) { rtc::scoped_ptr image( new BasicDesktopFrame(DesktopSize(kCursorWidth, kCursorHeight))); @@ -172,13 +168,9 @@ class DesktopAndCursorComposerTest : public testing::Test, } // DesktopCapturer::Callback interface - virtual SharedMemory* CreateSharedMemory(size_t size) OVERRIDE { - return NULL; - } + SharedMemory* CreateSharedMemory(size_t size) override { return NULL; } - virtual void OnCaptureCompleted(DesktopFrame* frame) OVERRIDE { - frame_.reset(frame); - } + void OnCaptureCompleted(DesktopFrame* frame) override { frame_.reset(frame); } protected: // Owned by |blender_|. diff --git a/webrtc/modules/desktop_capture/mouse_cursor_monitor_mac.mm b/webrtc/modules/desktop_capture/mouse_cursor_monitor_mac.mm index 325feae64..5a080fa63 100644 --- a/webrtc/modules/desktop_capture/mouse_cursor_monitor_mac.mm +++ b/webrtc/modules/desktop_capture/mouse_cursor_monitor_mac.mm @@ -35,8 +35,8 @@ class MouseCursorMonitorMac : public MouseCursorMonitor { ScreenId screen_id); virtual ~MouseCursorMonitorMac(); - virtual void Init(Callback* callback, Mode mode) OVERRIDE; - virtual void Capture() OVERRIDE; + void Init(Callback* callback, Mode mode) override; + void Capture() override; private: static void DisplaysReconfiguredCallback(CGDirectDisplayID display, diff --git a/webrtc/modules/desktop_capture/mouse_cursor_monitor_unittest.cc b/webrtc/modules/desktop_capture/mouse_cursor_monitor_unittest.cc index 36963a99d..723862805 100644 --- a/webrtc/modules/desktop_capture/mouse_cursor_monitor_unittest.cc +++ b/webrtc/modules/desktop_capture/mouse_cursor_monitor_unittest.cc @@ -28,12 +28,12 @@ class MouseCursorMonitorTest : public testing::Test, } // MouseCursorMonitor::Callback interface - virtual void OnMouseCursor(MouseCursor* cursor_image) OVERRIDE { + void OnMouseCursor(MouseCursor* cursor_image) override { cursor_image_.reset(cursor_image); } - virtual void OnMouseCursorPosition(MouseCursorMonitor::CursorState state, - const DesktopVector& position) OVERRIDE { + void OnMouseCursorPosition(MouseCursorMonitor::CursorState state, + const DesktopVector& position) override { state_ = state; position_ = position; position_received_ = true; diff --git a/webrtc/modules/desktop_capture/mouse_cursor_monitor_win.cc b/webrtc/modules/desktop_capture/mouse_cursor_monitor_win.cc index 8421161ad..3f4991e01 100644 --- a/webrtc/modules/desktop_capture/mouse_cursor_monitor_win.cc +++ b/webrtc/modules/desktop_capture/mouse_cursor_monitor_win.cc @@ -26,8 +26,8 @@ class MouseCursorMonitorWin : public MouseCursorMonitor { explicit MouseCursorMonitorWin(ScreenId screen); virtual ~MouseCursorMonitorWin(); - virtual void Init(Callback* callback, Mode mode) OVERRIDE; - virtual void Capture() OVERRIDE; + void Init(Callback* callback, Mode mode) override; + void Capture() override; private: // Get the rect of the currently selected screen, relative to the primary diff --git a/webrtc/modules/desktop_capture/mouse_cursor_monitor_x11.cc b/webrtc/modules/desktop_capture/mouse_cursor_monitor_x11.cc index b11647436..9b3cc17a6 100644 --- a/webrtc/modules/desktop_capture/mouse_cursor_monitor_x11.cc +++ b/webrtc/modules/desktop_capture/mouse_cursor_monitor_x11.cc @@ -63,12 +63,12 @@ class MouseCursorMonitorX11 : public MouseCursorMonitor, MouseCursorMonitorX11(const DesktopCaptureOptions& options, Window window); virtual ~MouseCursorMonitorX11(); - virtual void Init(Callback* callback, Mode mode) OVERRIDE; - virtual void Capture() OVERRIDE; + void Init(Callback* callback, Mode mode) override; + void Capture() override; private: // SharedXDisplay::XEventHandler interface. - virtual bool HandleXEvent(const XEvent& event) OVERRIDE; + bool HandleXEvent(const XEvent& event) override; Display* display() { return x_display_->display(); } diff --git a/webrtc/modules/desktop_capture/screen_capturer_mac.mm b/webrtc/modules/desktop_capture/screen_capturer_mac.mm index af98e73aa..93e9a6faf 100644 --- a/webrtc/modules/desktop_capture/screen_capturer_mac.mm +++ b/webrtc/modules/desktop_capture/screen_capturer_mac.mm @@ -196,11 +196,11 @@ class ScreenCapturerMac : public ScreenCapturer { bool Init(); // Overridden from ScreenCapturer: - virtual void Start(Callback* callback) OVERRIDE; - virtual void Capture(const DesktopRegion& region) OVERRIDE; - virtual void SetExcludedWindow(WindowId window) OVERRIDE; - virtual bool GetScreenList(ScreenList* screens) OVERRIDE; - virtual bool SelectScreen(ScreenId id) OVERRIDE; + void Start(Callback* callback) override; + void Capture(const DesktopRegion& region) override; + void SetExcludedWindow(WindowId window) override; + bool GetScreenList(ScreenList* screens) override; + bool SelectScreen(ScreenId id) override; private: void GlBlitFast(const DesktopFrame& frame, diff --git a/webrtc/modules/desktop_capture/screen_capturer_mac_unittest.cc b/webrtc/modules/desktop_capture/screen_capturer_mac_unittest.cc index c99138d92..e3d037b1e 100644 --- a/webrtc/modules/desktop_capture/screen_capturer_mac_unittest.cc +++ b/webrtc/modules/desktop_capture/screen_capturer_mac_unittest.cc @@ -38,9 +38,7 @@ class ScreenCapturerMacTest : public testing::Test { void CaptureDoneCallback2(DesktopFrame* frame); protected: - virtual void SetUp() OVERRIDE { - capturer_.reset(ScreenCapturer::Create()); - } + void SetUp() override { capturer_.reset(ScreenCapturer::Create()); } rtc::scoped_ptr capturer_; MockScreenCapturerCallback callback_; diff --git a/webrtc/modules/desktop_capture/screen_capturer_unittest.cc b/webrtc/modules/desktop_capture/screen_capturer_unittest.cc index 34eab7e9c..606c06153 100644 --- a/webrtc/modules/desktop_capture/screen_capturer_unittest.cc +++ b/webrtc/modules/desktop_capture/screen_capturer_unittest.cc @@ -30,7 +30,7 @@ class ScreenCapturerTest : public testing::Test { public: SharedMemory* CreateSharedMemory(size_t size); - virtual void SetUp() OVERRIDE { + void SetUp() override { capturer_.reset( ScreenCapturer::Create(DesktopCaptureOptions::CreateDefault())); } diff --git a/webrtc/modules/desktop_capture/screen_capturer_x11.cc b/webrtc/modules/desktop_capture/screen_capturer_x11.cc index 0a758f94e..1597e3fb6 100644 --- a/webrtc/modules/desktop_capture/screen_capturer_x11.cc +++ b/webrtc/modules/desktop_capture/screen_capturer_x11.cc @@ -50,18 +50,18 @@ class ScreenCapturerLinux : public ScreenCapturer, bool Init(const DesktopCaptureOptions& options); // DesktopCapturer interface. - virtual void Start(Callback* delegate) OVERRIDE; - virtual void Capture(const DesktopRegion& region) OVERRIDE; + void Start(Callback* delegate) override; + void Capture(const DesktopRegion& region) override; // ScreenCapturer interface. - virtual bool GetScreenList(ScreenList* screens) OVERRIDE; - virtual bool SelectScreen(ScreenId id) OVERRIDE; + bool GetScreenList(ScreenList* screens) override; + bool SelectScreen(ScreenId id) override; private: Display* display() { return options_.x_display()->display(); } // SharedXDisplay::XEventHandler interface. - virtual bool HandleXEvent(const XEvent& event) OVERRIDE; + bool HandleXEvent(const XEvent& event) override; void InitXDamage(); diff --git a/webrtc/modules/desktop_capture/win/screen_capturer_win_gdi.h b/webrtc/modules/desktop_capture/win/screen_capturer_win_gdi.h index 34de7de06..6014a1810 100644 --- a/webrtc/modules/desktop_capture/win/screen_capturer_win_gdi.h +++ b/webrtc/modules/desktop_capture/win/screen_capturer_win_gdi.h @@ -33,10 +33,10 @@ class ScreenCapturerWinGdi : public ScreenCapturer { virtual ~ScreenCapturerWinGdi(); // Overridden from ScreenCapturer: - virtual void Start(Callback* callback) OVERRIDE; - virtual void Capture(const DesktopRegion& region) OVERRIDE; - virtual bool GetScreenList(ScreenList* screens) OVERRIDE; - virtual bool SelectScreen(ScreenId id) OVERRIDE; + void Start(Callback* callback) override; + void Capture(const DesktopRegion& region) override; + bool GetScreenList(ScreenList* screens) override; + bool SelectScreen(ScreenId id) override; private: typedef HRESULT (WINAPI * DwmEnableCompositionFunc)(UINT); diff --git a/webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.h b/webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.h index 53caaa293..5bc0f8120 100644 --- a/webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.h +++ b/webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.h @@ -43,11 +43,11 @@ class ScreenCapturerWinMagnifier : public ScreenCapturer { virtual ~ScreenCapturerWinMagnifier(); // Overridden from ScreenCapturer: - virtual void Start(Callback* callback) OVERRIDE; - virtual void Capture(const DesktopRegion& region) OVERRIDE; - virtual bool GetScreenList(ScreenList* screens) OVERRIDE; - virtual bool SelectScreen(ScreenId id) OVERRIDE; - virtual void SetExcludedWindow(WindowId window) OVERRIDE; + void Start(Callback* callback) override; + void Capture(const DesktopRegion& region) override; + bool GetScreenList(ScreenList* screens) override; + bool SelectScreen(ScreenId id) override; + void SetExcludedWindow(WindowId window) override; private: typedef BOOL(WINAPI* MagImageScalingCallback)(HWND hwnd, diff --git a/webrtc/modules/desktop_capture/window_capturer_mac.mm b/webrtc/modules/desktop_capture/window_capturer_mac.mm index e69fc11d6..daa9fc785 100644 --- a/webrtc/modules/desktop_capture/window_capturer_mac.mm +++ b/webrtc/modules/desktop_capture/window_capturer_mac.mm @@ -50,13 +50,13 @@ class WindowCapturerMac : public WindowCapturer { virtual ~WindowCapturerMac(); // WindowCapturer interface. - virtual bool GetWindowList(WindowList* windows) OVERRIDE; - virtual bool SelectWindow(WindowId id) OVERRIDE; - virtual bool BringSelectedWindowToFront() OVERRIDE; + bool GetWindowList(WindowList* windows) override; + bool SelectWindow(WindowId id) override; + bool BringSelectedWindowToFront() override; // DesktopCapturer interface. - virtual void Start(Callback* callback) OVERRIDE; - virtual void Capture(const DesktopRegion& region) OVERRIDE; + void Start(Callback* callback) override; + void Capture(const DesktopRegion& region) override; private: Callback* callback_; diff --git a/webrtc/modules/desktop_capture/window_capturer_null.cc b/webrtc/modules/desktop_capture/window_capturer_null.cc index 5f9010d2f..d9ad0ca0b 100755 --- a/webrtc/modules/desktop_capture/window_capturer_null.cc +++ b/webrtc/modules/desktop_capture/window_capturer_null.cc @@ -24,13 +24,13 @@ class WindowCapturerNull : public WindowCapturer { virtual ~WindowCapturerNull(); // WindowCapturer interface. - virtual bool GetWindowList(WindowList* windows) OVERRIDE; - virtual bool SelectWindow(WindowId id) OVERRIDE; - virtual bool BringSelectedWindowToFront() OVERRIDE; + bool GetWindowList(WindowList* windows) override; + bool SelectWindow(WindowId id) override; + bool BringSelectedWindowToFront() override; // DesktopCapturer interface. - virtual void Start(Callback* callback) OVERRIDE; - virtual void Capture(const DesktopRegion& region) OVERRIDE; + void Start(Callback* callback) override; + void Capture(const DesktopRegion& region) override; private: Callback* callback_; diff --git a/webrtc/modules/desktop_capture/window_capturer_unittest.cc b/webrtc/modules/desktop_capture/window_capturer_unittest.cc index ac62c9689..bb4ddf07c 100644 --- a/webrtc/modules/desktop_capture/window_capturer_unittest.cc +++ b/webrtc/modules/desktop_capture/window_capturer_unittest.cc @@ -22,22 +22,17 @@ namespace webrtc { class WindowCapturerTest : public testing::Test, public DesktopCapturer::Callback { public: - void SetUp() OVERRIDE { + void SetUp() override { capturer_.reset( WindowCapturer::Create(DesktopCaptureOptions::CreateDefault())); } - void TearDown() OVERRIDE { - } + void TearDown() override {} // DesktopCapturer::Callback interface - virtual SharedMemory* CreateSharedMemory(size_t size) OVERRIDE { - return NULL; - } + SharedMemory* CreateSharedMemory(size_t size) override { return NULL; } - virtual void OnCaptureCompleted(DesktopFrame* frame) OVERRIDE { - frame_.reset(frame); - } + void OnCaptureCompleted(DesktopFrame* frame) override { frame_.reset(frame); } protected: rtc::scoped_ptr capturer_; diff --git a/webrtc/modules/desktop_capture/window_capturer_win.cc b/webrtc/modules/desktop_capture/window_capturer_win.cc index 5d6bf649c..c7e1fd879 100644 --- a/webrtc/modules/desktop_capture/window_capturer_win.cc +++ b/webrtc/modules/desktop_capture/window_capturer_win.cc @@ -72,13 +72,13 @@ class WindowCapturerWin : public WindowCapturer { virtual ~WindowCapturerWin(); // WindowCapturer interface. - virtual bool GetWindowList(WindowList* windows) OVERRIDE; - virtual bool SelectWindow(WindowId id) OVERRIDE; - virtual bool BringSelectedWindowToFront() OVERRIDE; + bool GetWindowList(WindowList* windows) override; + bool SelectWindow(WindowId id) override; + bool BringSelectedWindowToFront() override; // DesktopCapturer interface. - virtual void Start(Callback* callback) OVERRIDE; - virtual void Capture(const DesktopRegion& region) OVERRIDE; + void Start(Callback* callback) override; + void Capture(const DesktopRegion& region) override; private: bool IsAeroEnabled(); diff --git a/webrtc/modules/desktop_capture/window_capturer_x11.cc b/webrtc/modules/desktop_capture/window_capturer_x11.cc index 0a90b0ca5..8dacd4639 100755 --- a/webrtc/modules/desktop_capture/window_capturer_x11.cc +++ b/webrtc/modules/desktop_capture/window_capturer_x11.cc @@ -92,16 +92,16 @@ class WindowCapturerLinux : public WindowCapturer, virtual ~WindowCapturerLinux(); // WindowCapturer interface. - virtual bool GetWindowList(WindowList* windows) OVERRIDE; - virtual bool SelectWindow(WindowId id) OVERRIDE; - virtual bool BringSelectedWindowToFront() OVERRIDE; + bool GetWindowList(WindowList* windows) override; + bool SelectWindow(WindowId id) override; + bool BringSelectedWindowToFront() override; // DesktopCapturer interface. - virtual void Start(Callback* callback) OVERRIDE; - virtual void Capture(const DesktopRegion& region) OVERRIDE; + void Start(Callback* callback) override; + void Capture(const DesktopRegion& region) override; // SharedXDisplay::XEventHandler interface. - virtual bool HandleXEvent(const XEvent& event) OVERRIDE; + bool HandleXEvent(const XEvent& event) override; private: Display* display() { return x_display_->display(); } diff --git a/webrtc/modules/media_file/source/media_file_impl.h b/webrtc/modules/media_file/source/media_file_impl.h index 9b14a8623..c5038bbdf 100644 --- a/webrtc/modules/media_file/source/media_file_impl.h +++ b/webrtc/modules/media_file/source/media_file_impl.h @@ -26,72 +26,71 @@ public: MediaFileImpl(const int32_t id); ~MediaFileImpl(); - virtual int32_t Process() OVERRIDE; - virtual int64_t TimeUntilNextProcess() OVERRIDE; + int32_t Process() override; + int64_t TimeUntilNextProcess() override; // MediaFile functions - virtual int32_t PlayoutAudioData(int8_t* audioBuffer, - size_t& dataLengthInBytes) OVERRIDE; + int32_t PlayoutAudioData(int8_t* audioBuffer, + size_t& dataLengthInBytes) override; - virtual int32_t PlayoutStereoData(int8_t* audioBufferLeft, - int8_t* audioBufferRight, - size_t& dataLengthInBytes) OVERRIDE; + int32_t PlayoutStereoData(int8_t* audioBufferLeft, + int8_t* audioBufferRight, + size_t& dataLengthInBytes) override; - virtual int32_t StartPlayingAudioFile( - const char* fileName, + int32_t StartPlayingAudioFile( + const char* fileName, const uint32_t notificationTimeMs = 0, - const bool loop = false, - const FileFormats format = kFileFormatPcm16kHzFile, - const CodecInst* codecInst = NULL, + const bool loop = false, + const FileFormats format = kFileFormatPcm16kHzFile, + const CodecInst* codecInst = NULL, const uint32_t startPointMs = 0, - const uint32_t stopPointMs = 0) OVERRIDE; + const uint32_t stopPointMs = 0) override; - virtual int32_t StartPlayingAudioStream(InStream& stream, + int32_t StartPlayingAudioStream( + InStream& stream, const uint32_t notificationTimeMs = 0, const FileFormats format = kFileFormatPcm16kHzFile, const CodecInst* codecInst = NULL, const uint32_t startPointMs = 0, - const uint32_t stopPointMs = 0) OVERRIDE; + const uint32_t stopPointMs = 0) override; - virtual int32_t StopPlaying() OVERRIDE; + int32_t StopPlaying() override; - virtual bool IsPlaying() OVERRIDE; + bool IsPlaying() override; - virtual int32_t PlayoutPositionMs(uint32_t& positionMs) const OVERRIDE; + int32_t PlayoutPositionMs(uint32_t& positionMs) const override; - virtual int32_t IncomingAudioData(const int8_t* audioBuffer, - const size_t bufferLength) OVERRIDE; + int32_t IncomingAudioData(const int8_t* audioBuffer, + const size_t bufferLength) override; - virtual int32_t StartRecordingAudioFile( - const char* fileName, - const FileFormats format, - const CodecInst& codecInst, - const uint32_t notificationTimeMs = 0, - const uint32_t maxSizeBytes = 0) OVERRIDE; + int32_t StartRecordingAudioFile(const char* fileName, + const FileFormats format, + const CodecInst& codecInst, + const uint32_t notificationTimeMs = 0, + const uint32_t maxSizeBytes = 0) override; - virtual int32_t StartRecordingAudioStream( - OutStream& stream, - const FileFormats format, - const CodecInst& codecInst, - const uint32_t notificationTimeMs = 0) OVERRIDE; + int32_t StartRecordingAudioStream( + OutStream& stream, + const FileFormats format, + const CodecInst& codecInst, + const uint32_t notificationTimeMs = 0) override; - virtual int32_t StopRecording() OVERRIDE; + int32_t StopRecording() override; - virtual bool IsRecording() OVERRIDE; + bool IsRecording() override; - virtual int32_t RecordDurationMs(uint32_t& durationMs) OVERRIDE; + int32_t RecordDurationMs(uint32_t& durationMs) override; - virtual bool IsStereo() OVERRIDE; + bool IsStereo() override; - virtual int32_t SetModuleFileCallback(FileCallback* callback) OVERRIDE; + int32_t SetModuleFileCallback(FileCallback* callback) override; - virtual int32_t FileDurationMs( - const char* fileName, - uint32_t& durationMs, - const FileFormats format, - const uint32_t freqInHz = 16000) OVERRIDE; + int32_t FileDurationMs(const char* fileName, + uint32_t& durationMs, + const FileFormats format, + const uint32_t freqInHz = 16000) override; - virtual int32_t codec_info(CodecInst& codecInst) const OVERRIDE; + int32_t codec_info(CodecInst& codecInst) const override; private: // Returns true if the combination of format and codecInst is valid. diff --git a/webrtc/modules/pacing/include/paced_sender.h b/webrtc/modules/pacing/include/paced_sender.h index efd42177a..645999d50 100644 --- a/webrtc/modules/pacing/include/paced_sender.h +++ b/webrtc/modules/pacing/include/paced_sender.h @@ -121,10 +121,10 @@ class PacedSender : public Module { // Returns the number of milliseconds until the module want a worker thread // to call Process. - virtual int64_t TimeUntilNextProcess() OVERRIDE; + int64_t TimeUntilNextProcess() override; // Process any pending packets in the queue(s). - virtual int32_t Process() OVERRIDE; + int32_t Process() override; private: // Updates the number of bytes that can be sent for the next time interval. diff --git a/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.h b/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.h index b5aee769c..56f1c1a86 100644 --- a/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.h +++ b/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.h @@ -27,22 +27,22 @@ class AimdRateControl : public RemoteRateControl { virtual ~AimdRateControl() {} // Implements RemoteRateControl. - virtual bool ValidEstimate() const OVERRIDE; - virtual RateControlType GetControlType() const OVERRIDE; - virtual uint32_t GetMinBitrate() const OVERRIDE; - virtual int64_t GetFeedbackInterval() const OVERRIDE; + bool ValidEstimate() const override; + RateControlType GetControlType() const override; + uint32_t GetMinBitrate() const override; + int64_t GetFeedbackInterval() const override; // Returns true if the bitrate estimate hasn't been changed for more than // an RTT, or if the incoming_bitrate is more than 5% above the current // estimate. Should be used to decide if we should reduce the rate further // when over-using. - virtual bool TimeToReduceFurther( - int64_t time_now, uint32_t incoming_bitrate_bps) const OVERRIDE; - virtual uint32_t LatestEstimate() const OVERRIDE; - virtual uint32_t UpdateBandwidthEstimate(int64_t now_ms) OVERRIDE; - virtual void SetRtt(int64_t rtt) OVERRIDE; - virtual RateControlRegion Update(const RateControlInput* input, - int64_t now_ms) OVERRIDE; - virtual void SetEstimate(int bitrate_bps, int64_t now_ms) OVERRIDE; + bool TimeToReduceFurther(int64_t time_now, + uint32_t incoming_bitrate_bps) const override; + uint32_t LatestEstimate() const override; + uint32_t UpdateBandwidthEstimate(int64_t now_ms) override; + void SetRtt(int64_t rtt) override; + RateControlRegion Update(const RateControlInput* input, + int64_t now_ms) override; + void SetEstimate(int bitrate_bps, int64_t now_ms) override; private: // Update the target bitrate according based on, among other things, diff --git a/webrtc/modules/remote_bitrate_estimator/bwe_simulations.cc b/webrtc/modules/remote_bitrate_estimator/bwe_simulations.cc index de28c9a38..99642934e 100644 --- a/webrtc/modules/remote_bitrate_estimator/bwe_simulations.cc +++ b/webrtc/modules/remote_bitrate_estimator/bwe_simulations.cc @@ -30,7 +30,7 @@ class BweSimulation : public BweTest, virtual ~BweSimulation() {} protected: - virtual void SetUp() OVERRIDE { BweTest::SetUp(); } + void SetUp() override { BweTest::SetUp(); } private: DISALLOW_COPY_AND_ASSIGN(BweSimulation); diff --git a/webrtc/modules/remote_bitrate_estimator/mimd_rate_control.h b/webrtc/modules/remote_bitrate_estimator/mimd_rate_control.h index 1b1862c6f..d15799344 100644 --- a/webrtc/modules/remote_bitrate_estimator/mimd_rate_control.h +++ b/webrtc/modules/remote_bitrate_estimator/mimd_rate_control.h @@ -25,18 +25,18 @@ class MimdRateControl : public RemoteRateControl { virtual ~MimdRateControl() {} // Implements RemoteRateControl. - virtual RateControlType GetControlType() const OVERRIDE; - virtual uint32_t GetMinBitrate() const OVERRIDE; - virtual bool ValidEstimate() const OVERRIDE; - virtual int64_t GetFeedbackInterval() const OVERRIDE; - virtual bool TimeToReduceFurther( - int64_t time_now, uint32_t incoming_bitrate_bps) const OVERRIDE; - virtual uint32_t LatestEstimate() const OVERRIDE; - virtual uint32_t UpdateBandwidthEstimate(int64_t now_ms) OVERRIDE; - virtual void SetRtt(int64_t rtt) OVERRIDE; - virtual RateControlRegion Update(const RateControlInput* input, - int64_t now_ms) OVERRIDE; - virtual void SetEstimate(int bitrate_bps, int64_t now_ms) OVERRIDE; + RateControlType GetControlType() const override; + uint32_t GetMinBitrate() const override; + bool ValidEstimate() const override; + int64_t GetFeedbackInterval() const override; + bool TimeToReduceFurther(int64_t time_now, + uint32_t incoming_bitrate_bps) const override; + uint32_t LatestEstimate() const override; + uint32_t UpdateBandwidthEstimate(int64_t now_ms) override; + void SetRtt(int64_t rtt) override; + RateControlRegion Update(const RateControlInput* input, + int64_t now_ms) override; + void SetEstimate(int bitrate_bps, int64_t now_ms) override; private: uint32_t ChangeBitRate(uint32_t current_bit_rate, diff --git a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc index c20683d46..65e540149 100644 --- a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc +++ b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc @@ -111,23 +111,23 @@ class RemoteBitrateEstimatorAbsSendTimeImpl : public RemoteBitrateEstimator { uint32_t min_bitrate_bps); virtual ~RemoteBitrateEstimatorAbsSendTimeImpl() {} - virtual void IncomingPacketFeedbackVector( - const std::vector& packet_feedback_vector) OVERRIDE; + void IncomingPacketFeedbackVector( + const std::vector& packet_feedback_vector) override; - virtual void IncomingPacket(int64_t arrival_time_ms, - size_t payload_size, - const RTPHeader& header) OVERRIDE; + void IncomingPacket(int64_t arrival_time_ms, + size_t payload_size, + const RTPHeader& header) override; // This class relies on Process() being called periodically (at least once // every other second) for streams to be timed out properly. Therefore it // shouldn't be detached from the ProcessThread except if it's about to be // deleted. - virtual int32_t Process() OVERRIDE; - virtual int64_t TimeUntilNextProcess() OVERRIDE; - virtual void OnRttUpdate(int64_t rtt) OVERRIDE; - virtual void RemoveStream(unsigned int ssrc) OVERRIDE; - virtual bool LatestEstimate(std::vector* ssrcs, - unsigned int* bitrate_bps) const OVERRIDE; - virtual bool GetStats(ReceiveBandwidthEstimatorStats* output) const OVERRIDE; + int32_t Process() override; + int64_t TimeUntilNextProcess() override; + void OnRttUpdate(int64_t rtt) override; + void RemoveStream(unsigned int ssrc) override; + bool LatestEstimate(std::vector* ssrcs, + unsigned int* bitrate_bps) const override; + bool GetStats(ReceiveBandwidthEstimatorStats* output) const override; private: typedef std::map Ssrcs; diff --git a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc index f9eef2ac3..72c476d20 100644 --- a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc +++ b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc @@ -36,16 +36,16 @@ class RemoteBitrateEstimatorImpl : public RemoteBitrateEstimator { uint32_t min_bitrate_bps); virtual ~RemoteBitrateEstimatorImpl(); - virtual void IncomingPacket(int64_t arrival_time_ms, - size_t payload_size, - const RTPHeader& header) OVERRIDE; - virtual int32_t Process() OVERRIDE; - virtual int64_t TimeUntilNextProcess() OVERRIDE; - virtual void OnRttUpdate(int64_t rtt) OVERRIDE; - virtual void RemoveStream(unsigned int ssrc) OVERRIDE; - virtual bool LatestEstimate(std::vector* ssrcs, - unsigned int* bitrate_bps) const OVERRIDE; - virtual bool GetStats(ReceiveBandwidthEstimatorStats* output) const OVERRIDE; + void IncomingPacket(int64_t arrival_time_ms, + size_t payload_size, + const RTPHeader& header) override; + int32_t Process() override; + int64_t TimeUntilNextProcess() override; + void OnRttUpdate(int64_t rtt) override; + void RemoveStream(unsigned int ssrc) override; + bool LatestEstimate(std::vector* ssrcs, + unsigned int* bitrate_bps) const override; + bool GetStats(ReceiveBandwidthEstimatorStats* output) const override; private: struct Detector { diff --git a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h index 83cd97fbf..8da880f6c 100644 --- a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h +++ b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h @@ -29,8 +29,8 @@ class TestBitrateObserver : public RemoteBitrateObserver { TestBitrateObserver() : updated_(false), latest_bitrate_(0) {} virtual ~TestBitrateObserver() {} - virtual void OnReceiveBitrateChanged(const std::vector& ssrcs, - unsigned int bitrate) OVERRIDE; + void OnReceiveBitrateChanged(const std::vector& ssrcs, + unsigned int bitrate) override; void Reset() { updated_ = false; } diff --git a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc index c81764ede..d1b9ea79f 100644 --- a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc +++ b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc @@ -267,7 +267,7 @@ class BweFeedbackTest } protected: - virtual void SetUp() OVERRIDE { BweTest::SetUp(); } + void SetUp() override { BweTest::SetUp(); } private: DISALLOW_COPY_AND_ASSIGN(BweFeedbackTest); diff --git a/webrtc/modules/remote_bitrate_estimator/test/bwe.cc b/webrtc/modules/remote_bitrate_estimator/test/bwe.cc index 3221d2b7a..bd22e3eb4 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/bwe.cc +++ b/webrtc/modules/remote_bitrate_estimator/test/bwe.cc @@ -26,12 +26,12 @@ class NullBweSender : public BweSender { NullBweSender() {} virtual ~NullBweSender() {} - virtual int GetFeedbackIntervalMs() const override { return 1000; } - virtual void GiveFeedback(const FeedbackPacket& feedback) override {} - virtual int64_t TimeUntilNextProcess() override { + int GetFeedbackIntervalMs() const override { return 1000; } + void GiveFeedback(const FeedbackPacket& feedback) override {} + int64_t TimeUntilNextProcess() override { return std::numeric_limits::max(); } - virtual int Process() override { return 0; } + int Process() override { return 0; } private: DISALLOW_COPY_AND_ASSIGN(NullBweSender); diff --git a/webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h b/webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h index 902e48ff6..9e893de51 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h +++ b/webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h @@ -403,7 +403,7 @@ class AdaptiveVideoSource : public VideoSource { int64_t first_frame_offset_ms); virtual ~AdaptiveVideoSource() {} - virtual void SetBitrateBps(int bitrate_bps) OVERRIDE; + void SetBitrateBps(int bitrate_bps) override; private: DISALLOW_IMPLICIT_CONSTRUCTORS(AdaptiveVideoSource); @@ -420,9 +420,9 @@ class PeriodicKeyFrameSource : public AdaptiveVideoSource { virtual ~PeriodicKeyFrameSource() {} protected: - virtual uint32_t NextFrameSize() OVERRIDE; - virtual uint32_t NextPacketSize(uint32_t frame_size, - uint32_t remaining_payload) OVERRIDE; + uint32_t NextFrameSize() override; + uint32_t NextPacketSize(uint32_t frame_size, + uint32_t remaining_payload) override; private: int key_frame_interval_; diff --git a/webrtc/modules/remote_bitrate_estimator/test/packet_receiver.h b/webrtc/modules/remote_bitrate_estimator/test/packet_receiver.h index 18fd97832..6d94ea7a0 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/packet_receiver.h +++ b/webrtc/modules/remote_bitrate_estimator/test/packet_receiver.h @@ -32,7 +32,7 @@ class PacketReceiver : public PacketProcessor { ~PacketReceiver(); // Implements PacketProcessor. - virtual void RunFor(int64_t time_ms, Packets* in_out) OVERRIDE; + void RunFor(int64_t time_ms, Packets* in_out) override; void LogStats(); diff --git a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h index e5cbbcb1c..8c13cb16e 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h +++ b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h @@ -37,14 +37,14 @@ class PacketSender : public PacketProcessor, public BitrateObserver { // output of the estimators is sampled and therefore the baseline files may // have to be regenerated. virtual int GetFeedbackIntervalMs() const; - virtual void RunFor(int64_t time_ms, Packets* in_out) OVERRIDE; + void RunFor(int64_t time_ms, Packets* in_out) override; virtual VideoSource* source() const { return source_; } // Implements BitrateObserver. - virtual void OnNetworkChanged(uint32_t target_bitrate_bps, - uint8_t fraction_lost, - int64_t rtt) OVERRIDE; + void OnNetworkChanged(uint32_t target_bitrate_bps, + uint8_t fraction_lost, + int64_t rtt) override; protected: void ProcessFeedbackAndGeneratePackets(int64_t time_ms, @@ -70,19 +70,19 @@ class PacedVideoSender : public PacketSender, public PacedSender::Callback { BandwidthEstimatorType estimator); virtual ~PacedVideoSender(); - virtual void RunFor(int64_t time_ms, Packets* in_out) OVERRIDE; + void RunFor(int64_t time_ms, Packets* in_out) override; // Implements PacedSender::Callback. - virtual bool TimeToSendPacket(uint32_t ssrc, - uint16_t sequence_number, - int64_t capture_time_ms, - bool retransmission) OVERRIDE; - virtual size_t TimeToSendPadding(size_t bytes) OVERRIDE; + bool TimeToSendPacket(uint32_t ssrc, + uint16_t sequence_number, + int64_t capture_time_ms, + bool retransmission) override; + size_t TimeToSendPadding(size_t bytes) override; // Implements BitrateObserver. - virtual void OnNetworkChanged(uint32_t target_bitrate_bps, - uint8_t fraction_lost, - int64_t rtt) OVERRIDE; + void OnNetworkChanged(uint32_t target_bitrate_bps, + uint8_t fraction_lost, + int64_t rtt) override; private: int64_t TimeUntilNextProcess(const std::list& modules); diff --git a/webrtc/modules/rtp_rtcp/interface/receive_statistics.h b/webrtc/modules/rtp_rtcp/interface/receive_statistics.h index 3bd953f0d..f7de91fc4 100644 --- a/webrtc/modules/rtp_rtcp/interface/receive_statistics.h +++ b/webrtc/modules/rtp_rtcp/interface/receive_statistics.h @@ -85,20 +85,20 @@ class ReceiveStatistics : public Module { class NullReceiveStatistics : public ReceiveStatistics { public: - virtual void IncomingPacket(const RTPHeader& rtp_header, - size_t packet_length, - bool retransmitted) OVERRIDE; - virtual void FecPacketReceived(const RTPHeader& header, - size_t packet_length) OVERRIDE; - virtual StatisticianMap GetActiveStatisticians() const OVERRIDE; - virtual StreamStatistician* GetStatistician(uint32_t ssrc) const OVERRIDE; - virtual int64_t TimeUntilNextProcess() OVERRIDE; - virtual int32_t Process() OVERRIDE; - virtual void SetMaxReorderingThreshold(int max_reordering_threshold) OVERRIDE; - virtual void RegisterRtcpStatisticsCallback(RtcpStatisticsCallback* callback) - OVERRIDE; - virtual void RegisterRtpStatisticsCallback( - StreamDataCountersCallback* callback) OVERRIDE; + void IncomingPacket(const RTPHeader& rtp_header, + size_t packet_length, + bool retransmitted) override; + void FecPacketReceived(const RTPHeader& header, + size_t packet_length) override; + StatisticianMap GetActiveStatisticians() const override; + StreamStatistician* GetStatistician(uint32_t ssrc) const override; + int64_t TimeUntilNextProcess() override; + int32_t Process() override; + void SetMaxReorderingThreshold(int max_reordering_threshold) override; + void RegisterRtcpStatisticsCallback( + RtcpStatisticsCallback* callback) override; + void RegisterRtpStatisticsCallback( + StreamDataCountersCallback* callback) override; }; } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h index 76091a16c..4938b5fef 100644 --- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h +++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h @@ -307,24 +307,22 @@ class NullRtpFeedback : public RtpFeedback { public: virtual ~NullRtpFeedback() {} - virtual int32_t OnInitializeDecoder( - const int32_t id, - const int8_t payloadType, - const char payloadName[RTP_PAYLOAD_NAME_SIZE], - const int frequency, - const uint8_t channels, - const uint32_t rate) OVERRIDE { + int32_t OnInitializeDecoder(const int32_t id, + const int8_t payloadType, + const char payloadName[RTP_PAYLOAD_NAME_SIZE], + const int frequency, + const uint8_t channels, + const uint32_t rate) override { return 0; } - virtual void OnIncomingSSRCChanged(const int32_t id, - const uint32_t ssrc) OVERRIDE {} + void OnIncomingSSRCChanged(const int32_t id, const uint32_t ssrc) override {} - virtual void OnIncomingCSRCChanged(const int32_t id, - const uint32_t CSRC, - const bool added) OVERRIDE {} + void OnIncomingCSRCChanged(const int32_t id, + const uint32_t CSRC, + const bool added) override {} - virtual void ResetStatistics(uint32_t ssrc) OVERRIDE {} + void ResetStatistics(uint32_t ssrc) override {} }; // Null object version of RtpData. @@ -332,15 +330,13 @@ class NullRtpData : public RtpData { public: virtual ~NullRtpData() {} - virtual int32_t OnReceivedPayloadData( - const uint8_t* payloadData, - const size_t payloadSize, - const WebRtcRTPHeader* rtpHeader) OVERRIDE { + int32_t OnReceivedPayloadData(const uint8_t* payloadData, + const size_t payloadSize, + const WebRtcRTPHeader* rtpHeader) override { return 0; } - virtual bool OnRecoveredPacket(const uint8_t* packet, - size_t packet_length) OVERRIDE { + bool OnRecoveredPacket(const uint8_t* packet, size_t packet_length) override { return true; } }; @@ -350,10 +346,10 @@ class NullRtpAudioFeedback : public RtpAudioFeedback { public: virtual ~NullRtpAudioFeedback() {} - virtual void OnPlayTelephoneEvent(const int32_t id, - const uint8_t event, - const uint16_t lengthMs, - const uint8_t volume) OVERRIDE {} + void OnPlayTelephoneEvent(const int32_t id, + const uint8_t event, + const uint16_t lengthMs, + const uint8_t volume) override {} }; } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h b/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h index 2f4b0fbae..24db39b90 100644 --- a/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h +++ b/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h @@ -28,14 +28,14 @@ class FecReceiverImpl : public FecReceiver { FecReceiverImpl(RtpData* callback); virtual ~FecReceiverImpl(); - virtual int32_t AddReceivedRedPacket(const RTPHeader& rtp_header, - const uint8_t* incoming_rtp_packet, - size_t packet_length, - uint8_t ulpfec_payload_type) OVERRIDE; + int32_t AddReceivedRedPacket(const RTPHeader& rtp_header, + const uint8_t* incoming_rtp_packet, + size_t packet_length, + uint8_t ulpfec_payload_type) override; - virtual int32_t ProcessReceivedFec() OVERRIDE; + int32_t ProcessReceivedFec() override; - virtual FecPacketCounter GetPacketCounter() const OVERRIDE; + FecPacketCounter GetPacketCounter() const override; private: rtc::scoped_ptr crit_sect_; diff --git a/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc b/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc index e7022b5e1..e5c4faff3 100644 --- a/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc @@ -38,10 +38,10 @@ class VerifyingRtxReceiver : public NullRtpData public: VerifyingRtxReceiver() {} - virtual int32_t OnReceivedPayloadData( + int32_t OnReceivedPayloadData( const uint8_t* data, const size_t size, - const webrtc::WebRtcRTPHeader* rtp_header) OVERRIDE { + const webrtc::WebRtcRTPHeader* rtp_header) override { if (!sequence_numbers_.empty()) EXPECT_EQ(kTestSsrc, rtp_header->header.ssrc); sequence_numbers_.push_back(rtp_header->header.sequenceNumber); @@ -55,8 +55,7 @@ class TestRtpFeedback : public NullRtpFeedback { TestRtpFeedback(RtpRtcp* rtp_rtcp) : rtp_rtcp_(rtp_rtcp) {} virtual ~TestRtpFeedback() {} - virtual void OnIncomingSSRCChanged(const int32_t id, - const uint32_t ssrc) OVERRIDE { + void OnIncomingSSRCChanged(const int32_t id, const uint32_t ssrc) override { rtp_rtcp_->SetRemoteSSRC(ssrc); } @@ -95,7 +94,7 @@ class RtxLoopBackTransport : public webrtc::Transport { packet_loss_ = 0; } - virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE { + int SendPacket(int channel, const void* data, size_t len) override { count_++; const unsigned char* ptr = static_cast(data); uint32_t ssrc = (ptr[8] << 24) + (ptr[9] << 16) + (ptr[10] << 8) + ptr[11]; @@ -146,9 +145,7 @@ class RtxLoopBackTransport : public webrtc::Transport { return static_cast(len); } - virtual int SendRTCPPacket(int channel, - const void *data, - size_t len) OVERRIDE { + int SendRTCPPacket(int channel, const void* data, size_t len) override { if (module_->IncomingRtcpPacket((const uint8_t*)data, len) == 0) { return static_cast(len); } @@ -177,7 +174,7 @@ class RtpRtcpRtxNackTest : public ::testing::Test { fake_clock(123456) {} ~RtpRtcpRtxNackTest() {} - virtual void SetUp() OVERRIDE { + void SetUp() override { RtpRtcp::Configuration configuration; configuration.id = kTestId; configuration.audio = false; @@ -284,9 +281,7 @@ class RtpRtcpRtxNackTest : public ::testing::Test { receiver_.sequence_numbers_.sort(); } - virtual void TearDown() OVERRIDE { - delete rtp_rtcp_module_; - } + void TearDown() override { delete rtp_rtcp_module_; } rtc::scoped_ptr receive_statistics_; RTPPayloadRegistry rtp_payload_registry_; diff --git a/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h b/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h index 78280364e..cd41744d8 100644 --- a/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h +++ b/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h @@ -30,16 +30,16 @@ class StreamStatisticianImpl : public StreamStatistician { StreamDataCountersCallback* rtp_callback); virtual ~StreamStatisticianImpl() {} - virtual bool GetStatistics(RtcpStatistics* statistics, bool reset) OVERRIDE; - virtual void GetDataCounters(size_t* bytes_received, - uint32_t* packets_received) const OVERRIDE; - virtual void GetReceiveStreamDataCounters( - StreamDataCounters* data_counters) const OVERRIDE; - virtual uint32_t BitrateReceived() const OVERRIDE; - virtual void ResetStatistics() OVERRIDE; - virtual bool IsRetransmitOfOldPacket(const RTPHeader& header, - int64_t min_rtt) const OVERRIDE; - virtual bool IsPacketInOrder(uint16_t sequence_number) const OVERRIDE; + bool GetStatistics(RtcpStatistics* statistics, bool reset) override; + void GetDataCounters(size_t* bytes_received, + uint32_t* packets_received) const override; + void GetReceiveStreamDataCounters( + StreamDataCounters* data_counters) const override; + uint32_t BitrateReceived() const override; + void ResetStatistics() override; + bool IsRetransmitOfOldPacket(const RTPHeader& header, + int64_t min_rtt) const override; + bool IsPacketInOrder(uint16_t sequence_number) const override; void IncomingPacket(const RTPHeader& rtp_header, size_t packet_length, @@ -107,31 +107,31 @@ class ReceiveStatisticsImpl : public ReceiveStatistics, ~ReceiveStatisticsImpl(); // Implement ReceiveStatistics. - virtual void IncomingPacket(const RTPHeader& header, - size_t packet_length, - bool retransmitted) OVERRIDE; - virtual void FecPacketReceived(const RTPHeader& header, - size_t packet_length) OVERRIDE; - virtual StatisticianMap GetActiveStatisticians() const OVERRIDE; - virtual StreamStatistician* GetStatistician(uint32_t ssrc) const OVERRIDE; - virtual void SetMaxReorderingThreshold(int max_reordering_threshold) OVERRIDE; + void IncomingPacket(const RTPHeader& header, + size_t packet_length, + bool retransmitted) override; + void FecPacketReceived(const RTPHeader& header, + size_t packet_length) override; + StatisticianMap GetActiveStatisticians() const override; + StreamStatistician* GetStatistician(uint32_t ssrc) const override; + void SetMaxReorderingThreshold(int max_reordering_threshold) override; // Implement Module. - virtual int32_t Process() OVERRIDE; - virtual int64_t TimeUntilNextProcess() OVERRIDE; + int32_t Process() override; + int64_t TimeUntilNextProcess() override; - virtual void RegisterRtcpStatisticsCallback(RtcpStatisticsCallback* callback) - OVERRIDE; + void RegisterRtcpStatisticsCallback( + RtcpStatisticsCallback* callback) override; - virtual void RegisterRtpStatisticsCallback( - StreamDataCountersCallback* callback) OVERRIDE; + void RegisterRtpStatisticsCallback( + StreamDataCountersCallback* callback) override; private: - virtual void StatisticsUpdated(const RtcpStatistics& statistics, - uint32_t ssrc) OVERRIDE; - virtual void CNameChanged(const char* cname, uint32_t ssrc) OVERRIDE; - virtual void DataCountersUpdated(const StreamDataCounters& counters, - uint32_t ssrc) OVERRIDE; + void StatisticsUpdated(const RtcpStatistics& statistics, + uint32_t ssrc) override; + void CNameChanged(const char* cname, uint32_t ssrc) override; + void DataCountersUpdated(const StreamDataCounters& counters, + uint32_t ssrc) override; typedef std::map StatisticianImplMap; diff --git a/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc b/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc index 7da5285fd..8b25bcf61 100644 --- a/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc @@ -169,7 +169,7 @@ TEST_F(ReceiveStatisticsTest, RtcpCallbacks) { ++num_calls_; } - virtual void CNameChanged(const char* cname, uint32_t ssrc) OVERRIDE {} + void CNameChanged(const char* cname, uint32_t ssrc) override {} uint32_t num_calls_; uint32_t ssrc_; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc index cb8928759..3c1a9a3fc 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc @@ -30,14 +30,14 @@ class TestTransport : public Transport { rtcp_receiver_(rtcp_receiver) { } - virtual int SendPacket(int /*channel*/, - const void* /*data*/, - size_t /*len*/) OVERRIDE { + int SendPacket(int /*channel*/, + const void* /*data*/, + size_t /*len*/) override { return -1; } - virtual int SendRTCPPacket(int /*channel*/, - const void *packet, - size_t packetLength) OVERRIDE { + int SendRTCPPacket(int /*channel*/, + const void* packet, + size_t packetLength) override { RTCPUtility::RTCPParserV2 rtcpParser((uint8_t*)packet, packetLength, true); // Allow non-compound RTCP @@ -73,8 +73,8 @@ class RtcpFormatRembTest : public ::testing::Test { system_clock_, kMimdControl, kRemoteBitrateEstimatorMinBitrateBps)) {} - virtual void SetUp() OVERRIDE; - virtual void TearDown() OVERRIDE; + void SetUp() override; + void TearDown() override; OverUseDetectorOptions over_use_detector_options_; Clock* system_clock_; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h index 0ea98a280..150b5b409 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h @@ -90,8 +90,9 @@ class Empty : public RtcpPacket { virtual ~Empty() {} protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: DISALLOW_COPY_AND_ASSIGN(Empty); @@ -204,8 +205,9 @@ class SenderReport : public RtcpPacket { void WithReportBlock(ReportBlock* block); protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: enum { kMaxNumberOfReportBlocks = 0x1f }; @@ -250,8 +252,9 @@ class ReceiverReport : public RtcpPacket { void WithReportBlock(ReportBlock* block); protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: enum { kMaxNumberOfReportBlocks = 0x1f }; @@ -295,8 +298,9 @@ class Ij : public RtcpPacket { void WithJitterItem(uint32_t jitter); protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: enum { kMaxNumberOfIjItems = 0x1f }; @@ -351,8 +355,9 @@ class Sdes : public RtcpPacket { }; protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: enum { kMaxNumberOfChunks = 0x1f }; @@ -392,8 +397,9 @@ class Bye : public RtcpPacket { void WithCsrc(uint32_t csrc); protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: enum { kMaxNumberOfCsrcs = 0x1f - 1 }; @@ -452,8 +458,9 @@ class App : public RtcpPacket { } protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: size_t BlockLength() const { @@ -502,8 +509,9 @@ class Pli : public RtcpPacket { } protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: size_t BlockLength() const { @@ -553,8 +561,9 @@ class Sli : public RtcpPacket { } protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: size_t BlockLength() const { @@ -594,8 +603,9 @@ class Nack : public RtcpPacket { void WithList(const uint16_t* nack_list, int length); protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: size_t BlockLength() const { @@ -644,8 +654,9 @@ class Rpsi : public RtcpPacket { void WithPictureId(uint64_t picture_id); protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: size_t BlockLength() const { @@ -691,8 +702,9 @@ class Fir : public RtcpPacket { } protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: size_t BlockLength() const { @@ -740,8 +752,9 @@ class Tmmbr : public RtcpPacket { } protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: size_t BlockLength() const { @@ -781,8 +794,9 @@ class Tmmbn : public RtcpPacket { void WithTmmbr(uint32_t ssrc, uint32_t bitrate_kbps, uint16_t overhead); protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: enum { kMaxNumberOfTmmbrs = 50 }; @@ -836,8 +850,9 @@ class Remb : public RtcpPacket { } protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: enum { kMaxNumberOfSsrcs = 0xff }; @@ -883,8 +898,9 @@ class Xr : public RtcpPacket { void WithVoipMetric(VoipMetric* voip_metric); protected: - virtual void Create( - uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE; + void Create(uint8_t* packet, + size_t* length, + size_t max_length) const override; private: enum { kMaxNumberOfRrtrBlocks = 50 }; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc index f90c598d8..f2ea04be5 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc @@ -39,24 +39,22 @@ class TestTransport : public Transport, void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) { rtcp_receiver_ = rtcp_receiver; } - virtual int SendPacket(int /*ch*/, - const void* /*data*/, - size_t /*len*/) OVERRIDE { + int SendPacket(int /*ch*/, const void* /*data*/, size_t /*len*/) override { ADD_FAILURE(); // FAIL() gives a compile error. return -1; } // Injects an RTCP packet into the receiver. - virtual int SendRTCPPacket(int /* ch */, - const void *packet, - size_t packet_len) OVERRIDE { + int SendRTCPPacket(int /* ch */, + const void* packet, + size_t packet_len) override { ADD_FAILURE(); return 0; } - virtual int OnReceivedPayloadData(const uint8_t* payloadData, - const size_t payloadSize, - const WebRtcRTPHeader* rtpHeader) OVERRIDE { + int OnReceivedPayloadData(const uint8_t* payloadData, + const size_t payloadSize, + const WebRtcRTPHeader* rtpHeader) override { ADD_FAILURE(); return 0; } @@ -966,13 +964,13 @@ TEST_F(RtcpReceiverTest, Callbacks) { RtcpCallbackImpl() : RtcpStatisticsCallback(), ssrc_(0) {} virtual ~RtcpCallbackImpl() {} - virtual void StatisticsUpdated(const RtcpStatistics& statistics, - uint32_t ssrc) OVERRIDE { + void StatisticsUpdated(const RtcpStatistics& statistics, + uint32_t ssrc) override { stats_ = statistics; ssrc_ = ssrc; } - virtual void CNameChanged(const char* cname, uint32_t ssrc) OVERRIDE {} + void CNameChanged(const char* cname, uint32_t ssrc) override {} bool Matches(uint32_t ssrc, uint32_t extended_max, uint8_t fraction_loss, uint32_t cumulative_loss, uint32_t jitter) { diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc index 5563b0dce..a35b7c382 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc @@ -227,15 +227,13 @@ class TestTransport : public Transport, void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) { rtcp_receiver_ = rtcp_receiver; } - virtual int SendPacket(int /*ch*/, - const void* /*data*/, - size_t /*len*/) OVERRIDE { + int SendPacket(int /*ch*/, const void* /*data*/, size_t /*len*/) override { return -1; } - virtual int SendRTCPPacket(int /*ch*/, - const void *packet, - size_t packet_len) OVERRIDE { + int SendRTCPPacket(int /*ch*/, + const void* packet, + size_t packet_len) override { RTCPUtility::RTCPParserV2 rtcpParser((uint8_t*)packet, packet_len, true); // Allow non-compound RTCP @@ -265,9 +263,9 @@ class TestTransport : public Transport, return static_cast(packet_len); } - virtual int OnReceivedPayloadData(const uint8_t* payloadData, - const size_t payloadSize, - const WebRtcRTPHeader* rtpHeader) OVERRIDE { + int OnReceivedPayloadData(const uint8_t* payloadData, + const size_t payloadSize, + const WebRtcRTPHeader* rtpHeader) override { return 0; } RTCPReceiver* rtcp_receiver_; diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_h264.h b/webrtc/modules/rtp_rtcp/source/rtp_format_h264.h index ba293c853..4e92895c6 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_format_h264.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_format_h264.h @@ -26,10 +26,9 @@ class RtpPacketizerH264 : public RtpPacketizer { virtual ~RtpPacketizerH264(); - virtual void SetPayloadData( - const uint8_t* payload_data, - size_t payload_size, - const RTPFragmentationHeader* fragmentation) OVERRIDE; + void SetPayloadData(const uint8_t* payload_data, + size_t payload_size, + const RTPFragmentationHeader* fragmentation) override; // Get the next payload with H264 payload header. // buffer is a pointer to where the output will be written. @@ -38,15 +37,15 @@ class RtpPacketizerH264 : public RtpPacketizer { // the frame, false otherwise (i.e., call the function again to get the // next packet). // Returns true on success or false if there was no payload to packetize. - virtual bool NextPacket(uint8_t* buffer, - size_t* bytes_to_send, - bool* last_packet) OVERRIDE; + bool NextPacket(uint8_t* buffer, + size_t* bytes_to_send, + bool* last_packet) override; - virtual ProtectionType GetProtectionType() OVERRIDE; + ProtectionType GetProtectionType() override; - virtual StorageType GetStorageType(uint32_t retransmission_settings) OVERRIDE; + StorageType GetStorageType(uint32_t retransmission_settings) override; - virtual std::string ToString() OVERRIDE; + std::string ToString() override; private: struct Packet { @@ -95,9 +94,9 @@ class RtpDepacketizerH264 : public RtpDepacketizer { public: virtual ~RtpDepacketizerH264() {} - virtual bool Parse(ParsedPayload* parsed_payload, - const uint8_t* payload_data, - size_t payload_data_length) OVERRIDE; + bool Parse(ParsedPayload* parsed_payload, + const uint8_t* payload_data, + size_t payload_data_length) override; }; } // namespace webrtc #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_H264_H_ diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h b/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h index 2fd6aad1b..2e7bca5c4 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h @@ -30,10 +30,9 @@ class RtpPacketizerGeneric : public RtpPacketizer { virtual ~RtpPacketizerGeneric(); - virtual void SetPayloadData( - const uint8_t* payload_data, - size_t payload_size, - const RTPFragmentationHeader* fragmentation) OVERRIDE; + void SetPayloadData(const uint8_t* payload_data, + size_t payload_size, + const RTPFragmentationHeader* fragmentation) override; // Get the next payload with generic payload header. // buffer is a pointer to where the output will be written. @@ -42,15 +41,15 @@ class RtpPacketizerGeneric : public RtpPacketizer { // the frame, false otherwise (i.e., call the function again to get the // next packet). // Returns true on success or false if there was no payload to packetize. - virtual bool NextPacket(uint8_t* buffer, - size_t* bytes_to_send, - bool* last_packet) OVERRIDE; + bool NextPacket(uint8_t* buffer, + size_t* bytes_to_send, + bool* last_packet) override; - virtual ProtectionType GetProtectionType() OVERRIDE; + ProtectionType GetProtectionType() override; - virtual StorageType GetStorageType(uint32_t retransmission_settings) OVERRIDE; + StorageType GetStorageType(uint32_t retransmission_settings) override; - virtual std::string ToString() OVERRIDE; + std::string ToString() override; private: const uint8_t* payload_data_; @@ -68,9 +67,9 @@ class RtpDepacketizerGeneric : public RtpDepacketizer { public: virtual ~RtpDepacketizerGeneric() {} - virtual bool Parse(ParsedPayload* parsed_payload, - const uint8_t* payload_data, - size_t payload_data_length) OVERRIDE; + bool Parse(ParsedPayload* parsed_payload, + const uint8_t* payload_data, + size_t payload_data_length) override; }; } // namespace webrtc #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VIDEO_GENERIC_H_ diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h index dab7921b0..d73dfc1b5 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h @@ -60,10 +60,9 @@ class RtpPacketizerVp8 : public RtpPacketizer { virtual ~RtpPacketizerVp8(); - virtual void SetPayloadData( - const uint8_t* payload_data, - size_t payload_size, - const RTPFragmentationHeader* fragmentation) OVERRIDE; + void SetPayloadData(const uint8_t* payload_data, + size_t payload_size, + const RTPFragmentationHeader* fragmentation) override; // Get the next payload with VP8 payload header. // max_payload_len limits the sum length of payload and VP8 payload header. @@ -76,15 +75,15 @@ class RtpPacketizerVp8 : public RtpPacketizer { // the first payload byte in the packet is taken, with the first partition // having index 0; returns negative on error. // For the kEqualSize mode: returns 0 on success, return negative on error. - virtual bool NextPacket(uint8_t* buffer, - size_t* bytes_to_send, - bool* last_packet) OVERRIDE; + bool NextPacket(uint8_t* buffer, + size_t* bytes_to_send, + bool* last_packet) override; - virtual ProtectionType GetProtectionType() OVERRIDE; + ProtectionType GetProtectionType() override; - virtual StorageType GetStorageType(uint32_t retransmission_settings) OVERRIDE; + StorageType GetStorageType(uint32_t retransmission_settings) override; - virtual std::string ToString() OVERRIDE; + std::string ToString() override; private: typedef struct { @@ -221,9 +220,9 @@ class RtpDepacketizerVp8 : public RtpDepacketizer { public: virtual ~RtpDepacketizerVp8() {} - virtual bool Parse(ParsedPayload* parsed_payload, - const uint8_t* payload_data, - size_t payload_data_length) OVERRIDE; + bool Parse(ParsedPayload* parsed_payload, + const uint8_t* payload_data, + size_t payload_data_length) override; }; } // namespace webrtc #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VP8_H_ diff --git a/webrtc/modules/rtp_rtcp/source/rtp_header_parser.cc b/webrtc/modules/rtp_rtcp/source/rtp_header_parser.cc index 9a4cb6466..0b8280de1 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_header_parser.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_header_parser.cc @@ -21,14 +21,13 @@ class RtpHeaderParserImpl : public RtpHeaderParser { RtpHeaderParserImpl(); virtual ~RtpHeaderParserImpl() {} - virtual bool Parse(const uint8_t* packet, - size_t length, - RTPHeader* header) const OVERRIDE; + bool Parse(const uint8_t* packet, + size_t length, + RTPHeader* header) const override; - virtual bool RegisterRtpHeaderExtension(RTPExtensionType type, - uint8_t id) OVERRIDE; + bool RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id) override; - virtual bool DeregisterRtpHeaderExtension(RTPExtensionType type) OVERRIDE; + bool DeregisterRtpHeaderExtension(RTPExtensionType type) override; private: rtc::scoped_ptr critical_section_; diff --git a/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc b/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc index 25be1a587..9a98e2ad8 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc @@ -368,12 +368,12 @@ bool RTPPayloadRegistry::ReportMediaPayloadType(uint8_t media_payload_type) { class RTPPayloadAudioStrategy : public RTPPayloadStrategy { public: - virtual bool CodecsMustBeUnique() const OVERRIDE { return true; } + bool CodecsMustBeUnique() const override { return true; } - virtual bool PayloadIsCompatible(const RtpUtility::Payload& payload, - const uint32_t frequency, - const uint8_t channels, - const uint32_t rate) const OVERRIDE { + bool PayloadIsCompatible(const RtpUtility::Payload& payload, + const uint32_t frequency, + const uint8_t channels, + const uint32_t rate) const override { return payload.audio && payload.typeSpecific.Audio.frequency == frequency && @@ -382,17 +382,17 @@ class RTPPayloadAudioStrategy : public RTPPayloadStrategy { payload.typeSpecific.Audio.rate == 0 || rate == 0); } - virtual void UpdatePayloadRate(RtpUtility::Payload* payload, - const uint32_t rate) const OVERRIDE { + void UpdatePayloadRate(RtpUtility::Payload* payload, + const uint32_t rate) const override { payload->typeSpecific.Audio.rate = rate; } - virtual RtpUtility::Payload* CreatePayloadType( + RtpUtility::Payload* CreatePayloadType( const char payloadName[RTP_PAYLOAD_NAME_SIZE], const int8_t payloadType, const uint32_t frequency, const uint8_t channels, - const uint32_t rate) const OVERRIDE { + const uint32_t rate) const override { RtpUtility::Payload* payload = new RtpUtility::Payload; payload->name[RTP_PAYLOAD_NAME_SIZE - 1] = 0; strncpy(payload->name, payloadName, RTP_PAYLOAD_NAME_SIZE - 1); @@ -411,26 +411,26 @@ class RTPPayloadAudioStrategy : public RTPPayloadStrategy { class RTPPayloadVideoStrategy : public RTPPayloadStrategy { public: - virtual bool CodecsMustBeUnique() const OVERRIDE { return false; } + bool CodecsMustBeUnique() const override { return false; } - virtual bool PayloadIsCompatible(const RtpUtility::Payload& payload, - const uint32_t frequency, - const uint8_t channels, - const uint32_t rate) const OVERRIDE { + bool PayloadIsCompatible(const RtpUtility::Payload& payload, + const uint32_t frequency, + const uint8_t channels, + const uint32_t rate) const override { return !payload.audio; } - virtual void UpdatePayloadRate(RtpUtility::Payload* payload, - const uint32_t rate) const OVERRIDE { + void UpdatePayloadRate(RtpUtility::Payload* payload, + const uint32_t rate) const override { payload->typeSpecific.Video.maxRate = rate; } - virtual RtpUtility::Payload* CreatePayloadType( + RtpUtility::Payload* CreatePayloadType( const char payloadName[RTP_PAYLOAD_NAME_SIZE], const int8_t payloadType, const uint32_t frequency, const uint8_t channels, - const uint32_t rate) const OVERRIDE { + const uint32_t rate) const override { RtpVideoCodecTypes videoType = kRtpVideoGeneric; if (RtpUtility::StringCompare(payloadName, "VP8", 3)) { videoType = kRtpVideoVp8; diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h index 9ca87f6f7..cd146b933 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h @@ -53,32 +53,31 @@ class RTPReceiverAudio : public RTPReceiverStrategy, uint32_t* frequency, bool* cng_payload_type_has_changed); - virtual int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header, - const PayloadUnion& specific_payload, - bool is_red, - const uint8_t* packet, - size_t payload_length, - int64_t timestamp_ms, - bool is_first_packet) OVERRIDE; + int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header, + const PayloadUnion& specific_payload, + bool is_red, + const uint8_t* packet, + size_t payload_length, + int64_t timestamp_ms, + bool is_first_packet) override; - int GetPayloadTypeFrequency() const OVERRIDE; + int GetPayloadTypeFrequency() const override; - virtual RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const - OVERRIDE; + RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const override; - virtual bool ShouldReportCsrcChanges(uint8_t payload_type) const OVERRIDE; + bool ShouldReportCsrcChanges(uint8_t payload_type) const override; - virtual int32_t OnNewPayloadTypeCreated( + int32_t OnNewPayloadTypeCreated( const char payload_name[RTP_PAYLOAD_NAME_SIZE], int8_t payload_type, - uint32_t frequency) OVERRIDE; + uint32_t frequency) override; - virtual int32_t InvokeOnInitializeDecoder( + int32_t InvokeOnInitializeDecoder( RtpFeedback* callback, int32_t id, int8_t payload_type, const char payload_name[RTP_PAYLOAD_NAME_SIZE], - const PayloadUnion& specific_payload) const OVERRIDE; + const PayloadUnion& specific_payload) const override; // We do not allow codecs to have multiple payload types for audio, so we // need to override the default behavior (which is to do nothing). @@ -95,9 +94,9 @@ class RTPReceiverAudio : public RTPReceiverStrategy, void CheckPayloadChanged(int8_t payload_type, PayloadUnion* specific_payload, bool* should_reset_statistics, - bool* should_discard_changes) OVERRIDE; + bool* should_discard_changes) override; - int Energy(uint8_t array_of_energy[kRtpCsrcSize]) const OVERRIDE; + int Energy(uint8_t array_of_energy[kRtpCsrcSize]) const override; private: diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h index 3b2bbf6a5..539c22676 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h @@ -34,38 +34,36 @@ class RtpReceiverImpl : public RtpReceiver { virtual ~RtpReceiverImpl(); - virtual int32_t RegisterReceivePayload( - const char payload_name[RTP_PAYLOAD_NAME_SIZE], - const int8_t payload_type, - const uint32_t frequency, - const uint8_t channels, - const uint32_t rate) OVERRIDE; + int32_t RegisterReceivePayload(const char payload_name[RTP_PAYLOAD_NAME_SIZE], + const int8_t payload_type, + const uint32_t frequency, + const uint8_t channels, + const uint32_t rate) override; - virtual int32_t DeRegisterReceivePayload(const int8_t payload_type) OVERRIDE; + int32_t DeRegisterReceivePayload(const int8_t payload_type) override; - virtual bool IncomingRtpPacket( - const RTPHeader& rtp_header, - const uint8_t* payload, - size_t payload_length, - PayloadUnion payload_specific, - bool in_order) OVERRIDE; + bool IncomingRtpPacket(const RTPHeader& rtp_header, + const uint8_t* payload, + size_t payload_length, + PayloadUnion payload_specific, + bool in_order) override; - virtual NACKMethod NACK() const OVERRIDE; + NACKMethod NACK() const override; // Turn negative acknowledgement requests on/off. - virtual void SetNACKStatus(const NACKMethod method) OVERRIDE; + void SetNACKStatus(const NACKMethod method) override; // Returns the last received timestamp. - virtual bool Timestamp(uint32_t* timestamp) const OVERRIDE; - virtual bool LastReceivedTimeMs(int64_t* receive_time_ms) const OVERRIDE; + bool Timestamp(uint32_t* timestamp) const override; + bool LastReceivedTimeMs(int64_t* receive_time_ms) const override; - virtual uint32_t SSRC() const OVERRIDE; + uint32_t SSRC() const override; - virtual int32_t CSRCs(uint32_t array_of_csrc[kRtpCsrcSize]) const OVERRIDE; + int32_t CSRCs(uint32_t array_of_csrc[kRtpCsrcSize]) const override; - virtual int32_t Energy(uint8_t array_of_energy[kRtpCsrcSize]) const OVERRIDE; + int32_t Energy(uint8_t array_of_energy[kRtpCsrcSize]) const override; - virtual TelephoneEventHandler* GetTelephoneEventHandler() OVERRIDE; + TelephoneEventHandler* GetTelephoneEventHandler() override; private: bool HaveReceivedFrame() const; diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h index c355e802e..d617d0a85 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h @@ -26,34 +26,33 @@ class RTPReceiverVideo : public RTPReceiverStrategy { virtual ~RTPReceiverVideo(); - virtual int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header, - const PayloadUnion& specific_payload, - bool is_red, - const uint8_t* packet, - size_t packet_length, - int64_t timestamp, - bool is_first_packet) OVERRIDE; + int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header, + const PayloadUnion& specific_payload, + bool is_red, + const uint8_t* packet, + size_t packet_length, + int64_t timestamp, + bool is_first_packet) override; TelephoneEventHandler* GetTelephoneEventHandler() { return NULL; } - int GetPayloadTypeFrequency() const OVERRIDE; + int GetPayloadTypeFrequency() const override; - virtual RTPAliveType ProcessDeadOrAlive( - uint16_t last_payload_length) const OVERRIDE; + RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const override; - virtual bool ShouldReportCsrcChanges(uint8_t payload_type) const OVERRIDE; + bool ShouldReportCsrcChanges(uint8_t payload_type) const override; - virtual int32_t OnNewPayloadTypeCreated( + int32_t OnNewPayloadTypeCreated( const char payload_name[RTP_PAYLOAD_NAME_SIZE], int8_t payload_type, - uint32_t frequency) OVERRIDE; + uint32_t frequency) override; - virtual int32_t InvokeOnInitializeDecoder( + int32_t InvokeOnInitializeDecoder( RtpFeedback* callback, int32_t id, int8_t payload_type, const char payload_name[RTP_PAYLOAD_NAME_SIZE], - const PayloadUnion& specific_payload) const OVERRIDE; + const PayloadUnion& specific_payload) const override; void SetPacketOverHead(uint16_t packet_over_head); diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h index 2b88aefe0..4c007ebf4 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h @@ -29,277 +29,268 @@ class ModuleRtpRtcpImpl : public RtpRtcp { // Returns the number of milliseconds until the module want a worker thread to // call Process. - virtual int64_t TimeUntilNextProcess() OVERRIDE; + int64_t TimeUntilNextProcess() override; // Process any pending tasks such as timeouts. - virtual int32_t Process() OVERRIDE; + int32_t Process() override; // Receiver part. // Called when we receive an RTCP packet. - virtual int32_t IncomingRtcpPacket(const uint8_t* incoming_packet, - size_t incoming_packet_length) OVERRIDE; + int32_t IncomingRtcpPacket(const uint8_t* incoming_packet, + size_t incoming_packet_length) override; - virtual void SetRemoteSSRC(uint32_t ssrc) OVERRIDE; + void SetRemoteSSRC(uint32_t ssrc) override; // Sender part. - virtual int32_t RegisterSendPayload(const CodecInst& voice_codec) OVERRIDE; + int32_t RegisterSendPayload(const CodecInst& voice_codec) override; - virtual int32_t RegisterSendPayload(const VideoCodec& video_codec) OVERRIDE; + int32_t RegisterSendPayload(const VideoCodec& video_codec) override; - virtual int32_t DeRegisterSendPayload(int8_t payload_type) OVERRIDE; + int32_t DeRegisterSendPayload(int8_t payload_type) override; int8_t SendPayloadType() const; // Register RTP header extension. - virtual int32_t RegisterSendRtpHeaderExtension(RTPExtensionType type, - uint8_t id) OVERRIDE; + int32_t RegisterSendRtpHeaderExtension(RTPExtensionType type, + uint8_t id) override; - virtual int32_t DeregisterSendRtpHeaderExtension( - RTPExtensionType type) OVERRIDE; + int32_t DeregisterSendRtpHeaderExtension(RTPExtensionType type) override; // Get start timestamp. - virtual uint32_t StartTimestamp() const OVERRIDE; + uint32_t StartTimestamp() const override; // Configure start timestamp, default is a random number. - virtual void SetStartTimestamp(uint32_t timestamp) OVERRIDE; + void SetStartTimestamp(uint32_t timestamp) override; - virtual uint16_t SequenceNumber() const OVERRIDE; + uint16_t SequenceNumber() const override; // Set SequenceNumber, default is a random number. - virtual void SetSequenceNumber(uint16_t seq) OVERRIDE; + void SetSequenceNumber(uint16_t seq) override; - virtual bool SetRtpStateForSsrc(uint32_t ssrc, - const RtpState& rtp_state) OVERRIDE; - virtual bool GetRtpStateForSsrc(uint32_t ssrc, RtpState* rtp_state) OVERRIDE; + bool SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state) override; + bool GetRtpStateForSsrc(uint32_t ssrc, RtpState* rtp_state) override; - virtual uint32_t SSRC() const OVERRIDE; + uint32_t SSRC() const override; // Configure SSRC, default is a random number. - virtual void SetSSRC(uint32_t ssrc) OVERRIDE; + void SetSSRC(uint32_t ssrc) override; - virtual void SetCsrcs(const std::vector& csrcs) OVERRIDE; + void SetCsrcs(const std::vector& csrcs) override; RTCPSender::FeedbackState GetFeedbackState(); int CurrentSendFrequencyHz() const; - virtual void SetRtxSendStatus(int mode) OVERRIDE; - virtual int RtxSendStatus() const OVERRIDE; + void SetRtxSendStatus(int mode) override; + int RtxSendStatus() const override; - virtual void SetRtxSsrc(uint32_t ssrc) OVERRIDE; + void SetRtxSsrc(uint32_t ssrc) override; - virtual void SetRtxSendPayloadType(int payload_type) OVERRIDE; + void SetRtxSendPayloadType(int payload_type) override; // Sends kRtcpByeCode when going from true to false. - virtual int32_t SetSendingStatus(bool sending) OVERRIDE; + int32_t SetSendingStatus(bool sending) override; - virtual bool Sending() const OVERRIDE; + bool Sending() const override; // Drops or relays media packets. - virtual void SetSendingMediaStatus(bool sending) OVERRIDE; + void SetSendingMediaStatus(bool sending) override; - virtual bool SendingMedia() const OVERRIDE; + bool SendingMedia() const override; // Used by the codec module to deliver a video or audio frame for // packetization. - virtual int32_t SendOutgoingData( - FrameType frame_type, - int8_t payload_type, - uint32_t time_stamp, - int64_t capture_time_ms, - const uint8_t* payload_data, - size_t payload_size, - const RTPFragmentationHeader* fragmentation = NULL, - const RTPVideoHeader* rtp_video_hdr = NULL) OVERRIDE; + int32_t SendOutgoingData(FrameType frame_type, + int8_t payload_type, + uint32_t time_stamp, + int64_t capture_time_ms, + const uint8_t* payload_data, + size_t payload_size, + const RTPFragmentationHeader* fragmentation = NULL, + const RTPVideoHeader* rtp_video_hdr = NULL) override; - virtual bool TimeToSendPacket(uint32_t ssrc, - uint16_t sequence_number, - int64_t capture_time_ms, - bool retransmission) OVERRIDE; + bool TimeToSendPacket(uint32_t ssrc, + uint16_t sequence_number, + int64_t capture_time_ms, + bool retransmission) override; // Returns the number of padding bytes actually sent, which can be more or // less than |bytes|. - virtual size_t TimeToSendPadding(size_t bytes) OVERRIDE; + size_t TimeToSendPadding(size_t bytes) override; - virtual bool GetSendSideDelay(int* avg_send_delay_ms, - int* max_send_delay_ms) const OVERRIDE; + bool GetSendSideDelay(int* avg_send_delay_ms, + int* max_send_delay_ms) const override; // RTCP part. // Get RTCP status. - virtual RTCPMethod RTCP() const OVERRIDE; + RTCPMethod RTCP() const override; // Configure RTCP status i.e on/off. - virtual void SetRTCPStatus(RTCPMethod method) OVERRIDE; + void SetRTCPStatus(RTCPMethod method) override; // Set RTCP CName. - virtual int32_t SetCNAME(const char c_name[RTCP_CNAME_SIZE]) OVERRIDE; + int32_t SetCNAME(const char c_name[RTCP_CNAME_SIZE]) override; // Get remote CName. - virtual int32_t RemoteCNAME(uint32_t remote_ssrc, - char c_name[RTCP_CNAME_SIZE]) const OVERRIDE; + int32_t RemoteCNAME(uint32_t remote_ssrc, + char c_name[RTCP_CNAME_SIZE]) const override; // Get remote NTP. - virtual int32_t RemoteNTP(uint32_t* received_ntp_secs, - uint32_t* received_ntp_frac, - uint32_t* rtcp_arrival_time_secs, - uint32_t* rtcp_arrival_time_frac, - uint32_t* rtcp_timestamp) const OVERRIDE; + int32_t RemoteNTP(uint32_t* received_ntp_secs, + uint32_t* received_ntp_frac, + uint32_t* rtcp_arrival_time_secs, + uint32_t* rtcp_arrival_time_frac, + uint32_t* rtcp_timestamp) const override; - virtual int32_t AddMixedCNAME(uint32_t ssrc, - const char c_name[RTCP_CNAME_SIZE]) OVERRIDE; + int32_t AddMixedCNAME(uint32_t ssrc, + const char c_name[RTCP_CNAME_SIZE]) override; - virtual int32_t RemoveMixedCNAME(uint32_t ssrc) OVERRIDE; + int32_t RemoveMixedCNAME(uint32_t ssrc) override; // Get RoundTripTime. - virtual int32_t RTT(uint32_t remote_ssrc, - int64_t* rtt, - int64_t* avg_rtt, - int64_t* min_rtt, - int64_t* max_rtt) const OVERRIDE; + int32_t RTT(uint32_t remote_ssrc, + int64_t* rtt, + int64_t* avg_rtt, + int64_t* min_rtt, + int64_t* max_rtt) const override; // Force a send of an RTCP packet. // Normal SR and RR are triggered via the process function. - virtual int32_t SendRTCP(uint32_t rtcp_packet_type = kRtcpReport) OVERRIDE; + int32_t SendRTCP(uint32_t rtcp_packet_type = kRtcpReport) override; - virtual int32_t ResetSendDataCountersRTP() OVERRIDE; + int32_t ResetSendDataCountersRTP() override; // Statistics of the amount of data sent and received. - virtual int32_t DataCountersRTP(size_t* bytes_sent, - uint32_t* packets_sent) const OVERRIDE; + int32_t DataCountersRTP(size_t* bytes_sent, + uint32_t* packets_sent) const override; - virtual void GetSendStreamDataCounters( + void GetSendStreamDataCounters( StreamDataCounters* rtp_counters, - StreamDataCounters* rtx_counters) const OVERRIDE; + StreamDataCounters* rtx_counters) const override; // Get received RTCP report, sender info. - virtual int32_t RemoteRTCPStat(RTCPSenderInfo* sender_info) OVERRIDE; + int32_t RemoteRTCPStat(RTCPSenderInfo* sender_info) override; // Get received RTCP report, report block. - virtual int32_t RemoteRTCPStat( - std::vector* receive_blocks) const OVERRIDE; + int32_t RemoteRTCPStat( + std::vector* receive_blocks) const override; // Set received RTCP report block. - virtual int32_t AddRTCPReportBlock( - uint32_t ssrc, - const RTCPReportBlock* receive_block) OVERRIDE; + int32_t AddRTCPReportBlock(uint32_t ssrc, + const RTCPReportBlock* receive_block) override; - virtual int32_t RemoveRTCPReportBlock(uint32_t ssrc) OVERRIDE; + int32_t RemoveRTCPReportBlock(uint32_t ssrc) override; // (REMB) Receiver Estimated Max Bitrate. - virtual bool REMB() const OVERRIDE; + bool REMB() const override; - virtual void SetREMBStatus(bool enable) OVERRIDE; + void SetREMBStatus(bool enable) override; - virtual void SetREMBData(uint32_t bitrate, - const std::vector& ssrcs) OVERRIDE; + void SetREMBData(uint32_t bitrate, + const std::vector& ssrcs) override; // (IJ) Extended jitter report. - virtual bool IJ() const OVERRIDE; + bool IJ() const override; - virtual void SetIJStatus(bool enable) OVERRIDE; + void SetIJStatus(bool enable) override; // (TMMBR) Temporary Max Media Bit Rate. - virtual bool TMMBR() const OVERRIDE; + bool TMMBR() const override; - virtual void SetTMMBRStatus(bool enable) OVERRIDE; + void SetTMMBRStatus(bool enable) override; int32_t SetTMMBN(const TMMBRSet* bounding_set); - virtual uint16_t MaxPayloadLength() const OVERRIDE; + uint16_t MaxPayloadLength() const override; - virtual uint16_t MaxDataPayloadLength() const OVERRIDE; + uint16_t MaxDataPayloadLength() const override; - virtual int32_t SetMaxTransferUnit(uint16_t size) OVERRIDE; + int32_t SetMaxTransferUnit(uint16_t size) override; - virtual int32_t SetTransportOverhead( - bool tcp, - bool ipv6, - uint8_t authentication_overhead = 0) OVERRIDE; + int32_t SetTransportOverhead(bool tcp, + bool ipv6, + uint8_t authentication_overhead = 0) override; // (NACK) Negative acknowledgment part. - virtual int SelectiveRetransmissions() const OVERRIDE; + int SelectiveRetransmissions() const override; - virtual int SetSelectiveRetransmissions(uint8_t settings) OVERRIDE; + int SetSelectiveRetransmissions(uint8_t settings) override; // Send a Negative acknowledgment packet. - virtual int32_t SendNACK(const uint16_t* nack_list, uint16_t size) OVERRIDE; + int32_t SendNACK(const uint16_t* nack_list, uint16_t size) override; // Store the sent packets, needed to answer to a negative acknowledgment // requests. - virtual void SetStorePacketsStatus(bool enable, - uint16_t number_to_store) OVERRIDE; + void SetStorePacketsStatus(bool enable, uint16_t number_to_store) override; - virtual bool StorePackets() const OVERRIDE; + bool StorePackets() const override; // Called on receipt of RTCP report block from remote side. - virtual void RegisterRtcpStatisticsCallback( - RtcpStatisticsCallback* callback) OVERRIDE; - virtual RtcpStatisticsCallback* GetRtcpStatisticsCallback() OVERRIDE; + void RegisterRtcpStatisticsCallback( + RtcpStatisticsCallback* callback) override; + RtcpStatisticsCallback* GetRtcpStatisticsCallback() override; // (APP) Application specific data. - virtual int32_t SetRTCPApplicationSpecificData(uint8_t sub_type, - uint32_t name, - const uint8_t* data, - uint16_t length) OVERRIDE; + int32_t SetRTCPApplicationSpecificData(uint8_t sub_type, + uint32_t name, + const uint8_t* data, + uint16_t length) override; // (XR) VOIP metric. - virtual int32_t SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric) OVERRIDE; + int32_t SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric) override; // (XR) Receiver reference time report. - virtual void SetRtcpXrRrtrStatus(bool enable) OVERRIDE; + void SetRtcpXrRrtrStatus(bool enable) override; - virtual bool RtcpXrRrtrStatus() const OVERRIDE; + bool RtcpXrRrtrStatus() const override; // Audio part. // Set audio packet size, used to determine when it's time to send a DTMF // packet in silence (CNG). - virtual int32_t SetAudioPacketSize(uint16_t packet_size_samples) OVERRIDE; + int32_t SetAudioPacketSize(uint16_t packet_size_samples) override; // Send a TelephoneEvent tone using RFC 2833 (4733). - virtual int32_t SendTelephoneEventOutband(uint8_t key, - uint16_t time_ms, - uint8_t level) OVERRIDE; + int32_t SendTelephoneEventOutband(uint8_t key, + uint16_t time_ms, + uint8_t level) override; // Set payload type for Redundant Audio Data RFC 2198. - virtual int32_t SetSendREDPayloadType(int8_t payload_type) OVERRIDE; + int32_t SetSendREDPayloadType(int8_t payload_type) override; // Get payload type for Redundant Audio Data RFC 2198. - virtual int32_t SendREDPayloadType(int8_t& payload_type) const OVERRIDE; + int32_t SendREDPayloadType(int8_t& payload_type) const override; // Store the audio level in d_bov for header-extension-for-audio-level- // indication. - virtual int32_t SetAudioLevel(uint8_t level_d_bov) OVERRIDE; + int32_t SetAudioLevel(uint8_t level_d_bov) override; // Video part. - virtual int32_t SendRTCPSliceLossIndication(uint8_t picture_id) OVERRIDE; + int32_t SendRTCPSliceLossIndication(uint8_t picture_id) override; // Set method for requesting a new key frame. - virtual int32_t SetKeyFrameRequestMethod( - KeyFrameRequestMethod method) OVERRIDE; + int32_t SetKeyFrameRequestMethod(KeyFrameRequestMethod method) override; // Send a request for a keyframe. - virtual int32_t RequestKeyFrame() OVERRIDE; + int32_t RequestKeyFrame() override; - virtual void SetTargetSendBitrate(uint32_t bitrate_bps) OVERRIDE; + void SetTargetSendBitrate(uint32_t bitrate_bps) override; - virtual int32_t SetGenericFECStatus(bool enable, - uint8_t payload_type_red, - uint8_t payload_type_fec) OVERRIDE; + int32_t SetGenericFECStatus(bool enable, + uint8_t payload_type_red, + uint8_t payload_type_fec) override; - virtual int32_t GenericFECStatus( - bool& enable, - uint8_t& payload_type_red, - uint8_t& payload_type_fec) OVERRIDE; + int32_t GenericFECStatus(bool& enable, + uint8_t& payload_type_red, + uint8_t& payload_type_fec) override; - virtual int32_t SetFecParameters( - const FecProtectionParams* delta_params, - const FecProtectionParams* key_params) OVERRIDE; + int32_t SetFecParameters(const FecProtectionParams* delta_params, + const FecProtectionParams* key_params) override; bool LastReceivedNTP(uint32_t* NTPsecs, uint32_t* NTPfrac, @@ -309,23 +300,22 @@ class ModuleRtpRtcpImpl : public RtpRtcp { virtual int32_t BoundingSet(bool& tmmbr_owner, TMMBRSet*& bounding_set_rec); - virtual void BitrateSent(uint32_t* total_rate, - uint32_t* video_rate, - uint32_t* fec_rate, - uint32_t* nackRate) const OVERRIDE; + void BitrateSent(uint32_t* total_rate, + uint32_t* video_rate, + uint32_t* fec_rate, + uint32_t* nackRate) const override; int64_t SendTimeOfSendReport(uint32_t send_report); bool SendTimeOfXrRrReport(uint32_t mid_ntp, int64_t* time_ms) const; // Good state of RTP receiver inform sender. - virtual int32_t SendRTCPReferencePictureSelection( - uint64_t picture_id) OVERRIDE; + int32_t SendRTCPReferencePictureSelection(uint64_t picture_id) override; - virtual void RegisterSendChannelRtpStatisticsCallback( - StreamDataCountersCallback* callback) OVERRIDE; - virtual StreamDataCountersCallback* - GetSendChannelRtpStatisticsCallback() const OVERRIDE; + void RegisterSendChannelRtpStatisticsCallback( + StreamDataCountersCallback* callback) override; + StreamDataCountersCallback* GetSendChannelRtpStatisticsCallback() + const override; void OnReceivedTMMBR(); diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc index e32a53513..e7b58a2a6 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc @@ -40,12 +40,8 @@ class RtcpRttStatsTestImpl : public RtcpRttStats { RtcpRttStatsTestImpl() : rtt_ms_(0) {} virtual ~RtcpRttStatsTestImpl() {} - virtual void OnRttUpdate(int64_t rtt_ms) OVERRIDE { - rtt_ms_ = rtt_ms; - } - virtual int64_t LastProcessedRtt() const OVERRIDE { - return rtt_ms_; - } + void OnRttUpdate(int64_t rtt_ms) override { rtt_ms_ = rtt_ms; } + int64_t LastProcessedRtt() const override { return rtt_ms_; } int64_t rtt_ms_; }; @@ -66,7 +62,7 @@ class SendTransport : public Transport, clock_ = clock; delay_ms_ = delay_ms; } - virtual int SendPacket(int /*ch*/, const void* data, size_t len) OVERRIDE { + int SendPacket(int /*ch*/, const void* data, size_t len) override { RTPHeader header; rtc::scoped_ptr parser(RtpHeaderParser::Create()); EXPECT_TRUE(parser->Parse(static_cast(data), len, &header)); @@ -74,9 +70,7 @@ class SendTransport : public Transport, last_rtp_header_ = header; return static_cast(len); } - virtual int SendRTCPPacket(int /*ch*/, - const void *data, - size_t len) OVERRIDE { + int SendRTCPPacket(int /*ch*/, const void* data, size_t len) override { test::RtcpPacketParser parser; parser.Parse(static_cast(data), len); last_nack_list_ = parser.nack_item()->last_nack_list(); diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc index 5f5a71ae5..e6a912eb9 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc @@ -73,7 +73,7 @@ class BitrateAggregator { : aggregator_(aggregator) {} // Implements Bitrate::Observer. - virtual void BitrateUpdated(const BitrateStatistics& stats) OVERRIDE { + void BitrateUpdated(const BitrateStatistics& stats) override { statistics_ = stats; aggregator_.OnStatsUpdated(); } diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.h b/webrtc/modules/rtp_rtcp/source/rtp_sender.h index 1fa46d198..9342e5e5e 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.h @@ -81,7 +81,7 @@ class RTPSender : public RTPSenderInterface { void ProcessBitrate(); - virtual uint16_t ActualSendBitrateKbit() const OVERRIDE; + uint16_t ActualSendBitrateKbit() const override; uint32_t VideoBitrateSent() const; uint32_t FecOverheadRate() const; @@ -95,7 +95,7 @@ class RTPSender : public RTPSenderInterface { uint32_t GetTargetBitrate(); // Includes size of RTP and FEC headers. - virtual size_t MaxDataPayloadLength() const OVERRIDE; + size_t MaxDataPayloadLength() const override; int32_t RegisterPayload( const char payload_name[RTP_PAYLOAD_NAME_SIZE], @@ -126,7 +126,7 @@ class RTPSender : public RTPSenderInterface { uint32_t GenerateNewSSRC(); void SetSSRC(uint32_t ssrc); - virtual uint16_t SequenceNumber() const OVERRIDE; + uint16_t SequenceNumber() const override; void SetSequenceNumber(uint16_t seq); void SetCsrcs(const std::vector& csrcs); @@ -193,28 +193,29 @@ class RTPSender : public RTPSenderInterface { void SetRtxPayloadType(int payloadType); // Functions wrapping RTPSenderInterface. - virtual int32_t BuildRTPheader( - uint8_t* data_buffer, - int8_t payload_type, - bool marker_bit, - uint32_t capture_timestamp, - int64_t capture_time_ms, - const bool timestamp_provided = true, - const bool inc_sequence_number = true) OVERRIDE; + int32_t BuildRTPheader(uint8_t* data_buffer, + int8_t payload_type, + bool marker_bit, + uint32_t capture_timestamp, + int64_t capture_time_ms, + const bool timestamp_provided = true, + const bool inc_sequence_number = true) override; - virtual size_t RTPHeaderLength() const OVERRIDE; - virtual uint16_t IncrementSequenceNumber() OVERRIDE; - virtual size_t MaxPayloadLength() const OVERRIDE; - virtual uint16_t PacketOverHead() const OVERRIDE; + size_t RTPHeaderLength() const override; + uint16_t IncrementSequenceNumber() override; + size_t MaxPayloadLength() const override; + uint16_t PacketOverHead() const override; // Current timestamp. - virtual uint32_t Timestamp() const OVERRIDE; - virtual uint32_t SSRC() const OVERRIDE; + uint32_t Timestamp() const override; + uint32_t SSRC() const override; - virtual int32_t SendToNetwork( - uint8_t *data_buffer, size_t payload_length, size_t rtp_header_length, - int64_t capture_time_ms, StorageType storage, - PacedSender::Priority priority) OVERRIDE; + int32_t SendToNetwork(uint8_t* data_buffer, + size_t payload_length, + size_t rtp_header_length, + int64_t capture_time_ms, + StorageType storage, + PacedSender::Priority priority) override; // Audio. diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc index 8787ad677..f57ee2732 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc @@ -62,16 +62,14 @@ class LoopbackTransportTest : public webrtc::Transport { public: LoopbackTransportTest() : packets_sent_(0), last_sent_packet_len_(0), total_bytes_sent_(0) {} - virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE { + int SendPacket(int channel, const void* data, size_t len) override { packets_sent_++; memcpy(last_sent_packet_, data, len); last_sent_packet_len_ = len; total_bytes_sent_ += len; return static_cast(len); } - virtual int SendRTCPPacket(int channel, - const void *data, - size_t len) OVERRIDE { + int SendRTCPPacket(int channel, const void* data, size_t len) override { return -1; } int packets_sent_; @@ -93,7 +91,7 @@ class RtpSenderTest : public ::testing::Test { SendPacket(_, _, _, _, _, _)).WillRepeatedly(testing::Return(true)); } - virtual void SetUp() OVERRIDE { + void SetUp() override { rtp_sender_.reset(new RTPSender(0, false, &fake_clock_, &transport_, NULL, &mock_paced_sender_, NULL, NULL, NULL)); rtp_sender_->SetSequenceNumber(kSeqNum); @@ -771,8 +769,8 @@ TEST_F(RtpSenderTest, FrameCountCallbacks) { TestCallback() : FrameCountObserver(), num_calls_(0), ssrc_(0) {} virtual ~TestCallback() {} - virtual void FrameCountUpdated(const FrameCounts& frame_counts, - uint32_t ssrc) OVERRIDE { + void FrameCountUpdated(const FrameCounts& frame_counts, + uint32_t ssrc) override { ++num_calls_; ssrc_ = ssrc; frame_counts_ = frame_counts; @@ -821,9 +819,9 @@ TEST_F(RtpSenderTest, BitrateCallbacks) { TestCallback() : BitrateStatisticsObserver(), num_calls_(0), ssrc_(0) {} virtual ~TestCallback() {} - virtual void Notify(const BitrateStatistics& total_stats, - const BitrateStatistics& retransmit_stats, - uint32_t ssrc) OVERRIDE { + void Notify(const BitrateStatistics& total_stats, + const BitrateStatistics& retransmit_stats, + uint32_t ssrc) override { ++num_calls_; ssrc_ = ssrc; total_stats_ = total_stats; @@ -891,7 +889,7 @@ class RtpSenderAudioTest : public RtpSenderTest { protected: RtpSenderAudioTest() {} - virtual void SetUp() OVERRIDE { + void SetUp() override { payload_ = kAudioPayload; rtp_sender_.reset(new RTPSender(0, true, &fake_clock_, &transport_, NULL, &mock_paced_sender_, NULL, NULL, NULL)); @@ -906,8 +904,8 @@ TEST_F(RtpSenderTest, StreamDataCountersCallbacks) { : StreamDataCountersCallback(), ssrc_(0), counters_() {} virtual ~TestCallback() {} - virtual void DataCountersUpdated(const StreamDataCounters& counters, - uint32_t ssrc) OVERRIDE { + void DataCountersUpdated(const StreamDataCounters& counters, + uint32_t ssrc) override { ssrc_ = ssrc; counters_ = counters; } diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc index 77ee6fb72..ea8ac9876 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc @@ -32,15 +32,15 @@ public: myTransportCB (RtpRtcp *rtpMod) : _rtpMod(rtpMod) {}; protected: // Inherited from UdpTransportData - virtual void IncomingRTPPacket(const int8_t* incomingRtpPacket, - const size_t rtpPacketLength, - const int8_t* fromIP, - const uint16_t fromPort) OVERRIDE; + void IncomingRTPPacket(const int8_t* incomingRtpPacket, + const size_t rtpPacketLength, + const int8_t* fromIP, + const uint16_t fromPort) override; - virtual void IncomingRTCPPacket(const int8_t* incomingRtcpPacket, - const size_t rtcpPacketLength, - const int8_t* fromIP, - const uint16_t fromPort) OVERRIDE; + void IncomingRTCPPacket(const int8_t* incomingRtcpPacket, + const size_t rtcpPacketLength, + const int8_t* fromIP, + const uint16_t fromPort) override; private: RtpRtcp *_rtpMod; diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h index 30a84c960..9ebc5a552 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h @@ -69,43 +69,38 @@ public: int32_t SetPacketTimeout(const uint32_t timeoutMS); // Inherited from RtpFeedback - virtual int32_t OnInitializeDecoder( - const int32_t id, - const int8_t payloadType, - const int8_t payloadName[RTP_PAYLOAD_NAME_SIZE], - const uint32_t frequency, - const uint8_t channels, - const uint32_t rate) OVERRIDE { + int32_t OnInitializeDecoder(const int32_t id, + const int8_t payloadType, + const int8_t payloadName[RTP_PAYLOAD_NAME_SIZE], + const uint32_t frequency, + const uint8_t channels, + const uint32_t rate) override { return 0; } - virtual void OnIncomingSSRCChanged(const int32_t id, - const uint32_t SSRC) OVERRIDE {} - - virtual void OnIncomingCSRCChanged(const int32_t id, - const uint32_t CSRC, - const bool added) OVERRIDE {} + void OnIncomingSSRCChanged(const int32_t id, const uint32_t SSRC) override { + } + void OnIncomingCSRCChanged(const int32_t id, + const uint32_t CSRC, + const bool added) override {} // Inherited from RtpData - virtual int32_t OnReceivedPayloadData( + int32_t OnReceivedPayloadData( const uint8_t* payloadData, const size_t payloadSize, - const webrtc::WebRtcRTPHeader* rtpHeader) OVERRIDE; - + const webrtc::WebRtcRTPHeader* rtpHeader) override; // Inherited from UdpTransportData - virtual void IncomingRTPPacket(const int8_t* incomingRtpPacket, - const size_t rtpPacketLength, - const int8_t* fromIP, - const uint16_t fromPort) OVERRIDE; - - virtual void IncomingRTCPPacket(const int8_t* incomingRtcpPacket, - const size_t rtcpPacketLength, - const int8_t* fromIP, - const uint16_t fromPort) OVERRIDE; - + void IncomingRTPPacket(const int8_t* incomingRtpPacket, + const size_t rtpPacketLength, + const int8_t* fromIP, + const uint16_t fromPort) override; + void IncomingRTCPPacket(const int8_t* incomingRtcpPacket, + const size_t rtcpPacketLength, + const int8_t* fromIP, + const uint16_t fromPort) override; ///////////////////////////////// // Sender methods diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc index d265c8614..6b4e55df6 100644 --- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc +++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc @@ -89,7 +89,7 @@ class RtpRtcpAPITest : public ::testing::Test { } ~RtpRtcpAPITest() {} - virtual void SetUp() OVERRIDE { + void SetUp() override { RtpRtcp::Configuration configuration; configuration.id = test_id; configuration.audio = true; diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h index 677d3b189..069cdc77d 100644 --- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h +++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h @@ -35,10 +35,8 @@ class LoopBackTransport : public webrtc::Transport { RtpReceiver* receiver, ReceiveStatistics* receive_statistics); void DropEveryNthPacket(int n); - virtual int SendPacket(int channel, const void* data, size_t len) OVERRIDE; - virtual int SendRTCPPacket(int channel, - const void* data, - size_t len) OVERRIDE; + int SendPacket(int channel, const void* data, size_t len) override; + int SendRTCPPacket(int channel, const void* data, size_t len) override; private: int count_; @@ -51,10 +49,10 @@ class LoopBackTransport : public webrtc::Transport { class TestRtpReceiver : public NullRtpData { public: - virtual int32_t OnReceivedPayloadData( + int32_t OnReceivedPayloadData( const uint8_t* payload_data, const size_t payload_size, - const webrtc::WebRtcRTPHeader* rtp_header) OVERRIDE; + const webrtc::WebRtcRTPHeader* rtp_header) override; const uint8_t* payload_data() const { return payload_data_; } size_t payload_size() const { return payload_size_; } diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc index c8b83d32a..61923aa44 100644 --- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc +++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc @@ -25,10 +25,10 @@ using namespace webrtc; class VerifyingAudioReceiver : public NullRtpData { public: - virtual int32_t OnReceivedPayloadData( + int32_t OnReceivedPayloadData( const uint8_t* payloadData, const size_t payloadSize, - const webrtc::WebRtcRTPHeader* rtpHeader) OVERRIDE { + const webrtc::WebRtcRTPHeader* rtpHeader) override { if (rtpHeader->header.payloadType == 98 || rtpHeader->header.payloadType == 99) { EXPECT_EQ(4u, payloadSize); @@ -61,13 +61,12 @@ class VerifyingAudioReceiver : public NullRtpData { class RTPCallback : public NullRtpFeedback { public: - virtual int32_t OnInitializeDecoder( - const int32_t id, - const int8_t payloadType, - const char payloadName[RTP_PAYLOAD_NAME_SIZE], - const int frequency, - const uint8_t channels, - const uint32_t rate) OVERRIDE { + int32_t OnInitializeDecoder(const int32_t id, + const int8_t payloadType, + const char payloadName[RTP_PAYLOAD_NAME_SIZE], + const int frequency, + const uint8_t channels, + const uint32_t rate) override { if (payloadType == 96) { EXPECT_EQ(test_rate, rate) << "The rate should be 64K for this payloadType"; @@ -88,7 +87,7 @@ class RtpRtcpAudioTest : public ::testing::Test { } ~RtpRtcpAudioTest() {} - virtual void SetUp() OVERRIDE { + void SetUp() override { audioFeedback = new NullRtpAudioFeedback(); data_receiver1 = new VerifyingAudioReceiver(); data_receiver2 = new VerifyingAudioReceiver(); @@ -133,7 +132,7 @@ class RtpRtcpAudioTest : public ::testing::Test { rtp_receiver1_.get(), receive_statistics1_.get()); } - virtual void TearDown() OVERRIDE { + void TearDown() override { delete module1; delete module2; delete transport1; diff --git a/webrtc/modules/utility/source/coder.h b/webrtc/modules/utility/source/coder.h index a82124612..57eada18c 100644 --- a/webrtc/modules/utility/source/coder.h +++ b/webrtc/modules/utility/source/coder.h @@ -42,13 +42,12 @@ public: size_t& encodedLengthInBytes); protected: - virtual int32_t SendData( - FrameType frameType, - uint8_t payloadType, - uint32_t timeStamp, - const uint8_t* payloadData, - size_t payloadSize, - const RTPFragmentationHeader* fragmentation) OVERRIDE; + int32_t SendData(FrameType frameType, + uint8_t payloadType, + uint32_t timeStamp, + const uint8_t* payloadData, + size_t payloadSize, + const RTPFragmentationHeader* fragmentation) override; private: rtc::scoped_ptr _acm; diff --git a/webrtc/modules/utility/source/file_player_unittests.cc b/webrtc/modules/utility/source/file_player_unittests.cc index d430d9f59..7ce9d4729 100644 --- a/webrtc/modules/utility/source/file_player_unittests.cc +++ b/webrtc/modules/utility/source/file_player_unittests.cc @@ -35,7 +35,7 @@ class FilePlayerTest : public ::testing::Test { : player_(FilePlayer::CreateFilePlayer(kId, kFileFormat)), output_file_(NULL) {} - virtual void SetUp() OVERRIDE { + void SetUp() override { if (FLAGS_file_player_output) { std::string output_file = webrtc::test::OutputPath() + "file_player_unittest_out.pcm"; @@ -44,7 +44,7 @@ class FilePlayerTest : public ::testing::Test { } } - virtual void TearDown() OVERRIDE { + void TearDown() override { if (output_file_) fclose(output_file_); } diff --git a/webrtc/modules/utility/source/rtp_dump_impl.h b/webrtc/modules/utility/source/rtp_dump_impl.h index 5be9cbe14..b49a69042 100644 --- a/webrtc/modules/utility/source/rtp_dump_impl.h +++ b/webrtc/modules/utility/source/rtp_dump_impl.h @@ -22,11 +22,11 @@ public: RtpDumpImpl(); virtual ~RtpDumpImpl(); - virtual int32_t Start(const char* fileNameUTF8) OVERRIDE; - virtual int32_t Stop() OVERRIDE; - virtual bool IsActive() const OVERRIDE; - virtual int32_t DumpPacket(const uint8_t* packet, - size_t packetLength) OVERRIDE; + int32_t Start(const char* fileNameUTF8) override; + int32_t Stop() override; + bool IsActive() const override; + int32_t DumpPacket(const uint8_t* packet, size_t packetLength) override; + private: // Return the system time in ms. inline uint32_t GetTimeInMS() const; diff --git a/webrtc/modules/video_capture/ios/device_info_ios.h b/webrtc/modules/video_capture/ios/device_info_ios.h index 476e91983..e10db4a8a 100644 --- a/webrtc/modules/video_capture/ios/device_info_ios.h +++ b/webrtc/modules/video_capture/ios/device_info_ios.h @@ -21,40 +21,36 @@ class DeviceInfoIos : public DeviceInfoImpl { virtual ~DeviceInfoIos(); // Implementation of DeviceInfoImpl. - virtual int32_t Init() OVERRIDE; - virtual uint32_t NumberOfDevices() OVERRIDE; - virtual int32_t GetDeviceName( - uint32_t deviceNumber, - char* deviceNameUTF8, - uint32_t deviceNameLength, - char* deviceUniqueIdUTF8, - uint32_t deviceUniqueIdUTF8Length, - char* productUniqueIdUTF8 = 0, - uint32_t productUniqueIdUTF8Length = 0) OVERRIDE; + int32_t Init() override; + uint32_t NumberOfDevices() override; + int32_t GetDeviceName(uint32_t deviceNumber, + char* deviceNameUTF8, + uint32_t deviceNameLength, + char* deviceUniqueIdUTF8, + uint32_t deviceUniqueIdUTF8Length, + char* productUniqueIdUTF8 = 0, + uint32_t productUniqueIdUTF8Length = 0) override; - virtual int32_t NumberOfCapabilities(const char* deviceUniqueIdUTF8) OVERRIDE; + int32_t NumberOfCapabilities(const char* deviceUniqueIdUTF8) override; - virtual int32_t GetCapability(const char* deviceUniqueIdUTF8, - const uint32_t deviceCapabilityNumber, - VideoCaptureCapability& capability) OVERRIDE; + int32_t GetCapability(const char* deviceUniqueIdUTF8, + const uint32_t deviceCapabilityNumber, + VideoCaptureCapability& capability) override; - virtual int32_t GetBestMatchedCapability( - const char* deviceUniqueIdUTF8, - const VideoCaptureCapability& requested, - VideoCaptureCapability& resulting) OVERRIDE; + int32_t GetBestMatchedCapability(const char* deviceUniqueIdUTF8, + const VideoCaptureCapability& requested, + VideoCaptureCapability& resulting) override; - virtual int32_t DisplayCaptureSettingsDialogBox( - const char* deviceUniqueIdUTF8, - const char* dialogTitleUTF8, - void* parentWindow, - uint32_t positionX, - uint32_t positionY) OVERRIDE; + int32_t DisplayCaptureSettingsDialogBox(const char* deviceUniqueIdUTF8, + const char* dialogTitleUTF8, + void* parentWindow, + uint32_t positionX, + uint32_t positionY) override; - virtual int32_t GetOrientation(const char* deviceUniqueIdUTF8, - VideoRotation& orientation) OVERRIDE; + int32_t GetOrientation(const char* deviceUniqueIdUTF8, + VideoRotation& orientation) override; - virtual int32_t CreateCapabilityMap( - const char* device_unique_id_utf8) OVERRIDE; + int32_t CreateCapabilityMap(const char* device_unique_id_utf8) override; }; } // namespace videocapturemodule diff --git a/webrtc/modules/video_capture/ios/video_capture_ios.h b/webrtc/modules/video_capture/ios/video_capture_ios.h index ff8345f26..1afcbaddf 100644 --- a/webrtc/modules/video_capture/ios/video_capture_ios.h +++ b/webrtc/modules/video_capture/ios/video_capture_ios.h @@ -26,11 +26,10 @@ class VideoCaptureIos : public VideoCaptureImpl { const char* device_unique_id_utf8); // Implementation of VideoCaptureImpl. - virtual int32_t StartCapture( - const VideoCaptureCapability& capability) OVERRIDE; - virtual int32_t StopCapture() OVERRIDE; - virtual bool CaptureStarted() OVERRIDE; - virtual int32_t CaptureSettings(VideoCaptureCapability& settings) OVERRIDE; + int32_t StartCapture(const VideoCaptureCapability& capability) override; + int32_t StopCapture() override; + bool CaptureStarted() override; + int32_t CaptureSettings(VideoCaptureCapability& settings) override; private: RTCVideoCaptureIosObjC* capture_device_; diff --git a/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h b/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h index 7fef06078..f1159073b 100644 --- a/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h +++ b/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h @@ -34,9 +34,9 @@ class I420Encoder : public VideoEncoder { // // Return value : WEBRTC_VIDEO_CODEC_OK if OK. // <0 - Error - virtual int InitEncode(const VideoCodec* codecSettings, - int /*numberOfCores*/, - size_t /*maxPayloadSize*/) OVERRIDE; + int InitEncode(const VideoCodec* codecSettings, + int /*numberOfCores*/, + size_t /*maxPayloadSize*/) override; // "Encode" an I420 image (as a part of a video stream). The encoded image // will be returned to the user via the encode complete callback. @@ -48,10 +48,9 @@ class I420Encoder : public VideoEncoder { // // Return value : WEBRTC_VIDEO_CODEC_OK if OK. // <0 - Error - virtual int Encode( - const I420VideoFrame& inputImage, - const CodecSpecificInfo* /*codecSpecificInfo*/, - const std::vector* /*frame_types*/) OVERRIDE; + int Encode(const I420VideoFrame& inputImage, + const CodecSpecificInfo* /*codecSpecificInfo*/, + const std::vector* /*frame_types*/) override; // Register an encode complete callback object. // @@ -59,26 +58,22 @@ class I420Encoder : public VideoEncoder { // - callback : Callback object which handles encoded images. // // Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise. - virtual int RegisterEncodeCompleteCallback( - EncodedImageCallback* callback) OVERRIDE; + int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override; // Free encoder memory. // // Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise. - virtual int Release() OVERRIDE; + int Release() override; - virtual int SetRates(uint32_t /*newBitRate*/, - uint32_t /*frameRate*/) OVERRIDE { + int SetRates(uint32_t /*newBitRate*/, uint32_t /*frameRate*/) override { return WEBRTC_VIDEO_CODEC_OK; } - virtual int SetChannelParameters(uint32_t /*packetLoss*/, - int64_t /*rtt*/) OVERRIDE { + int SetChannelParameters(uint32_t /*packetLoss*/, int64_t /*rtt*/) override { return WEBRTC_VIDEO_CODEC_OK; } - virtual int CodecConfigParameters(uint8_t* /*buffer*/, - int /*size*/) OVERRIDE { + int CodecConfigParameters(uint8_t* /*buffer*/, int /*size*/) override { return WEBRTC_VIDEO_CODEC_OK; } @@ -102,11 +97,11 @@ class I420Decoder : public VideoDecoder { // // Return value : WEBRTC_VIDEO_CODEC_OK. // <0 - Errors - virtual int InitDecode(const VideoCodec* codecSettings, - int /*numberOfCores*/) OVERRIDE; + int InitDecode(const VideoCodec* codecSettings, + int /*numberOfCores*/) override; - virtual int SetCodecConfigParameters(const uint8_t* /*buffer*/, - int /*size*/) OVERRIDE { + int SetCodecConfigParameters(const uint8_t* /*buffer*/, + int /*size*/) override { return WEBRTC_VIDEO_CODEC_OK; } @@ -122,11 +117,11 @@ class I420Decoder : public VideoDecoder { // // Return value : WEBRTC_VIDEO_CODEC_OK if OK // <0 - Error - virtual int Decode(const EncodedImage& inputImage, - bool missingFrames, - const RTPFragmentationHeader* /*fragmentation*/, - const CodecSpecificInfo* /*codecSpecificInfo*/, - int64_t /*renderTimeMs*/) OVERRIDE; + int Decode(const EncodedImage& inputImage, + bool missingFrames, + const RTPFragmentationHeader* /*fragmentation*/, + const CodecSpecificInfo* /*codecSpecificInfo*/, + int64_t /*renderTimeMs*/) override; // Register a decode complete callback object. // @@ -134,20 +129,19 @@ class I420Decoder : public VideoDecoder { // - callback : Callback object which handles decoded images. // // Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise. - virtual int RegisterDecodeCompleteCallback( - DecodedImageCallback* callback) OVERRIDE; + int RegisterDecodeCompleteCallback(DecodedImageCallback* callback) override; // Free decoder memory. // // Return value : WEBRTC_VIDEO_CODEC_OK if OK. // <0 - Error - virtual int Release() OVERRIDE; + int Release() override; // Reset decoder state and prepare for a new call. // // Return value : WEBRTC_VIDEO_CODEC_OK. // <0 - Error - virtual int Reset() OVERRIDE; + int Reset() override; private: static const uint8_t* ExtractHeader(const uint8_t* buffer, diff --git a/webrtc/modules/video_coding/codecs/test/packet_manipulator.h b/webrtc/modules/video_coding/codecs/test/packet_manipulator.h index 3cf7233f0..5a1654a2a 100644 --- a/webrtc/modules/video_coding/codecs/test/packet_manipulator.h +++ b/webrtc/modules/video_coding/codecs/test/packet_manipulator.h @@ -91,7 +91,7 @@ class PacketManipulatorImpl : public PacketManipulator { const NetworkingConfig& config, bool verbose); virtual ~PacketManipulatorImpl(); - virtual int ManipulatePackets(webrtc::EncodedImage* encoded_image) OVERRIDE; + int ManipulatePackets(webrtc::EncodedImage* encoded_image) override; virtual void InitializeRandomSeed(unsigned int seed); protected: // Returns a uniformly distributed random value between 0.0 and 1.0 diff --git a/webrtc/modules/video_coding/codecs/test/predictive_packet_manipulator.h b/webrtc/modules/video_coding/codecs/test/predictive_packet_manipulator.h index fcd506410..082712d87 100644 --- a/webrtc/modules/video_coding/codecs/test/predictive_packet_manipulator.h +++ b/webrtc/modules/video_coding/codecs/test/predictive_packet_manipulator.h @@ -33,7 +33,7 @@ class PredictivePacketManipulator : public PacketManipulatorImpl { void AddRandomResult(double result); protected: // Returns a uniformly distributed random value between 0.0 and 1.0 - virtual double RandomUniform() OVERRIDE; + double RandomUniform() override; private: std::queue random_results_; diff --git a/webrtc/modules/video_coding/codecs/test/videoprocessor.h b/webrtc/modules/video_coding/codecs/test/videoprocessor.h index b0923638d..63d736394 100644 --- a/webrtc/modules/video_coding/codecs/test/videoprocessor.h +++ b/webrtc/modules/video_coding/codecs/test/videoprocessor.h @@ -163,8 +163,8 @@ class VideoProcessorImpl : public VideoProcessor { const TestConfig& config, Stats* stats); virtual ~VideoProcessorImpl(); - virtual bool Init() OVERRIDE; - virtual bool ProcessFrame(int frame_number) OVERRIDE; + bool Init() override; + bool ProcessFrame(int frame_number) override; private: // Invoked by the callback when a frame has completed encoding. @@ -176,13 +176,13 @@ class VideoProcessorImpl : public VideoProcessor { int GetElapsedTimeMicroseconds(const webrtc::TickTime& start, const webrtc::TickTime& stop); // Updates the encoder with the target bit rate and the frame rate. - virtual void SetRates(int bit_rate, int frame_rate) OVERRIDE; + void SetRates(int bit_rate, int frame_rate) override; // Return the size of the encoded frame in bytes. - virtual size_t EncodedFrameSize() OVERRIDE; + size_t EncodedFrameSize() override; // Return the number of dropped frames. - virtual int NumberDroppedFrames() OVERRIDE; + int NumberDroppedFrames() override; // Return the number of spatial resizes. - virtual int NumberSpatialResizes() OVERRIDE; + int NumberSpatialResizes() override; webrtc::VideoEncoder* encoder_; webrtc::VideoDecoder* decoder_; @@ -225,10 +225,10 @@ class VideoProcessorImpl : public VideoProcessor { public: explicit VideoProcessorEncodeCompleteCallback(VideoProcessorImpl* vp) : video_processor_(vp) {} - virtual int32_t Encoded( + int32_t Encoded( const webrtc::EncodedImage& encoded_image, const webrtc::CodecSpecificInfo* codec_specific_info, - const webrtc::RTPFragmentationHeader* fragmentation) OVERRIDE; + const webrtc::RTPFragmentationHeader* fragmentation) override; private: VideoProcessorImpl* video_processor_; @@ -241,7 +241,7 @@ class VideoProcessorImpl : public VideoProcessor { explicit VideoProcessorDecodeCompleteCallback(VideoProcessorImpl* vp) : video_processor_(vp) { } - virtual int32_t Decoded(webrtc::I420VideoFrame& image) OVERRIDE; + int32_t Decoded(webrtc::I420VideoFrame& image) override; private: VideoProcessorImpl* video_processor_; diff --git a/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc b/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc index fdf378f57..40677bb32 100644 --- a/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc +++ b/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc @@ -46,7 +46,7 @@ class ScreenshareLayersFT : public ScreenshareLayers { virtual ~ScreenshareLayersFT() {} protected: - virtual bool TargetBitrateExperimentEnabled() OVERRIDE { return true; } + bool TargetBitrateExperimentEnabled() override { return true; } }; class ScreenshareLayerTest : public ::testing::Test { diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h index 2d8a47dc8..d185d1513 100644 --- a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h +++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h @@ -37,24 +37,21 @@ class SimulcastEncoderAdapter : public VP8Encoder, virtual ~SimulcastEncoderAdapter(); // Implements VideoEncoder - virtual int Release() OVERRIDE; - virtual int InitEncode(const VideoCodec* inst, - int number_of_cores, - size_t max_payload_size) OVERRIDE; - virtual int Encode(const I420VideoFrame& input_image, - const CodecSpecificInfo* codec_specific_info, - const std::vector* frame_types) OVERRIDE; - virtual int RegisterEncodeCompleteCallback( - EncodedImageCallback* callback) OVERRIDE; - virtual int SetChannelParameters(uint32_t packet_loss, int64_t rtt) OVERRIDE; - virtual int SetRates(uint32_t new_bitrate_kbit, - uint32_t new_framerate) OVERRIDE; + int Release() override; + int InitEncode(const VideoCodec* inst, + int number_of_cores, + size_t max_payload_size) override; + int Encode(const I420VideoFrame& input_image, + const CodecSpecificInfo* codec_specific_info, + const std::vector* frame_types) override; + int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override; + int SetChannelParameters(uint32_t packet_loss, int64_t rtt) override; + int SetRates(uint32_t new_bitrate_kbit, uint32_t new_framerate) override; // Implements EncodedImageCallback - virtual int32_t Encoded( - const EncodedImage& encodedImage, - const CodecSpecificInfo* codecSpecificInfo = NULL, - const RTPFragmentationHeader* fragmentation = NULL) OVERRIDE; + int32_t Encoded(const EncodedImage& encodedImage, + const CodecSpecificInfo* codecSpecificInfo = NULL, + const RTPFragmentationHeader* fragmentation = NULL) override; private: struct StreamInfo { diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc index 762c507d2..2c2a323f9 100644 --- a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc +++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc @@ -145,15 +145,13 @@ class MockVideoEncoder : public VideoEncoder { class MockVideoEncoderFactory : public VideoEncoderFactory { public: - virtual VideoEncoder* Create() OVERRIDE { + VideoEncoder* Create() override { MockVideoEncoder* encoder = new MockVideoEncoder(); encoders_.push_back(encoder); return encoder; } - virtual void Destroy(VideoEncoder* encoder) OVERRIDE { - delete encoder; - } + void Destroy(VideoEncoder* encoder) override { delete encoder; } virtual ~MockVideoEncoderFactory() {} diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h index b2029b179..4925b9323 100644 --- a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h +++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h @@ -186,28 +186,26 @@ class SkipEncodingUnusedStreamsTest { return layers_->EncodeFlags(timestamp); } - virtual bool ConfigureBitrates(int bitrate_kbit, - int max_bitrate_kbit, - int framerate, - vpx_codec_enc_cfg_t* cfg) OVERRIDE { + bool ConfigureBitrates(int bitrate_kbit, + int max_bitrate_kbit, + int framerate, + vpx_codec_enc_cfg_t* cfg) override { configured_bitrate_ = bitrate_kbit; return layers_->ConfigureBitrates( bitrate_kbit, max_bitrate_kbit, framerate, cfg); } - virtual void PopulateCodecSpecific(bool base_layer_sync, - CodecSpecificInfoVP8* vp8_info, - uint32_t timestamp) OVERRIDE { + void PopulateCodecSpecific(bool base_layer_sync, + CodecSpecificInfoVP8* vp8_info, + uint32_t timestamp) override { layers_->PopulateCodecSpecific(base_layer_sync, vp8_info, timestamp); } - virtual void FrameEncoded(unsigned int size, uint32_t timestamp) OVERRIDE { + void FrameEncoded(unsigned int size, uint32_t timestamp) override { layers_->FrameEncoded(size, timestamp); } - virtual int CurrentLayerId() const OVERRIDE { - return layers_->CurrentLayerId(); - } + int CurrentLayerId() const override { return layers_->CurrentLayerId(); } int configured_bitrate_; TemporalLayers* layers_; @@ -216,8 +214,8 @@ class SkipEncodingUnusedStreamsTest { class SpyingTemporalLayersFactory : public TemporalLayers::Factory { public: virtual ~SpyingTemporalLayersFactory() {} - virtual TemporalLayers* Create(int temporal_layers, - uint8_t initial_tl0_pic_idx) const OVERRIDE { + TemporalLayers* Create(int temporal_layers, + uint8_t initial_tl0_pic_idx) const override { SpyingTemporalLayers* layers = new SpyingTemporalLayers(TemporalLayers::Factory::Create( temporal_layers, initial_tl0_pic_idx)); diff --git a/webrtc/modules/video_coding/codecs/vp8/vp8_factory.cc b/webrtc/modules/video_coding/codecs/vp8/vp8_factory.cc index 414b3a704..f701481b2 100644 --- a/webrtc/modules/video_coding/codecs/vp8/vp8_factory.cc +++ b/webrtc/modules/video_coding/codecs/vp8/vp8_factory.cc @@ -19,13 +19,9 @@ bool VP8EncoderFactoryConfig::use_simulcast_adapter_ = false; class VP8EncoderImplFactory : public VideoEncoderFactory { public: - virtual VideoEncoder* Create() OVERRIDE { - return new VP8EncoderImpl(); - } + VideoEncoder* Create() override { return new VP8EncoderImpl(); } - virtual void Destroy(VideoEncoder* encoder) OVERRIDE { - delete encoder; - } + void Destroy(VideoEncoder* encoder) override { delete encoder; } virtual ~VP8EncoderImplFactory() {} }; diff --git a/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h b/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h index 9d46d0d7b..019e73ea1 100644 --- a/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h +++ b/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h @@ -25,22 +25,21 @@ class VP9EncoderImpl : public VP9Encoder { virtual ~VP9EncoderImpl(); - virtual int Release() OVERRIDE; + int Release() override; - virtual int InitEncode(const VideoCodec* codec_settings, - int number_of_cores, - size_t max_payload_size) OVERRIDE; + int InitEncode(const VideoCodec* codec_settings, + int number_of_cores, + size_t max_payload_size) override; - virtual int Encode(const I420VideoFrame& input_image, - const CodecSpecificInfo* codec_specific_info, - const std::vector* frame_types) OVERRIDE; + int Encode(const I420VideoFrame& input_image, + const CodecSpecificInfo* codec_specific_info, + const std::vector* frame_types) override; - virtual int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) - OVERRIDE; + int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override; - virtual int SetChannelParameters(uint32_t packet_loss, int64_t rtt) OVERRIDE; + int SetChannelParameters(uint32_t packet_loss, int64_t rtt) override; - virtual int SetRates(uint32_t new_bitrate_kbit, uint32_t frame_rate) OVERRIDE; + int SetRates(uint32_t new_bitrate_kbit, uint32_t frame_rate) override; private: // Determine number of encoder threads to use. @@ -83,20 +82,19 @@ class VP9DecoderImpl : public VP9Decoder { virtual ~VP9DecoderImpl(); - virtual int InitDecode(const VideoCodec* inst, int number_of_cores) OVERRIDE; + int InitDecode(const VideoCodec* inst, int number_of_cores) override; - virtual int Decode(const EncodedImage& input_image, - bool missing_frames, - const RTPFragmentationHeader* fragmentation, - const CodecSpecificInfo* codec_specific_info, - int64_t /*render_time_ms*/) OVERRIDE; + int Decode(const EncodedImage& input_image, + bool missing_frames, + const RTPFragmentationHeader* fragmentation, + const CodecSpecificInfo* codec_specific_info, + int64_t /*render_time_ms*/) override; - virtual int RegisterDecodeCompleteCallback(DecodedImageCallback* callback) - OVERRIDE; + int RegisterDecodeCompleteCallback(DecodedImageCallback* callback) override; - virtual int Release() OVERRIDE; + int Release() override; - virtual int Reset() OVERRIDE; + int Reset() override; private: int ReturnFrame(const vpx_image_t* img, uint32_t timeStamp); diff --git a/webrtc/modules/video_coding/main/source/video_coding_impl.cc b/webrtc/modules/video_coding/main/source/video_coding_impl.cc index ff2ab9390..4f861535d 100644 --- a/webrtc/modules/video_coding/main/source/video_coding_impl.cc +++ b/webrtc/modules/video_coding/main/source/video_coding_impl.cc @@ -88,7 +88,7 @@ class VideoCodingModuleImpl : public VideoCodingModule { own_event_factory_.reset(); } - virtual int64_t TimeUntilNextProcess() OVERRIDE { + int64_t TimeUntilNextProcess() override { int64_t sender_time = sender_->TimeUntilNextProcess(); int64_t receiver_time = receiver_->TimeUntilNextProcess(); assert(sender_time >= 0); @@ -96,7 +96,7 @@ class VideoCodingModuleImpl : public VideoCodingModule { return VCM_MIN(sender_time, receiver_time); } - virtual int32_t Process() OVERRIDE { + int32_t Process() override { int32_t sender_return = sender_->Process(); int32_t receiver_return = receiver_->Process(); if (sender_return != VCM_OK) @@ -104,78 +104,75 @@ class VideoCodingModuleImpl : public VideoCodingModule { return receiver_return; } - virtual int32_t InitializeSender() OVERRIDE { - return sender_->InitializeSender(); - } + int32_t InitializeSender() override { return sender_->InitializeSender(); } - virtual int32_t RegisterSendCodec(const VideoCodec* sendCodec, - uint32_t numberOfCores, - uint32_t maxPayloadSize) OVERRIDE { + int32_t RegisterSendCodec(const VideoCodec* sendCodec, + uint32_t numberOfCores, + uint32_t maxPayloadSize) override { return sender_->RegisterSendCodec(sendCodec, numberOfCores, maxPayloadSize); } - virtual const VideoCodec& GetSendCodec() const OVERRIDE { + const VideoCodec& GetSendCodec() const override { return sender_->GetSendCodec(); } // DEPRECATED. - virtual int32_t SendCodec(VideoCodec* currentSendCodec) const OVERRIDE { + int32_t SendCodec(VideoCodec* currentSendCodec) const override { return sender_->SendCodecBlocking(currentSendCodec); } // DEPRECATED. - virtual VideoCodecType SendCodec() const OVERRIDE { + VideoCodecType SendCodec() const override { return sender_->SendCodecBlocking(); } - virtual int32_t RegisterExternalEncoder(VideoEncoder* externalEncoder, - uint8_t payloadType, - bool internalSource) OVERRIDE { + int32_t RegisterExternalEncoder(VideoEncoder* externalEncoder, + uint8_t payloadType, + bool internalSource) override { return sender_->RegisterExternalEncoder( externalEncoder, payloadType, internalSource); } - virtual int32_t CodecConfigParameters(uint8_t* buffer, - int32_t size) OVERRIDE { + int32_t CodecConfigParameters(uint8_t* buffer, int32_t size) override { return sender_->CodecConfigParameters(buffer, size); } - virtual int Bitrate(unsigned int* bitrate) const OVERRIDE { + int Bitrate(unsigned int* bitrate) const override { return sender_->Bitrate(bitrate); } - virtual int FrameRate(unsigned int* framerate) const OVERRIDE { + int FrameRate(unsigned int* framerate) const override { return sender_->FrameRate(framerate); } - virtual int32_t SetChannelParameters(uint32_t target_bitrate, // bits/s. - uint8_t lossRate, - int64_t rtt) OVERRIDE { + int32_t SetChannelParameters(uint32_t target_bitrate, // bits/s. + uint8_t lossRate, + int64_t rtt) override { return sender_->SetChannelParameters(target_bitrate, lossRate, rtt); } - virtual int32_t RegisterTransportCallback( - VCMPacketizationCallback* transport) OVERRIDE { + int32_t RegisterTransportCallback( + VCMPacketizationCallback* transport) override { return sender_->RegisterTransportCallback(transport); } - virtual int32_t RegisterSendStatisticsCallback( - VCMSendStatisticsCallback* sendStats) OVERRIDE { + int32_t RegisterSendStatisticsCallback( + VCMSendStatisticsCallback* sendStats) override { return sender_->RegisterSendStatisticsCallback(sendStats); } - virtual int32_t RegisterVideoQMCallback( - VCMQMSettingsCallback* videoQMSettings) OVERRIDE { + int32_t RegisterVideoQMCallback( + VCMQMSettingsCallback* videoQMSettings) override { return sender_->RegisterVideoQMCallback(videoQMSettings); } - virtual int32_t RegisterProtectionCallback( - VCMProtectionCallback* protection) OVERRIDE { + int32_t RegisterProtectionCallback( + VCMProtectionCallback* protection) override { return sender_->RegisterProtectionCallback(protection); } - virtual int32_t SetVideoProtection(VCMVideoProtection videoProtection, - bool enable) OVERRIDE { + int32_t SetVideoProtection(VCMVideoProtection videoProtection, + bool enable) override { int32_t sender_return = sender_->SetVideoProtection(videoProtection, enable); int32_t receiver_return = @@ -185,172 +182,168 @@ class VideoCodingModuleImpl : public VideoCodingModule { return sender_return; } - virtual int32_t AddVideoFrame( - const I420VideoFrame& videoFrame, - const VideoContentMetrics* contentMetrics, - const CodecSpecificInfo* codecSpecificInfo) OVERRIDE { + int32_t AddVideoFrame(const I420VideoFrame& videoFrame, + const VideoContentMetrics* contentMetrics, + const CodecSpecificInfo* codecSpecificInfo) override { return sender_->AddVideoFrame( videoFrame, contentMetrics, codecSpecificInfo); } - virtual int32_t IntraFrameRequest(int stream_index) OVERRIDE { + int32_t IntraFrameRequest(int stream_index) override { return sender_->IntraFrameRequest(stream_index); } - virtual int32_t EnableFrameDropper(bool enable) OVERRIDE { + int32_t EnableFrameDropper(bool enable) override { return sender_->EnableFrameDropper(enable); } - virtual int32_t SentFrameCount(VCMFrameCount& frameCount) const OVERRIDE { + int32_t SentFrameCount(VCMFrameCount& frameCount) const override { return sender_->SentFrameCount(&frameCount); } - virtual int SetSenderNackMode(SenderNackMode mode) OVERRIDE { + int SetSenderNackMode(SenderNackMode mode) override { return sender_->SetSenderNackMode(mode); } - virtual int SetSenderReferenceSelection(bool enable) OVERRIDE { + int SetSenderReferenceSelection(bool enable) override { return sender_->SetSenderReferenceSelection(enable); } - virtual int SetSenderFEC(bool enable) OVERRIDE { + int SetSenderFEC(bool enable) override { return sender_->SetSenderFEC(enable); } - virtual int SetSenderKeyFramePeriod(int periodMs) OVERRIDE { + int SetSenderKeyFramePeriod(int periodMs) override { return sender_->SetSenderKeyFramePeriod(periodMs); } - virtual int StartDebugRecording(const char* file_name_utf8) OVERRIDE { + int StartDebugRecording(const char* file_name_utf8) override { return sender_->StartDebugRecording(file_name_utf8); } - virtual int StopDebugRecording() OVERRIDE { + int StopDebugRecording() override { sender_->StopDebugRecording(); return VCM_OK; } - virtual void SuspendBelowMinBitrate() OVERRIDE { + void SuspendBelowMinBitrate() override { return sender_->SuspendBelowMinBitrate(); } - virtual bool VideoSuspended() const OVERRIDE { - return sender_->VideoSuspended(); - } + bool VideoSuspended() const override { return sender_->VideoSuspended(); } - virtual int32_t InitializeReceiver() OVERRIDE { + int32_t InitializeReceiver() override { return receiver_->InitializeReceiver(); } - virtual int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec, - int32_t numberOfCores, - bool requireKeyFrame) OVERRIDE { + int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec, + int32_t numberOfCores, + bool requireKeyFrame) override { return receiver_->RegisterReceiveCodec( receiveCodec, numberOfCores, requireKeyFrame); } - virtual int32_t RegisterExternalDecoder(VideoDecoder* externalDecoder, - uint8_t payloadType, - bool internalRenderTiming) OVERRIDE { + int32_t RegisterExternalDecoder(VideoDecoder* externalDecoder, + uint8_t payloadType, + bool internalRenderTiming) override { return receiver_->RegisterExternalDecoder( externalDecoder, payloadType, internalRenderTiming); } - virtual int32_t RegisterReceiveCallback( - VCMReceiveCallback* receiveCallback) OVERRIDE { + int32_t RegisterReceiveCallback( + VCMReceiveCallback* receiveCallback) override { return receiver_->RegisterReceiveCallback(receiveCallback); } - virtual int32_t RegisterReceiveStatisticsCallback( - VCMReceiveStatisticsCallback* receiveStats) OVERRIDE { + int32_t RegisterReceiveStatisticsCallback( + VCMReceiveStatisticsCallback* receiveStats) override { return receiver_->RegisterReceiveStatisticsCallback(receiveStats); } - virtual int32_t RegisterDecoderTimingCallback( - VCMDecoderTimingCallback* decoderTiming) OVERRIDE { + int32_t RegisterDecoderTimingCallback( + VCMDecoderTimingCallback* decoderTiming) override { return receiver_->RegisterDecoderTimingCallback(decoderTiming); } - virtual int32_t RegisterFrameTypeCallback( - VCMFrameTypeCallback* frameTypeCallback) OVERRIDE { + int32_t RegisterFrameTypeCallback( + VCMFrameTypeCallback* frameTypeCallback) override { return receiver_->RegisterFrameTypeCallback(frameTypeCallback); } - virtual int32_t RegisterPacketRequestCallback( - VCMPacketRequestCallback* callback) OVERRIDE { + int32_t RegisterPacketRequestCallback( + VCMPacketRequestCallback* callback) override { return receiver_->RegisterPacketRequestCallback(callback); } - virtual int RegisterRenderBufferSizeCallback( - VCMRenderBufferSizeCallback* callback) OVERRIDE { + int RegisterRenderBufferSizeCallback( + VCMRenderBufferSizeCallback* callback) override { return receiver_->RegisterRenderBufferSizeCallback(callback); } - virtual int32_t Decode(uint16_t maxWaitTimeMs) OVERRIDE { + int32_t Decode(uint16_t maxWaitTimeMs) override { return receiver_->Decode(maxWaitTimeMs); } - virtual int32_t ResetDecoder() OVERRIDE { return receiver_->ResetDecoder(); } + int32_t ResetDecoder() override { return receiver_->ResetDecoder(); } - virtual int32_t ReceiveCodec(VideoCodec* currentReceiveCodec) const OVERRIDE { + int32_t ReceiveCodec(VideoCodec* currentReceiveCodec) const override { return receiver_->ReceiveCodec(currentReceiveCodec); } - virtual VideoCodecType ReceiveCodec() const OVERRIDE { + VideoCodecType ReceiveCodec() const override { return receiver_->ReceiveCodec(); } - virtual int32_t IncomingPacket(const uint8_t* incomingPayload, - size_t payloadLength, - const WebRtcRTPHeader& rtpInfo) OVERRIDE { + int32_t IncomingPacket(const uint8_t* incomingPayload, + size_t payloadLength, + const WebRtcRTPHeader& rtpInfo) override { return receiver_->IncomingPacket(incomingPayload, payloadLength, rtpInfo); } - virtual int32_t SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) OVERRIDE { + int32_t SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) override { return receiver_->SetMinimumPlayoutDelay(minPlayoutDelayMs); } - virtual int32_t SetRenderDelay(uint32_t timeMS) OVERRIDE { + int32_t SetRenderDelay(uint32_t timeMS) override { return receiver_->SetRenderDelay(timeMS); } - virtual int32_t Delay() const OVERRIDE { return receiver_->Delay(); } + int32_t Delay() const override { return receiver_->Delay(); } - virtual uint32_t DiscardedPackets() const OVERRIDE { + uint32_t DiscardedPackets() const override { return receiver_->DiscardedPackets(); } - virtual int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode, - VCMDecodeErrorMode errorMode) OVERRIDE { + int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode, + VCMDecodeErrorMode errorMode) override { return receiver_->SetReceiverRobustnessMode(robustnessMode, errorMode); } - virtual void SetNackSettings(size_t max_nack_list_size, - int max_packet_age_to_nack, - int max_incomplete_time_ms) OVERRIDE { + void SetNackSettings(size_t max_nack_list_size, + int max_packet_age_to_nack, + int max_incomplete_time_ms) override { return receiver_->SetNackSettings( max_nack_list_size, max_packet_age_to_nack, max_incomplete_time_ms); } - void SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) OVERRIDE { + void SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) override { return receiver_->SetDecodeErrorMode(decode_error_mode); } - virtual int SetMinReceiverDelay(int desired_delay_ms) OVERRIDE { + int SetMinReceiverDelay(int desired_delay_ms) override { return receiver_->SetMinReceiverDelay(desired_delay_ms); } - virtual int32_t SetReceiveChannelParameters(int64_t rtt) OVERRIDE { + int32_t SetReceiveChannelParameters(int64_t rtt) override { return receiver_->SetReceiveChannelParameters(rtt); } - virtual void RegisterPreDecodeImageCallback( - EncodedImageCallback* observer) OVERRIDE { + void RegisterPreDecodeImageCallback(EncodedImageCallback* observer) override { receiver_->RegisterPreDecodeImageCallback(observer); } - virtual void RegisterPostEncodeImageCallback( - EncodedImageCallback* observer) OVERRIDE { + void RegisterPostEncodeImageCallback( + EncodedImageCallback* observer) override { post_encode_callback_.Register(observer); } diff --git a/webrtc/modules/video_coding/main/source/video_sender_unittest.cc b/webrtc/modules/video_coding/main/source/video_sender_unittest.cc index 6666e4b78..de596d8e8 100644 --- a/webrtc/modules/video_coding/main/source/video_sender_unittest.cc +++ b/webrtc/modules/video_coding/main/source/video_sender_unittest.cc @@ -70,7 +70,7 @@ MATCHER_P(MatchesVp8StreamInfo, expected, "") { class EmptyFrameGenerator : public FrameGenerator { public: - virtual I420VideoFrame* NextFrame() OVERRIDE { + I420VideoFrame* NextFrame() override { frame_.reset(new I420VideoFrame()); return frame_.get(); } @@ -86,10 +86,10 @@ class PacketizationCallback : public VCMPacketizationCallback { virtual ~PacketizationCallback() {} - virtual int32_t SendData(uint8_t payload_type, - const EncodedImage& encoded_image, - const RTPFragmentationHeader& fragmentation_header, - const RTPVideoHeader* rtp_video_header) OVERRIDE { + int32_t SendData(uint8_t payload_type, + const EncodedImage& encoded_image, + const RTPFragmentationHeader& fragmentation_header, + const RTPVideoHeader* rtp_video_header) override { assert(rtp_video_header); frame_data_.push_back(FrameData(encoded_image._length, *rtp_video_header)); return 0; @@ -171,7 +171,7 @@ class TestVideoSender : public ::testing::Test { // a special case (e.g. frame rate in media optimization). TestVideoSender() : clock_(1000), packetization_callback_(&clock_) {} - virtual void SetUp() OVERRIDE { + void SetUp() override { sender_.reset(new VideoSender(&clock_, &post_encode_callback_, nullptr)); EXPECT_EQ(0, sender_->InitializeSender()); EXPECT_EQ(0, sender_->RegisterTransportCallback(&packetization_callback_)); @@ -197,7 +197,7 @@ class TestVideoSenderWithMockEncoder : public TestVideoSender { static const int kNumberOfLayers = 3; static const int kUnusedPayloadType = 10; - virtual void SetUp() OVERRIDE { + void SetUp() override { TestVideoSender::SetUp(); generator_.reset(new EmptyFrameGenerator()); EXPECT_EQ( @@ -220,7 +220,7 @@ class TestVideoSenderWithMockEncoder : public TestVideoSender { EXPECT_EQ(0, sender_->RegisterSendCodec(&settings_, 1, 1200)); } - virtual void TearDown() OVERRIDE { sender_.reset(); } + void TearDown() override { sender_.reset(); } void ExpectIntraRequest(int stream) { if (stream == -1) { @@ -313,7 +313,7 @@ class TestVideoSenderWithVp8 : public TestVideoSender { TestVideoSenderWithVp8() : codec_bitrate_kbps_(300), available_bitrate_kbps_(1000) {} - virtual void SetUp() OVERRIDE { + void SetUp() override { TestVideoSender::SetUp(); const char* input_video = "foreman_cif"; diff --git a/webrtc/modules/video_coding/main/test/generic_codec_test.h b/webrtc/modules/video_coding/main/test/generic_codec_test.h index 3b3ddcec5..9b041ce39 100644 --- a/webrtc/modules/video_coding/main/test/generic_codec_test.h +++ b/webrtc/modules/video_coding/main/test/generic_codec_test.h @@ -75,10 +75,8 @@ class RTPSendCallback_SizeTest : public webrtc::Transport public: // constructor input: (receive side) rtp module to send encoded data to RTPSendCallback_SizeTest() : _maxPayloadSize(0), _payloadSizeSum(0), _nPackets(0) {} - virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE; - virtual int SendRTCPPacket(int channel, - const void *data, - size_t len) OVERRIDE { + int SendPacket(int channel, const void* data, size_t len) override; + int SendRTCPPacket(int channel, const void* data, size_t len) override { return 0; } void SetMaxPayloadSize(size_t maxPayloadSize); @@ -94,11 +92,10 @@ class VCMEncComplete_KeyReqTest : public webrtc::VCMPacketizationCallback { public: VCMEncComplete_KeyReqTest(webrtc::VideoCodingModule &vcm) : _vcm(vcm), _seqNo(0), _timeStamp(0) {} - virtual int32_t SendData( - uint8_t payloadType, - const webrtc::EncodedImage& encoded_image, - const webrtc::RTPFragmentationHeader& fragmentationHeader, - const webrtc::RTPVideoHeader* videoHdr) OVERRIDE; + int32_t SendData(uint8_t payloadType, + const webrtc::EncodedImage& encoded_image, + const webrtc::RTPFragmentationHeader& fragmentationHeader, + const webrtc::RTPVideoHeader* videoHdr) override; private: webrtc::VideoCodingModule& _vcm; diff --git a/webrtc/modules/video_coding/main/test/mt_test_common.h b/webrtc/modules/video_coding/main/test/mt_test_common.h index 78d73e21a..c76736e51 100644 --- a/webrtc/modules/video_coding/main/test/mt_test_common.h +++ b/webrtc/modules/video_coding/main/test/mt_test_common.h @@ -52,7 +52,7 @@ class TransportCallback:public RTPSendCompleteCallback // Add packets to list // Incorporate network conditions - delay and packet loss // Actual transmission will occur on a separate thread - virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE; + int SendPacket(int channel, const void* data, size_t len) override; // Send to the receiver packets which are ready to be submitted int TransportPackets(); }; diff --git a/webrtc/modules/video_coding/main/test/normal_test.h b/webrtc/modules/video_coding/main/test/normal_test.h index b2fb38747..0015171e8 100644 --- a/webrtc/modules/video_coding/main/test/normal_test.h +++ b/webrtc/modules/video_coding/main/test/normal_test.h @@ -32,11 +32,10 @@ class VCMNTEncodeCompleteCallback : public webrtc::VCMPacketizationCallback void RegisterTransportCallback(webrtc::VCMPacketizationCallback* transport); // process encoded data received from the encoder, // pass stream to the VCMReceiver module - virtual int32_t SendData( - uint8_t payloadType, - const webrtc::EncodedImage& encoded_image, - const webrtc::RTPFragmentationHeader& fragmentationHeader, - const webrtc::RTPVideoHeader* videoHdr) OVERRIDE; + int32_t SendData(uint8_t payloadType, + const webrtc::EncodedImage& encoded_image, + const webrtc::RTPFragmentationHeader& fragmentationHeader, + const webrtc::RTPVideoHeader* videoHdr) override; // Register existing VCM. // Currently - encode and decode with the same vcm module. @@ -69,7 +68,7 @@ public: void SetUserReceiveCallback(webrtc::VCMReceiveCallback* receiveCallback); // will write decoded frame into file - virtual int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) OVERRIDE; + int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) override; size_t DecodedBytes(); private: diff --git a/webrtc/modules/video_coding/main/test/receiver_tests.h b/webrtc/modules/video_coding/main/test/receiver_tests.h index de1eb638c..eb0a35a71 100644 --- a/webrtc/modules/video_coding/main/test/receiver_tests.h +++ b/webrtc/modules/video_coding/main/test/receiver_tests.h @@ -27,10 +27,10 @@ class RtpDataCallback : public webrtc::NullRtpData { RtpDataCallback(webrtc::VideoCodingModule* vcm) : vcm_(vcm) {} virtual ~RtpDataCallback() {} - virtual int32_t OnReceivedPayloadData( + int32_t OnReceivedPayloadData( const uint8_t* payload_data, const size_t payload_size, - const webrtc::WebRtcRTPHeader* rtp_header) OVERRIDE { + const webrtc::WebRtcRTPHeader* rtp_header) override { return vcm_->IncomingPacket(payload_data, payload_size, *rtp_header); } diff --git a/webrtc/modules/video_coding/main/test/test_callbacks.h b/webrtc/modules/video_coding/main/test/test_callbacks.h index 3fe991adc..3d3c543f0 100644 --- a/webrtc/modules/video_coding/main/test/test_callbacks.h +++ b/webrtc/modules/video_coding/main/test/test_callbacks.h @@ -44,10 +44,10 @@ public: void RegisterTransportCallback(VCMPacketizationCallback* transport); // Process encoded data received from the encoder, pass stream to the // VCMReceiver module - virtual int32_t SendData(uint8_t payloadType, - const EncodedImage& encoded_image, - const RTPFragmentationHeader& fragmentationHeader, - const RTPVideoHeader* videoHdr) OVERRIDE; + int32_t SendData(uint8_t payloadType, + const EncodedImage& encoded_image, + const RTPFragmentationHeader& fragmentationHeader, + const RTPVideoHeader* videoHdr) override; // Register exisitng VCM. Currently - encode and decode under same module. void RegisterReceiverVCM(VideoCodingModule *vcm) {_VCMReceiver = vcm;} // Return size of last encoded frame data (all frames in the sequence) @@ -97,10 +97,10 @@ public: virtual ~VCMRTPEncodeCompleteCallback() {} // Process encoded data received from the encoder, pass stream to the // RTP module - virtual int32_t SendData(uint8_t payloadType, - const EncodedImage& encoded_image, - const RTPFragmentationHeader& fragmentationHeader, - const RTPVideoHeader* videoHdr) OVERRIDE; + int32_t SendData(uint8_t payloadType, + const EncodedImage& encoded_image, + const RTPFragmentationHeader& fragmentationHeader, + const RTPVideoHeader* videoHdr) override; // Return size of last encoded frame. Value good for one call // (resets to zero after call to inform test of frame drop) size_t EncodedBytes(); @@ -136,7 +136,7 @@ public: _decodedFile(decodedFile), _decodedBytes(0) {} virtual ~VCMDecodeCompleteCallback() {} // Write decoded frame into file - virtual int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) OVERRIDE; + int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) override; size_t DecodedBytes(); private: FILE* _decodedFile; @@ -157,11 +157,9 @@ public: void SetRtpModule(RtpRtcp* rtp_module) { _rtp = rtp_module; } // Send Packet to receive side RTP module - virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE; + int SendPacket(int channel, const void* data, size_t len) override; // Send RTCP Packet to receive side RTP module - virtual int SendRTCPPacket(int channel, - const void *data, - size_t len) OVERRIDE; + int SendRTCPPacket(int channel, const void* data, size_t len) override; // Set percentage of channel loss in the network void SetLossPct(double lossPct); // Set average size of burst loss @@ -203,8 +201,9 @@ class PacketRequester: public VCMPacketRequestCallback public: PacketRequester(RtpRtcp& rtp) : _rtp(rtp) {} - virtual int32_t ResendPackets(const uint16_t* sequenceNumbers, - uint16_t length) OVERRIDE; + int32_t ResendPackets(const uint16_t* sequenceNumbers, + uint16_t length) override; + private: webrtc::RtpRtcp& _rtp; }; @@ -213,7 +212,7 @@ private: class KeyFrameReqTest: public VCMFrameTypeCallback { public: - virtual int32_t RequestKeyFrame() OVERRIDE; + int32_t RequestKeyFrame() override; }; @@ -222,8 +221,8 @@ class SendStatsTest: public webrtc::VCMSendStatisticsCallback { public: SendStatsTest() : _framerate(15), _bitrate(500) {} - virtual int32_t SendStatistics(const uint32_t bitRate, - const uint32_t frameRate) OVERRIDE; + int32_t SendStatistics(const uint32_t bitRate, + const uint32_t frameRate) override; void set_framerate(uint32_t frameRate) {_framerate = frameRate;} void set_bitrate(uint32_t bitrate) {_bitrate = bitrate;} private: @@ -239,12 +238,11 @@ public: VideoProtectionCallback(); virtual ~VideoProtectionCallback(); void RegisterRtpModule(RtpRtcp* rtp) {_rtp = rtp;} - virtual int32_t ProtectionRequest( - const FecProtectionParams* delta_fec_params, - const FecProtectionParams* key_fec_params, - uint32_t* sent_video_rate_bps, - uint32_t* sent_nack_rate_bps, - uint32_t* sent_fec_rate_bps) OVERRIDE; + int32_t ProtectionRequest(const FecProtectionParams* delta_fec_params, + const FecProtectionParams* key_fec_params, + uint32_t* sent_video_rate_bps, + uint32_t* sent_nack_rate_bps, + uint32_t* sent_fec_rate_bps) override; FecProtectionParams DeltaFecParameters() const; FecProtectionParams KeyFecParameters() const; private: diff --git a/webrtc/modules/video_coding/main/test/vcm_payload_sink_factory.cc b/webrtc/modules/video_coding/main/test/vcm_payload_sink_factory.cc index 3f2d60987..e8dbe8df0 100644 --- a/webrtc/modules/video_coding/main/test/vcm_payload_sink_factory.cc +++ b/webrtc/modules/video_coding/main/test/vcm_payload_sink_factory.cc @@ -48,22 +48,20 @@ class VcmPayloadSinkFactory::VcmPayloadSink } // PayloadSinkInterface - virtual int32_t OnReceivedPayloadData( - const uint8_t* payload_data, - const size_t payload_size, - const WebRtcRTPHeader* rtp_header) OVERRIDE { + int32_t OnReceivedPayloadData(const uint8_t* payload_data, + const size_t payload_size, + const WebRtcRTPHeader* rtp_header) override { return vcm_->IncomingPacket(payload_data, payload_size, *rtp_header); } - virtual bool OnRecoveredPacket(const uint8_t* packet, - size_t packet_length) OVERRIDE { + bool OnRecoveredPacket(const uint8_t* packet, size_t packet_length) override { // We currently don't handle FEC. return true; } // VCMPacketRequestCallback - virtual int32_t ResendPackets(const uint16_t* sequence_numbers, - uint16_t length) OVERRIDE { + int32_t ResendPackets(const uint16_t* sequence_numbers, + uint16_t length) override { stream_->ResendPackets(sequence_numbers, length); return 0; } diff --git a/webrtc/modules/video_processing/main/interface/video_processing.h b/webrtc/modules/video_processing/main/interface/video_processing.h index a4425afc6..fb6770b7a 100644 --- a/webrtc/modules/video_processing/main/interface/video_processing.h +++ b/webrtc/modules/video_processing/main/interface/video_processing.h @@ -89,12 +89,12 @@ class VideoProcessingModule : public Module { /** Not supported. */ - virtual int64_t TimeUntilNextProcess() OVERRIDE { return -1; } + int64_t TimeUntilNextProcess() override { return -1; } /** Not supported. */ - virtual int32_t Process() OVERRIDE { return -1; } + int32_t Process() override { return -1; } /** Resets all processing components to their initial states. This should be diff --git a/webrtc/modules/video_processing/main/source/video_processing_impl.h b/webrtc/modules/video_processing/main/source/video_processing_impl.h index 69dcec4e1..14a9e5483 100644 --- a/webrtc/modules/video_processing/main/source/video_processing_impl.h +++ b/webrtc/modules/video_processing/main/source/video_processing_impl.h @@ -27,43 +27,40 @@ class VideoProcessingModuleImpl : public VideoProcessingModule { virtual ~VideoProcessingModuleImpl(); - virtual void Reset() OVERRIDE; + void Reset() override; - virtual int32_t Deflickering(I420VideoFrame* frame, - FrameStats* stats) OVERRIDE; + int32_t Deflickering(I420VideoFrame* frame, FrameStats* stats) override; - virtual int32_t BrightnessDetection(const I420VideoFrame& frame, - const FrameStats& stats) OVERRIDE; + int32_t BrightnessDetection(const I420VideoFrame& frame, + const FrameStats& stats) override; // Frame pre-processor functions // Enable temporal decimation - virtual void EnableTemporalDecimation(bool enable) OVERRIDE; + void EnableTemporalDecimation(bool enable) override; - virtual void SetInputFrameResampleMode( - VideoFrameResampling resampling_mode) OVERRIDE; + void SetInputFrameResampleMode(VideoFrameResampling resampling_mode) override; // Enable content analysis - virtual void EnableContentAnalysis(bool enable) OVERRIDE; + void EnableContentAnalysis(bool enable) override; // Set Target Resolution: frame rate and dimension - virtual int32_t SetTargetResolution(uint32_t width, - uint32_t height, - uint32_t frame_rate) OVERRIDE; - + int32_t SetTargetResolution(uint32_t width, + uint32_t height, + uint32_t frame_rate) override; // Get decimated values: frame rate/dimension - virtual uint32_t Decimatedframe_rate() OVERRIDE; - virtual uint32_t DecimatedWidth() const OVERRIDE; - virtual uint32_t DecimatedHeight() const OVERRIDE; + uint32_t Decimatedframe_rate() override; + uint32_t DecimatedWidth() const override; + uint32_t DecimatedHeight() const override; // Preprocess: // Pre-process incoming frame: Sample when needed and compute content // metrics when enabled. // If no resampling takes place - processed_frame is set to NULL. - virtual int32_t PreprocessFrame(const I420VideoFrame& frame, - I420VideoFrame** processed_frame) OVERRIDE; - virtual VideoContentMetrics* ContentMetrics() const OVERRIDE; + int32_t PreprocessFrame(const I420VideoFrame& frame, + I420VideoFrame** processed_frame) override; + VideoContentMetrics* ContentMetrics() const override; private: CriticalSectionWrapper& mutex_; diff --git a/webrtc/modules/video_render/include/video_render.h b/webrtc/modules/video_render/include/video_render.h index 600615f02..15dfd920b 100644 --- a/webrtc/modules/video_render/include/video_render.h +++ b/webrtc/modules/video_render/include/video_render.h @@ -52,8 +52,8 @@ public: */ static void DestroyVideoRender(VideoRender* module); - virtual int64_t TimeUntilNextProcess() OVERRIDE = 0; - virtual int32_t Process() OVERRIDE = 0; + int64_t TimeUntilNextProcess() override = 0; + int32_t Process() override = 0; /************************************************************************** * diff --git a/webrtc/modules/video_render/ios/video_render_ios_channel.h b/webrtc/modules/video_render/ios/video_render_ios_channel.h index 53020b615..2d635a700 100644 --- a/webrtc/modules/video_render/ios/video_render_ios_channel.h +++ b/webrtc/modules/video_render/ios/video_render_ios_channel.h @@ -24,8 +24,8 @@ class VideoRenderIosChannel : public VideoRenderCallback { virtual ~VideoRenderIosChannel(); // Implementation of VideoRenderCallback. - virtual int32_t RenderFrame(const uint32_t stream_id, - I420VideoFrame& video_frame) OVERRIDE; + int32_t RenderFrame(const uint32_t stream_id, + I420VideoFrame& video_frame) override; int SetStreamSettings(const float z_order, const float left, diff --git a/webrtc/modules/video_render/ios/video_render_ios_impl.h b/webrtc/modules/video_render/ios/video_render_ios_impl.h index 7e3029c6e..7fb46bf2e 100644 --- a/webrtc/modules/video_render/ios/video_render_ios_impl.h +++ b/webrtc/modules/video_render/ios/video_render_ios_impl.h @@ -30,50 +30,50 @@ class VideoRenderIosImpl : IVideoRender { ~VideoRenderIosImpl(); // Implementation of IVideoRender. - int32_t Init() OVERRIDE; - int32_t ChangeWindow(void* window) OVERRIDE; + int32_t Init() override; + int32_t ChangeWindow(void* window) override; VideoRenderCallback* AddIncomingRenderStream(const uint32_t stream_id, const uint32_t z_order, const float left, const float top, const float right, - const float bottom) OVERRIDE; + const float bottom) override; - int32_t DeleteIncomingRenderStream(const uint32_t stream_id) OVERRIDE; + int32_t DeleteIncomingRenderStream(const uint32_t stream_id) override; int32_t GetIncomingRenderStreamProperties(const uint32_t stream_id, uint32_t& z_order, float& left, float& top, float& right, - float& bottom) const OVERRIDE; + float& bottom) const override; - int32_t StartRender() OVERRIDE; - int32_t StopRender() OVERRIDE; + int32_t StartRender() override; + int32_t StopRender() override; - VideoRenderType RenderType() OVERRIDE; - RawVideoType PerferedVideoType() OVERRIDE; - bool FullScreen() OVERRIDE; + VideoRenderType RenderType() override; + RawVideoType PerferedVideoType() override; + bool FullScreen() override; int32_t GetGraphicsMemory( uint64_t& total_graphics_memory, - uint64_t& available_graphics_memory) const OVERRIDE; // NOLINT + uint64_t& available_graphics_memory) const override; // NOLINT int32_t GetScreenResolution( uint32_t& screen_width, - uint32_t& screen_height) const OVERRIDE; // NOLINT + uint32_t& screen_height) const override; // NOLINT uint32_t RenderFrameRate(const uint32_t stream_id); int32_t SetStreamCropping(const uint32_t stream_id, const float left, const float top, const float right, - const float bottom) OVERRIDE; + const float bottom) override; int32_t ConfigureRenderer(const uint32_t stream_id, const unsigned int z_order, const float left, const float top, const float right, - const float bottom) OVERRIDE; - int32_t SetTransparentBackground(const bool enable) OVERRIDE; + const float bottom) override; + int32_t SetTransparentBackground(const bool enable) override; int32_t SetText(const uint8_t text_id, const uint8_t* text, const int32_t text_length, @@ -82,7 +82,7 @@ class VideoRenderIosImpl : IVideoRender { const float left, const float top, const float right, - const float bottom) OVERRIDE; + const float bottom) override; int32_t SetBitmap(const void* bit_map, const uint8_t picture_id, const void* color_key, diff --git a/webrtc/p2p/base/fakesession.h b/webrtc/p2p/base/fakesession.h index 6f43b65de..f942487c9 100644 --- a/webrtc/p2p/base/fakesession.h +++ b/webrtc/p2p/base/fakesession.h @@ -295,7 +295,7 @@ class FakeTransportChannel : public TransportChannelImpl, } } - virtual bool GetStats(ConnectionInfos* infos) OVERRIDE { + bool GetStats(ConnectionInfos* infos) override { ConnectionInfo info; infos->clear(); infos->push_back(info); diff --git a/webrtc/p2p/base/teststunserver.h b/webrtc/p2p/base/teststunserver.h index a2a8b6fc1..1911a0b73 100644 --- a/webrtc/p2p/base/teststunserver.h +++ b/webrtc/p2p/base/teststunserver.h @@ -39,7 +39,7 @@ class TestStunServer : StunServer { explicit TestStunServer(rtc::AsyncUDPSocket* socket) : StunServer(socket) {} void OnBindingRequest(StunMessage* msg, - const rtc::SocketAddress& remote_addr) OVERRIDE { + const rtc::SocketAddress& remote_addr) override { if (fake_stun_addr_.IsNil()) { StunServer::OnBindingRequest(msg, remote_addr); } else { diff --git a/webrtc/system_wrappers/interface/clock.h b/webrtc/system_wrappers/interface/clock.h index 4da3203a4..a103d9515 100644 --- a/webrtc/system_wrappers/interface/clock.h +++ b/webrtc/system_wrappers/interface/clock.h @@ -53,22 +53,21 @@ class SimulatedClock : public Clock { public: explicit SimulatedClock(int64_t initial_time_us); - virtual ~SimulatedClock(); + ~SimulatedClock() override; // Return a timestamp in milliseconds relative to some arbitrary source; the // source is fixed for this clock. - virtual int64_t TimeInMilliseconds() const OVERRIDE; + int64_t TimeInMilliseconds() const override; // Return a timestamp in microseconds relative to some arbitrary source; the // source is fixed for this clock. - virtual int64_t TimeInMicroseconds() const OVERRIDE; + int64_t TimeInMicroseconds() const override; // Retrieve an NTP absolute timestamp in milliseconds. - virtual void CurrentNtp(uint32_t& seconds, - uint32_t& fractions) const OVERRIDE; + void CurrentNtp(uint32_t& seconds, uint32_t& fractions) const override; // Converts an NTP timestamp to a millisecond timestamp. - virtual int64_t CurrentNtpInMilliseconds() const OVERRIDE; + int64_t CurrentNtpInMilliseconds() const override; // Advance the simulated clock with a given number of milliseconds or // microseconds. diff --git a/webrtc/system_wrappers/interface/file_wrapper.h b/webrtc/system_wrappers/interface/file_wrapper.h index a61863433..8f4e09f9c 100644 --- a/webrtc/system_wrappers/interface/file_wrapper.h +++ b/webrtc/system_wrappers/interface/file_wrapper.h @@ -66,20 +66,11 @@ class FileWrapper : public InStream, public OutStream { // specifiers. Returns the number of characters written or -1 on error. virtual int WriteText(const char* format, ...) = 0; - // Inherited from Instream. - // Reads |length| bytes from file to |buf|. Returns the number of bytes read - // or -1 on error. - virtual int Read(void* buf, size_t length) = 0; - - // Inherited from OutStream. - // Writes |length| bytes from |buf| to file. The actual writing may happen - // some time later. Call Flush() to force a write. - virtual bool Write(const void* buf, size_t length) = 0; - // Inherited from both Instream and OutStream. // Rewinds the file to the start. Only available when OpenFile() has been // called with |loop| == true or |readOnly| == true. - virtual int Rewind() = 0; + // virtual int Rewind() = 0; + int Rewind() override; }; } // namespace webrtc diff --git a/webrtc/system_wrappers/source/clock.cc b/webrtc/system_wrappers/source/clock.cc index 8e69652a8..a7f261a8b 100644 --- a/webrtc/system_wrappers/source/clock.cc +++ b/webrtc/system_wrappers/source/clock.cc @@ -36,19 +36,18 @@ int64_t Clock::NtpToMs(uint32_t ntp_secs, uint32_t ntp_frac) { class RealTimeClock : public Clock { // Return a timestamp in milliseconds relative to some arbitrary source; the // source is fixed for this clock. - virtual int64_t TimeInMilliseconds() const OVERRIDE { + int64_t TimeInMilliseconds() const override { return TickTime::MillisecondTimestamp(); } // Return a timestamp in microseconds relative to some arbitrary source; the // source is fixed for this clock. - virtual int64_t TimeInMicroseconds() const OVERRIDE { + int64_t TimeInMicroseconds() const override { return TickTime::MicrosecondTimestamp(); } // Retrieve an NTP absolute timestamp in seconds and fractions of a second. - virtual void CurrentNtp(uint32_t& seconds, - uint32_t& fractions) const OVERRIDE { + void CurrentNtp(uint32_t& seconds, uint32_t& fractions) const override { timeval tv = CurrentTimeVal(); double microseconds_in_seconds; Adjust(tv, &seconds, µseconds_in_seconds); @@ -57,7 +56,7 @@ class RealTimeClock : public Clock { } // Retrieve an NTP absolute timestamp in milliseconds. - virtual int64_t CurrentNtpInMilliseconds() const OVERRIDE { + int64_t CurrentNtpInMilliseconds() const override { timeval tv = CurrentTimeVal(); uint32_t seconds; double microseconds_in_seconds; @@ -103,7 +102,7 @@ class WindowsRealTimeClock : public RealTimeClock { LARGE_INTEGER counter_ms; }; - virtual timeval CurrentTimeVal() const OVERRIDE { + timeval CurrentTimeVal() const override { const uint64_t FILETIME_1970 = 0x019db1ded53e8000; FILETIME StartTime; @@ -191,10 +190,10 @@ class UnixRealTimeClock : public RealTimeClock { public: UnixRealTimeClock() {} - virtual ~UnixRealTimeClock() {} + ~UnixRealTimeClock() override {} protected: - virtual timeval CurrentTimeVal() const OVERRIDE { + timeval CurrentTimeVal() const override { struct timeval tv; struct timezone tz; tz.tz_minuteswest = 0; diff --git a/webrtc/system_wrappers/source/condition_variable_posix.h b/webrtc/system_wrappers/source/condition_variable_posix.h index a014a3b72..b29e116d7 100644 --- a/webrtc/system_wrappers/source/condition_variable_posix.h +++ b/webrtc/system_wrappers/source/condition_variable_posix.h @@ -21,13 +21,13 @@ namespace webrtc { class ConditionVariablePosix : public ConditionVariableWrapper { public: static ConditionVariableWrapper* Create(); - virtual ~ConditionVariablePosix(); + ~ConditionVariablePosix() override; - virtual void SleepCS(CriticalSectionWrapper& crit_sect) OVERRIDE; - virtual bool SleepCS(CriticalSectionWrapper& crit_sect, - unsigned long max_time_in_ms) OVERRIDE; - virtual void Wake() OVERRIDE; - virtual void WakeAll() OVERRIDE; + void SleepCS(CriticalSectionWrapper& crit_sect) override; + bool SleepCS(CriticalSectionWrapper& crit_sect, + unsigned long max_time_in_ms) override; + void Wake() override; + void WakeAll() override; private: ConditionVariablePosix(); diff --git a/webrtc/system_wrappers/source/critical_section_posix.h b/webrtc/system_wrappers/source/critical_section_posix.h index a5ec36730..d71c93de0 100644 --- a/webrtc/system_wrappers/source/critical_section_posix.h +++ b/webrtc/system_wrappers/source/critical_section_posix.h @@ -21,10 +21,10 @@ class CriticalSectionPosix : public CriticalSectionWrapper { public: CriticalSectionPosix(); - virtual ~CriticalSectionPosix(); + ~CriticalSectionPosix() override; - virtual void Enter() OVERRIDE; - virtual void Leave() OVERRIDE; + void Enter() override; + void Leave() override; private: pthread_mutex_t mutex_; diff --git a/webrtc/system_wrappers/source/event_posix.h b/webrtc/system_wrappers/source/event_posix.h index 6561aa11c..7512c88a1 100644 --- a/webrtc/system_wrappers/source/event_posix.h +++ b/webrtc/system_wrappers/source/event_posix.h @@ -29,13 +29,13 @@ class EventPosix : public EventWrapper { public: static EventWrapper* Create(); - virtual ~EventPosix(); + ~EventPosix() override; - virtual EventTypeWrapper Wait(unsigned long max_time) OVERRIDE; - virtual bool Set() OVERRIDE; + EventTypeWrapper Wait(unsigned long max_time) override; + bool Set() override; - virtual bool StartTimer(bool periodic, unsigned long time) OVERRIDE; - virtual bool StopTimer() OVERRIDE; + bool StartTimer(bool periodic, unsigned long time) override; + bool StopTimer() override; private: EventPosix(); diff --git a/webrtc/system_wrappers/source/file_impl.cc b/webrtc/system_wrappers/source/file_impl.cc index eb199a848..dfb138897 100644 --- a/webrtc/system_wrappers/source/file_impl.cc +++ b/webrtc/system_wrappers/source/file_impl.cc @@ -19,6 +19,7 @@ #include #endif +#include "webrtc/base/checks.h" #include "webrtc/system_wrappers/interface/rw_lock_wrapper.h" namespace webrtc { @@ -269,4 +270,9 @@ int FileWrapperImpl::FlushImpl() { return -1; } +int FileWrapper::Rewind() { + DCHECK(false); + return -1; +} + } // namespace webrtc diff --git a/webrtc/system_wrappers/source/file_impl.h b/webrtc/system_wrappers/source/file_impl.h index 26e9d4d2f..e6679aa8e 100644 --- a/webrtc/system_wrappers/source/file_impl.h +++ b/webrtc/system_wrappers/source/file_impl.h @@ -23,31 +23,30 @@ class RWLockWrapper; class FileWrapperImpl : public FileWrapper { public: FileWrapperImpl(); - virtual ~FileWrapperImpl(); + ~FileWrapperImpl() override; - virtual int FileName(char* file_name_utf8, - size_t size) const OVERRIDE; + int FileName(char* file_name_utf8, size_t size) const override; - virtual bool Open() const OVERRIDE; + bool Open() const override; - virtual int OpenFile(const char* file_name_utf8, - bool read_only, - bool loop = false, - bool text = false) OVERRIDE; + int OpenFile(const char* file_name_utf8, + bool read_only, + bool loop = false, + bool text = false) override; - virtual int OpenFromFileHandle(FILE* handle, - bool manage_file, - bool read_only, - bool loop = false) OVERRIDE; + int OpenFromFileHandle(FILE* handle, + bool manage_file, + bool read_only, + bool loop = false) override; - virtual int CloseFile() OVERRIDE; - virtual int SetMaxFileSize(size_t bytes) OVERRIDE; - virtual int Flush() OVERRIDE; + int CloseFile() override; + int SetMaxFileSize(size_t bytes) override; + int Flush() override; - virtual int Read(void* buf, size_t length) OVERRIDE; - virtual bool Write(const void* buf, size_t length) OVERRIDE; - virtual int WriteText(const char* format, ...) OVERRIDE; - virtual int Rewind() OVERRIDE; + int Read(void* buf, size_t length) override; + bool Write(const void* buf, size_t length) override; + int WriteText(const char* format, ...) override; + int Rewind() override; private: int CloseFileImpl(); diff --git a/webrtc/system_wrappers/source/rw_lock_generic.h b/webrtc/system_wrappers/source/rw_lock_generic.h index dd69f52eb..653564c18 100644 --- a/webrtc/system_wrappers/source/rw_lock_generic.h +++ b/webrtc/system_wrappers/source/rw_lock_generic.h @@ -22,13 +22,13 @@ class ConditionVariableWrapper; class RWLockGeneric : public RWLockWrapper { public: RWLockGeneric(); - virtual ~RWLockGeneric(); + ~RWLockGeneric() override; - virtual void AcquireLockExclusive() OVERRIDE; - virtual void ReleaseLockExclusive() OVERRIDE; + void AcquireLockExclusive() override; + void ReleaseLockExclusive() override; - virtual void AcquireLockShared() OVERRIDE; - virtual void ReleaseLockShared() OVERRIDE; + void AcquireLockShared() override; + void ReleaseLockShared() override; private: CriticalSectionWrapper* critical_section_; diff --git a/webrtc/system_wrappers/source/rw_lock_posix.h b/webrtc/system_wrappers/source/rw_lock_posix.h index 6ce2b2d7e..bec3c2de5 100644 --- a/webrtc/system_wrappers/source/rw_lock_posix.h +++ b/webrtc/system_wrappers/source/rw_lock_posix.h @@ -21,13 +21,13 @@ namespace webrtc { class RWLockPosix : public RWLockWrapper { public: static RWLockPosix* Create(); - virtual ~RWLockPosix(); + ~RWLockPosix() override; - virtual void AcquireLockExclusive() OVERRIDE; - virtual void ReleaseLockExclusive() OVERRIDE; + void AcquireLockExclusive() override; + void ReleaseLockExclusive() override; - virtual void AcquireLockShared() OVERRIDE; - virtual void ReleaseLockShared() OVERRIDE; + void AcquireLockShared() override; + void ReleaseLockShared() override; private: RWLockPosix(); diff --git a/webrtc/system_wrappers/source/scoped_vector_unittest.cc b/webrtc/system_wrappers/source/scoped_vector_unittest.cc index d1f1a9042..9d7c81122 100644 --- a/webrtc/system_wrappers/source/scoped_vector_unittest.cc +++ b/webrtc/system_wrappers/source/scoped_vector_unittest.cc @@ -73,7 +73,7 @@ class LifeCycleWatcher : public LifeCycleObject::Observer { // Assert INITIAL -> CONSTRUCTED and no LifeCycleObject associated with this // LifeCycleWatcher. - virtual void OnLifeCycleConstruct(LifeCycleObject* object) OVERRIDE { + void OnLifeCycleConstruct(LifeCycleObject* object) override { ASSERT_EQ(LC_INITIAL, life_cycle_state_); ASSERT_EQ(NULL, constructed_life_cycle_object_.get()); life_cycle_state_ = LC_CONSTRUCTED; @@ -82,7 +82,7 @@ class LifeCycleWatcher : public LifeCycleObject::Observer { // Assert CONSTRUCTED -> DESTROYED and the |object| being destroyed is the // same one we saw constructed. - virtual void OnLifeCycleDestroy(LifeCycleObject* object) OVERRIDE { + void OnLifeCycleDestroy(LifeCycleObject* object) override { ASSERT_EQ(LC_CONSTRUCTED, life_cycle_state_); LifeCycleObject* constructed_life_cycle_object = constructed_life_cycle_object_.release(); diff --git a/webrtc/system_wrappers/source/trace_posix.h b/webrtc/system_wrappers/source/trace_posix.h index 2f0abc6ed..89420c650 100644 --- a/webrtc/system_wrappers/source/trace_posix.h +++ b/webrtc/system_wrappers/source/trace_posix.h @@ -19,14 +19,13 @@ namespace webrtc { class TracePosix : public TraceImpl { public: TracePosix(); - virtual ~TracePosix(); + ~TracePosix() override; // This method can be called on several different threads different from // the creating thread. - virtual int32_t AddTime(char* trace_message, const TraceLevel level) const - OVERRIDE; + int32_t AddTime(char* trace_message, const TraceLevel level) const override; - virtual int32_t AddDateTimeInfo(char* trace_message) const OVERRIDE; + int32_t AddDateTimeInfo(char* trace_message) const override; private: volatile mutable uint32_t prev_api_tick_count_; diff --git a/webrtc/test/call_test.h b/webrtc/test/call_test.h index 502d613cb..4771dee59 100644 --- a/webrtc/test/call_test.h +++ b/webrtc/test/call_test.h @@ -109,7 +109,7 @@ class SendTest : public BaseTest { explicit SendTest(unsigned int timeout_ms); SendTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config); - virtual bool ShouldCreateReceivers() const OVERRIDE; + bool ShouldCreateReceivers() const override; }; class EndToEndTest : public BaseTest { @@ -117,7 +117,7 @@ class EndToEndTest : public BaseTest { explicit EndToEndTest(unsigned int timeout_ms); EndToEndTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config); - virtual bool ShouldCreateReceivers() const OVERRIDE; + bool ShouldCreateReceivers() const override; }; } // namespace test diff --git a/webrtc/test/channel_transport/include/channel_transport.h b/webrtc/test/channel_transport/include/channel_transport.h index df22012d3..77107d94d 100644 --- a/webrtc/test/channel_transport/include/channel_transport.h +++ b/webrtc/test/channel_transport/include/channel_transport.h @@ -28,15 +28,15 @@ class VoiceChannelTransport : public UdpTransportData { virtual ~VoiceChannelTransport(); // Start implementation of UdpTransportData. - virtual void IncomingRTPPacket(const int8_t* incoming_rtp_packet, - const size_t packet_length, - const char* /*from_ip*/, - const uint16_t /*from_port*/) OVERRIDE; + void IncomingRTPPacket(const int8_t* incoming_rtp_packet, + const size_t packet_length, + const char* /*from_ip*/, + const uint16_t /*from_port*/) override; - virtual void IncomingRTCPPacket(const int8_t* incoming_rtcp_packet, - const size_t packet_length, - const char* /*from_ip*/, - const uint16_t /*from_port*/) OVERRIDE; + void IncomingRTCPPacket(const int8_t* incoming_rtcp_packet, + const size_t packet_length, + const char* /*from_ip*/, + const uint16_t /*from_port*/) override; // End implementation of UdpTransportData. // Specifies the ports to receive RTP packets on. @@ -59,15 +59,15 @@ class VideoChannelTransport : public UdpTransportData { virtual ~VideoChannelTransport(); // Start implementation of UdpTransportData. - virtual void IncomingRTPPacket(const int8_t* incoming_rtp_packet, + void IncomingRTPPacket(const int8_t* incoming_rtp_packet, const size_t packet_length, const char* /*from_ip*/, - const uint16_t /*from_port*/) OVERRIDE; + const uint16_t /*from_port*/) override; - virtual void IncomingRTCPPacket(const int8_t* incoming_rtcp_packet, + void IncomingRTCPPacket(const int8_t* incoming_rtcp_packet, const size_t packet_length, const char* /*from_ip*/, - const uint16_t /*from_port*/) OVERRIDE; + const uint16_t /*from_port*/) override; // End implementation of UdpTransportData. // Specifies the ports to receive RTP packets on. diff --git a/webrtc/test/channel_transport/udp_socket2_win.h b/webrtc/test/channel_transport/udp_socket2_win.h index 697115440..5d6b212b9 100644 --- a/webrtc/test/channel_transport/udp_socket2_win.h +++ b/webrtc/test/channel_transport/udp_socket2_win.h @@ -42,35 +42,41 @@ public: bool ipV6Enable = false, bool disableGQOS = false); virtual ~UdpSocket2Windows(); - virtual bool ValidHandle() OVERRIDE; + bool ValidHandle() override; - virtual bool SetCallback(CallbackObj, IncomingSocketCallback) OVERRIDE; + bool SetCallback(CallbackObj, IncomingSocketCallback) override; - virtual bool Bind(const SocketAddress& name) OVERRIDE; - virtual bool SetSockopt(int32_t level, int32_t optname, - const int8_t* optval, int32_t optlen) OVERRIDE; + bool Bind(const SocketAddress& name) override; + bool SetSockopt(int32_t level, + int32_t optname, + const int8_t* optval, + int32_t optlen) override; - virtual bool StartReceiving(const uint32_t receiveBuffers) OVERRIDE; - virtual inline bool StartReceiving() OVERRIDE {return StartReceiving(8);} - virtual bool StopReceiving() OVERRIDE; + bool StartReceiving(const uint32_t receiveBuffers) override; + inline bool StartReceiving() override { return StartReceiving(8); } + bool StopReceiving() override; - virtual int32_t SendTo(const int8_t* buf, size_t len, - const SocketAddress& to) OVERRIDE; + int32_t SendTo(const int8_t* buf, + size_t len, + const SocketAddress& to) override; - virtual void CloseBlocking() OVERRIDE; + void CloseBlocking() override; SOCKET GetFd() { return _socket;} - virtual bool SetQos(int32_t serviceType, int32_t tokenRate, - int32_t bucketSize, int32_t peekBandwith, - int32_t minPolicedSize, int32_t maxSduSize, - const SocketAddress &stRemName, - int32_t overrideDSCP = 0) OVERRIDE; + bool SetQos(int32_t serviceType, + int32_t tokenRate, + int32_t bucketSize, + int32_t peekBandwith, + int32_t minPolicedSize, + int32_t maxSduSize, + const SocketAddress& stRemName, + int32_t overrideDSCP = 0) override; - virtual int32_t SetTOS(const int32_t serviceType) OVERRIDE; - virtual int32_t SetPCP(const int32_t pcp) OVERRIDE; + int32_t SetTOS(const int32_t serviceType) override; + int32_t SetPCP(const int32_t pcp) override; - virtual uint32_t ReceiveBuffers() OVERRIDE {return _receiveBuffers.Value();} + uint32_t ReceiveBuffers() override { return _receiveBuffers.Value(); } protected: void IOCompleted(PerIoContext* pIOContext, uint32_t ioSize, uint32_t error); diff --git a/webrtc/test/channel_transport/udp_socket_manager_posix.h b/webrtc/test/channel_transport/udp_socket_manager_posix.h index 478d76bc6..f41de2fc8 100644 --- a/webrtc/test/channel_transport/udp_socket_manager_posix.h +++ b/webrtc/test/channel_transport/udp_socket_manager_posix.h @@ -38,13 +38,14 @@ public: UdpSocketManagerPosix(); virtual ~UdpSocketManagerPosix(); - virtual bool Init(int32_t id, uint8_t& numOfWorkThreads) OVERRIDE; + bool Init(int32_t id, uint8_t& numOfWorkThreads) override; - virtual bool Start() OVERRIDE; - virtual bool Stop() OVERRIDE; + bool Start() override; + bool Stop() override; + + bool AddSocket(UdpSocketWrapper* s) override; + bool RemoveSocket(UdpSocketWrapper* s) override; - virtual bool AddSocket(UdpSocketWrapper* s) OVERRIDE; - virtual bool RemoveSocket(UdpSocketWrapper* s) OVERRIDE; private: int32_t _id; CriticalSectionWrapper* _critSect; diff --git a/webrtc/test/channel_transport/udp_socket_posix.h b/webrtc/test/channel_transport/udp_socket_posix.h index 15fdca4d9..6ddf7e540 100644 --- a/webrtc/test/channel_transport/udp_socket_posix.h +++ b/webrtc/test/channel_transport/udp_socket_posix.h @@ -33,35 +33,37 @@ public: virtual ~UdpSocketPosix(); - virtual bool SetCallback(CallbackObj obj, - IncomingSocketCallback cb) OVERRIDE; + bool SetCallback(CallbackObj obj, IncomingSocketCallback cb) override; - virtual bool Bind(const SocketAddress& name) OVERRIDE; + bool Bind(const SocketAddress& name) override; - virtual bool SetSockopt(int32_t level, int32_t optname, - const int8_t* optval, int32_t optlen) OVERRIDE; + bool SetSockopt(int32_t level, + int32_t optname, + const int8_t* optval, + int32_t optlen) override; - virtual int32_t SetTOS(const int32_t serviceType) OVERRIDE; + int32_t SetTOS(const int32_t serviceType) override; - virtual int32_t SendTo(const int8_t* buf, size_t len, - const SocketAddress& to) OVERRIDE; + int32_t SendTo(const int8_t* buf, + size_t len, + const SocketAddress& to) override; // Deletes socket in addition to closing it. // TODO (hellner): make destructor protected. - virtual void CloseBlocking() OVERRIDE; + void CloseBlocking() override; SOCKET GetFd(); - virtual bool ValidHandle() OVERRIDE; + bool ValidHandle() override; - virtual bool SetQos(int32_t /*serviceType*/, - int32_t /*tokenRate*/, - int32_t /*bucketSize*/, - int32_t /*peekBandwith*/, - int32_t /*minPolicedSize*/, - int32_t /*maxSduSize*/, - const SocketAddress& /*stRemName*/, - int32_t /*overrideDSCP*/) OVERRIDE; + bool SetQos(int32_t /*serviceType*/, + int32_t /*tokenRate*/, + int32_t /*bucketSize*/, + int32_t /*peekBandwith*/, + int32_t /*minPolicedSize*/, + int32_t /*maxSduSize*/, + const SocketAddress& /*stRemName*/, + int32_t /*overrideDSCP*/) override; bool CleanUp(); void HasIncoming(); diff --git a/webrtc/test/channel_transport/udp_transport_impl.cc b/webrtc/test/channel_transport/udp_transport_impl.cc index c367b2f0e..ab7a1ff02 100644 --- a/webrtc/test/channel_transport/udp_transport_impl.cc +++ b/webrtc/test/channel_transport/udp_transport_impl.cc @@ -68,12 +68,12 @@ namespace test { class SocketFactory : public UdpTransportImpl::SocketFactoryInterface { public: - virtual UdpSocketWrapper* CreateSocket(const int32_t id, + UdpSocketWrapper* CreateSocket(const int32_t id, UdpSocketManager* mgr, CallbackObj obj, IncomingSocketCallback cb, bool ipV6Enable, - bool disableGQOS) OVERRIDE { + bool disableGQOS) override { return UdpSocketWrapper::CreateSocket(id, mgr, obj, cb, ipV6Enable, disableGQOS); } diff --git a/webrtc/test/channel_transport/udp_transport_impl.h b/webrtc/test/channel_transport/udp_transport_impl.h index 65ad09509..5dbf5d891 100644 --- a/webrtc/test/channel_transport/udp_transport_impl.h +++ b/webrtc/test/channel_transport/udp_transport_impl.h @@ -47,98 +47,89 @@ public: virtual ~UdpTransportImpl(); // UdpTransport functions - virtual int32_t InitializeSendSockets( - const char* ipAddr, - const uint16_t rtpPort, - const uint16_t rtcpPort = 0) OVERRIDE; - virtual int32_t InitializeReceiveSockets( - UdpTransportData* const packetCallback, - const uint16_t rtpPort, - const char* ipAddr = NULL, - const char* multicastIpAddr = NULL, - const uint16_t rtcpPort = 0) OVERRIDE; - virtual int32_t InitializeSourcePorts( - const uint16_t rtpPort, - const uint16_t rtcpPort = 0) OVERRIDE; - virtual int32_t SourcePorts(uint16_t& rtpPort, - uint16_t& rtcpPort) const OVERRIDE; - virtual int32_t ReceiveSocketInformation( + int32_t InitializeSendSockets(const char* ipAddr, + const uint16_t rtpPort, + const uint16_t rtcpPort = 0) override; + int32_t InitializeReceiveSockets(UdpTransportData* const packetCallback, + const uint16_t rtpPort, + const char* ipAddr = NULL, + const char* multicastIpAddr = NULL, + const uint16_t rtcpPort = 0) override; + int32_t InitializeSourcePorts(const uint16_t rtpPort, + const uint16_t rtcpPort = 0) override; + int32_t SourcePorts(uint16_t& rtpPort, uint16_t& rtcpPort) const override; + int32_t ReceiveSocketInformation( char ipAddr[kIpAddressVersion6Length], uint16_t& rtpPort, uint16_t& rtcpPort, - char multicastIpAddr[kIpAddressVersion6Length]) const OVERRIDE; - virtual int32_t SendSocketInformation( - char ipAddr[kIpAddressVersion6Length], - uint16_t& rtpPort, - uint16_t& rtcpPort) const OVERRIDE; - virtual int32_t RemoteSocketInformation( - char ipAddr[kIpAddressVersion6Length], - uint16_t& rtpPort, - uint16_t& rtcpPort) const OVERRIDE; - virtual int32_t SetQoS(const bool QoS, - const int32_t serviceType, - const uint32_t maxBitrate = 0, - const int32_t overrideDSCP = 0, - const bool audio = false) OVERRIDE; - virtual int32_t QoS(bool& QoS, int32_t& serviceType, - int32_t& overrideDSCP) const OVERRIDE; - virtual int32_t SetToS(const int32_t DSCP, - const bool useSetSockOpt = false) OVERRIDE; - virtual int32_t ToS(int32_t& DSCP, bool& useSetSockOpt) const OVERRIDE; - virtual int32_t SetPCP(const int32_t PCP) OVERRIDE; - virtual int32_t PCP(int32_t& PCP) const OVERRIDE; - virtual int32_t EnableIpV6() OVERRIDE; - virtual bool IpV6Enabled() const OVERRIDE; - virtual int32_t SetFilterIP( - const char filterIPAddress[kIpAddressVersion6Length]) OVERRIDE; - virtual int32_t FilterIP( - char filterIPAddress[kIpAddressVersion6Length]) const OVERRIDE; - virtual int32_t SetFilterPorts(const uint16_t rtpFilterPort, - const uint16_t rtcpFilterPort) OVERRIDE; - virtual int32_t FilterPorts(uint16_t& rtpFilterPort, - uint16_t& rtcpFilterPort) const OVERRIDE; - virtual int32_t StartReceiving( - const uint32_t numberOfSocketBuffers) OVERRIDE; - virtual int32_t StopReceiving() OVERRIDE; - virtual bool Receiving() const OVERRIDE; - virtual bool SendSocketsInitialized() const OVERRIDE; - virtual bool SourcePortsInitialized() const OVERRIDE; - virtual bool ReceiveSocketsInitialized() const OVERRIDE; - virtual int32_t SendRaw(const int8_t* data, - size_t length, int32_t isRTCP, - uint16_t portnr = 0, - const char* ip = NULL) OVERRIDE; - virtual int32_t SendRTPPacketTo(const int8_t *data, - size_t length, - const SocketAddress& to) OVERRIDE; - virtual int32_t SendRTCPPacketTo(const int8_t *data, - size_t length, - const SocketAddress& to) OVERRIDE; - virtual int32_t SendRTPPacketTo(const int8_t *data, - size_t length, - uint16_t rtpPort) OVERRIDE; - virtual int32_t SendRTCPPacketTo(const int8_t *data, - size_t length, - uint16_t rtcpPort) OVERRIDE; + char multicastIpAddr[kIpAddressVersion6Length]) const override; + int32_t SendSocketInformation(char ipAddr[kIpAddressVersion6Length], + uint16_t& rtpPort, + uint16_t& rtcpPort) const override; + int32_t RemoteSocketInformation(char ipAddr[kIpAddressVersion6Length], + uint16_t& rtpPort, + uint16_t& rtcpPort) const override; + int32_t SetQoS(const bool QoS, + const int32_t serviceType, + const uint32_t maxBitrate = 0, + const int32_t overrideDSCP = 0, + const bool audio = false) override; + int32_t QoS(bool& QoS, + int32_t& serviceType, + int32_t& overrideDSCP) const override; + int32_t SetToS(const int32_t DSCP, + const bool useSetSockOpt = false) override; + int32_t ToS(int32_t& DSCP, bool& useSetSockOpt) const override; + int32_t SetPCP(const int32_t PCP) override; + int32_t PCP(int32_t& PCP) const override; + int32_t EnableIpV6() override; + bool IpV6Enabled() const override; + int32_t SetFilterIP( + const char filterIPAddress[kIpAddressVersion6Length]) override; + int32_t FilterIP( + char filterIPAddress[kIpAddressVersion6Length]) const override; + int32_t SetFilterPorts(const uint16_t rtpFilterPort, + const uint16_t rtcpFilterPort) override; + int32_t FilterPorts(uint16_t& rtpFilterPort, + uint16_t& rtcpFilterPort) const override; + int32_t StartReceiving(const uint32_t numberOfSocketBuffers) override; + int32_t StopReceiving() override; + bool Receiving() const override; + bool SendSocketsInitialized() const override; + bool SourcePortsInitialized() const override; + bool ReceiveSocketsInitialized() const override; + int32_t SendRaw(const int8_t* data, + size_t length, + int32_t isRTCP, + uint16_t portnr = 0, + const char* ip = NULL) override; + int32_t SendRTPPacketTo(const int8_t* data, + size_t length, + const SocketAddress& to) override; + int32_t SendRTCPPacketTo(const int8_t* data, + size_t length, + const SocketAddress& to) override; + int32_t SendRTPPacketTo(const int8_t* data, + size_t length, + uint16_t rtpPort) override; + int32_t SendRTCPPacketTo(const int8_t* data, + size_t length, + uint16_t rtcpPort) override; // Transport functions - virtual int SendPacket(int channel, - const void* data, - size_t length) OVERRIDE; - virtual int SendRTCPPacket(int channel, - const void* data, - size_t length) OVERRIDE; + int SendPacket(int channel, const void* data, size_t length) override; + int SendRTCPPacket(int channel, const void* data, size_t length) override; // UdpTransport functions continue. - virtual int32_t SetSendIP(const char* ipaddr) OVERRIDE; - virtual int32_t SetSendPorts(const uint16_t rtpPort, - const uint16_t rtcpPort = 0) OVERRIDE; + int32_t SetSendIP(const char* ipaddr) override; + int32_t SetSendPorts(const uint16_t rtpPort, + const uint16_t rtcpPort = 0) override; - virtual ErrorCode LastError() const OVERRIDE; + ErrorCode LastError() const override; - virtual int32_t IPAddressCached(const SocketAddress& address, - char* ip, - uint32_t& ipSize, - uint16_t& sourcePort) OVERRIDE; + int32_t IPAddressCached(const SocketAddress& address, + char* ip, + uint32_t& ipSize, + uint16_t& sourcePort) override; int32_t Id() const {return _id;} protected: diff --git a/webrtc/test/configurable_frame_size_encoder.h b/webrtc/test/configurable_frame_size_encoder.h index 24f6be89b..eed44982f 100644 --- a/webrtc/test/configurable_frame_size_encoder.h +++ b/webrtc/test/configurable_frame_size_encoder.h @@ -24,28 +24,26 @@ class ConfigurableFrameSizeEncoder : public VideoEncoder { explicit ConfigurableFrameSizeEncoder(size_t max_frame_size); virtual ~ConfigurableFrameSizeEncoder(); - virtual int32_t InitEncode(const VideoCodec* codec_settings, - int32_t number_of_cores, - size_t max_payload_size) OVERRIDE; + int32_t InitEncode(const VideoCodec* codec_settings, + int32_t number_of_cores, + size_t max_payload_size) override; - virtual int32_t Encode(const I420VideoFrame& input_image, - const CodecSpecificInfo* codec_specific_info, - const std::vector* frame_types) - OVERRIDE; + int32_t Encode(const I420VideoFrame& input_image, + const CodecSpecificInfo* codec_specific_info, + const std::vector* frame_types) override; - virtual int32_t RegisterEncodeCompleteCallback(EncodedImageCallback* callback) - OVERRIDE; + int32_t RegisterEncodeCompleteCallback( + EncodedImageCallback* callback) override; - virtual int32_t Release() OVERRIDE; + int32_t Release() override; - virtual int32_t SetChannelParameters(uint32_t packet_loss, - int64_t rtt) OVERRIDE; + int32_t SetChannelParameters(uint32_t packet_loss, int64_t rtt) override; - virtual int32_t SetRates(uint32_t new_bit_rate, uint32_t frame_rate) OVERRIDE; + int32_t SetRates(uint32_t new_bit_rate, uint32_t frame_rate) override; - virtual int32_t SetPeriodicKeyFrames(bool enable) OVERRIDE; + int32_t SetPeriodicKeyFrames(bool enable) override; - virtual int32_t CodecConfigParameters(uint8_t* buffer, int32_t size) OVERRIDE; + int32_t CodecConfigParameters(uint8_t* buffer, int32_t size) override; int32_t SetFrameSize(size_t size); diff --git a/webrtc/test/direct_transport.h b/webrtc/test/direct_transport.h index b9fd45446..338be75e5 100644 --- a/webrtc/test/direct_transport.h +++ b/webrtc/test/direct_transport.h @@ -39,8 +39,8 @@ class DirectTransport : public newapi::Transport { virtual void StopSending(); virtual void SetReceiver(PacketReceiver* receiver); - virtual bool SendRtp(const uint8_t* data, size_t length) OVERRIDE; - virtual bool SendRtcp(const uint8_t* data, size_t length) OVERRIDE; + bool SendRtp(const uint8_t* data, size_t length) override; + bool SendRtcp(const uint8_t* data, size_t length) override; private: static bool NetworkProcess(void* transport); diff --git a/webrtc/test/fake_audio_device.h b/webrtc/test/fake_audio_device.h index ce5231e08..6df53e98b 100644 --- a/webrtc/test/fake_audio_device.h +++ b/webrtc/test/fake_audio_device.h @@ -33,12 +33,12 @@ class FakeAudioDevice : public FakeAudioDeviceModule { virtual ~FakeAudioDevice(); - virtual int32_t Init() OVERRIDE; - virtual int32_t RegisterAudioCallback(AudioTransport* callback) OVERRIDE; + int32_t Init() override; + int32_t RegisterAudioCallback(AudioTransport* callback) override; - virtual bool Playing() const OVERRIDE; - virtual int32_t PlayoutDelay(uint16_t* delay_ms) const OVERRIDE; - virtual bool Recording() const OVERRIDE; + bool Playing() const override; + int32_t PlayoutDelay(uint16_t* delay_ms) const override; + bool Recording() const override; void Start(); void Stop(); diff --git a/webrtc/test/fake_common.h b/webrtc/test/fake_common.h index a07480856..ec8179876 100644 --- a/webrtc/test/fake_common.h +++ b/webrtc/test/fake_common.h @@ -16,28 +16,24 @@ #include "webrtc/typedefs.h" #define WEBRTC_STUB(method, args) \ - virtual int method args OVERRIDE { return 0; } + int method args override { return 0; } #define WEBRTC_STUB_CONST(method, args) \ - virtual int method args const OVERRIDE { return 0; } + int method args const override { return 0; } #define WEBRTC_BOOL_STUB(method, args) \ - virtual bool method args OVERRIDE { return true; } + bool method args override { return true; } #define WEBRTC_VOID_STUB(method, args) \ - virtual void method args OVERRIDE {} + void method args override {} -#define WEBRTC_FUNC(method, args) \ - virtual int method args OVERRIDE +#define WEBRTC_FUNC(method, args) int method args override -#define WEBRTC_FUNC_CONST(method, args) \ - virtual int method args const OVERRIDE +#define WEBRTC_FUNC_CONST(method, args) int method args const override -#define WEBRTC_BOOL_FUNC(method, args) \ - virtual bool method args OVERRIDE +#define WEBRTC_BOOL_FUNC(method, args) bool method args override -#define WEBRTC_VOID_FUNC(method, args) \ - virtual void method args OVERRIDE +#define WEBRTC_VOID_FUNC(method, args) void method args override #define WEBRTC_CHECK_CHANNEL(channel) \ if (channels_.find(channel) == channels_.end()) return -1; diff --git a/webrtc/test/fake_encoder.h b/webrtc/test/fake_encoder.h index 2cb28cac8..096b9c22e 100644 --- a/webrtc/test/fake_encoder.h +++ b/webrtc/test/fake_encoder.h @@ -28,20 +28,17 @@ class FakeEncoder : public VideoEncoder { // Sets max bitrate. Not thread-safe, call before registering the encoder. void SetMaxBitrate(int max_kbps); - virtual int32_t InitEncode(const VideoCodec* config, - int32_t number_of_cores, - size_t max_payload_size) OVERRIDE; - virtual int32_t Encode( - const I420VideoFrame& input_image, - const CodecSpecificInfo* codec_specific_info, - const std::vector* frame_types) OVERRIDE; - virtual int32_t RegisterEncodeCompleteCallback( - EncodedImageCallback* callback) OVERRIDE; - virtual int32_t Release() OVERRIDE; - virtual int32_t SetChannelParameters(uint32_t packet_loss, - int64_t rtt) OVERRIDE; - virtual int32_t SetRates(uint32_t new_target_bitrate, - uint32_t framerate) OVERRIDE; + int32_t InitEncode(const VideoCodec* config, + int32_t number_of_cores, + size_t max_payload_size) override; + int32_t Encode(const I420VideoFrame& input_image, + const CodecSpecificInfo* codec_specific_info, + const std::vector* frame_types) override; + int32_t RegisterEncodeCompleteCallback( + EncodedImageCallback* callback) override; + int32_t Release() override; + int32_t SetChannelParameters(uint32_t packet_loss, int64_t rtt) override; + int32_t SetRates(uint32_t new_target_bitrate, uint32_t framerate) override; protected: Clock* const clock_; @@ -58,13 +55,12 @@ class FakeH264Encoder : public FakeEncoder, public EncodedImageCallback { explicit FakeH264Encoder(Clock* clock); virtual ~FakeH264Encoder() {} - virtual int32_t RegisterEncodeCompleteCallback( - EncodedImageCallback* callback) OVERRIDE; + int32_t RegisterEncodeCompleteCallback( + EncodedImageCallback* callback) override; - virtual int32_t Encoded( - const EncodedImage& encodedImage, - const CodecSpecificInfo* codecSpecificInfo, - const RTPFragmentationHeader* fragments) OVERRIDE; + int32_t Encoded(const EncodedImage& encodedImage, + const CodecSpecificInfo* codecSpecificInfo, + const RTPFragmentationHeader* fragments) override; private: EncodedImageCallback* callback_; @@ -76,10 +72,9 @@ class DelayedEncoder : public test::FakeEncoder { DelayedEncoder(Clock* clock, int delay_ms); virtual ~DelayedEncoder() {} - virtual int32_t Encode( - const I420VideoFrame& input_image, - const CodecSpecificInfo* codec_specific_info, - const std::vector* frame_types) OVERRIDE; + int32_t Encode(const I420VideoFrame& input_image, + const CodecSpecificInfo* codec_specific_info, + const std::vector* frame_types) override; private: const int delay_ms_; diff --git a/webrtc/test/frame_generator.cc b/webrtc/test/frame_generator.cc index fe6b1b1a0..71be89e62 100644 --- a/webrtc/test/frame_generator.cc +++ b/webrtc/test/frame_generator.cc @@ -28,7 +28,7 @@ class ChromaGenerator : public FrameGenerator { assert(height > 0); } - virtual I420VideoFrame* NextFrame() OVERRIDE { + I420VideoFrame* NextFrame() override { frame_.CreateEmptyFrame(static_cast(width_), static_cast(height_), static_cast(width_), @@ -77,7 +77,7 @@ class YuvFileGenerator : public FrameGenerator { fclose(file); } - virtual I420VideoFrame* NextFrame() OVERRIDE { + I420VideoFrame* NextFrame() override { if (current_display_count_ == 0) ReadNextFrame(); if (++current_display_count_ >= frame_display_count_) diff --git a/webrtc/test/frame_generator_capturer.h b/webrtc/test/frame_generator_capturer.h index 69b9f5f26..1064a5f3d 100644 --- a/webrtc/test/frame_generator_capturer.h +++ b/webrtc/test/frame_generator_capturer.h @@ -42,8 +42,8 @@ class FrameGeneratorCapturer : public VideoCapturer { Clock* clock); virtual ~FrameGeneratorCapturer(); - virtual void Start() OVERRIDE; - virtual void Stop() OVERRIDE; + void Start() override; + void Stop() override; int64_t first_frame_capture_time() const { return first_frame_capture_time_; } diff --git a/webrtc/test/gl/gl_renderer.h b/webrtc/test/gl/gl_renderer.h index c2110b2e7..b712f2569 100644 --- a/webrtc/test/gl/gl_renderer.h +++ b/webrtc/test/gl/gl_renderer.h @@ -26,8 +26,8 @@ namespace test { class GlRenderer : public VideoRenderer { public: - virtual void RenderFrame(const webrtc::I420VideoFrame& frame, - int time_to_render_ms) OVERRIDE; + void RenderFrame(const webrtc::I420VideoFrame& frame, + int time_to_render_ms) override; protected: GlRenderer(); diff --git a/webrtc/test/linux/glx_renderer.h b/webrtc/test/linux/glx_renderer.h index 8def121fe..6d9e4e6dd 100644 --- a/webrtc/test/linux/glx_renderer.h +++ b/webrtc/test/linux/glx_renderer.h @@ -26,9 +26,8 @@ class GlxRenderer : public GlRenderer { size_t height); virtual ~GlxRenderer(); - virtual void RenderFrame(const webrtc::I420VideoFrame& frame, - int delta) override; - virtual bool IsTextureSupported() const override { return false; } + void RenderFrame(const webrtc::I420VideoFrame& frame, int delta) override; + bool IsTextureSupported() const override { return false; } private: GlxRenderer(size_t width, size_t height); diff --git a/webrtc/test/mac/video_renderer_mac.h b/webrtc/test/mac/video_renderer_mac.h index 330fd0412..6237709f9 100644 --- a/webrtc/test/mac/video_renderer_mac.h +++ b/webrtc/test/mac/video_renderer_mac.h @@ -27,8 +27,8 @@ class MacRenderer : public GlRenderer { bool Init(const char* window_title, int width, int height); // Implements GlRenderer. - virtual void RenderFrame(const I420VideoFrame& frame, int delta) override; - virtual bool IsTextureSupported() const override { return false; } + void RenderFrame(const I420VideoFrame& frame, int delta) override; + bool IsTextureSupported() const override { return false; } private: CocoaWindow* window_; diff --git a/webrtc/test/null_transport.h b/webrtc/test/null_transport.h index e8d4d1027..b80f751b1 100644 --- a/webrtc/test/null_transport.h +++ b/webrtc/test/null_transport.h @@ -19,8 +19,8 @@ class PacketReceiver; namespace test { class NullTransport : public newapi::Transport { public: - virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE; - virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE; + bool SendRtp(const uint8_t* packet, size_t length) override; + bool SendRtcp(const uint8_t* packet, size_t length) override; }; } // namespace test } // namespace webrtc diff --git a/webrtc/test/rtp_file_reader.cc b/webrtc/test/rtp_file_reader.cc index 34290ac8d..26151bba1 100644 --- a/webrtc/test/rtp_file_reader.cc +++ b/webrtc/test/rtp_file_reader.cc @@ -168,7 +168,7 @@ class RtpDumpReader : public RtpFileReaderImpl { return true; } - virtual bool NextPacket(RtpPacket* packet) OVERRIDE { + bool NextPacket(RtpPacket* packet) override { uint8_t* rtp_data = packet->data; packet->length = RtpPacket::kMaxPacketBufferSize; @@ -265,7 +265,7 @@ class PcapReader : public RtpFileReaderImpl { } } - bool Init(const std::string& filename) OVERRIDE { + bool Init(const std::string& filename) override { return Initialize(filename) == kResultSuccess; } @@ -334,7 +334,7 @@ class PcapReader : public RtpFileReaderImpl { return kResultSuccess; } - virtual bool NextPacket(RtpPacket* packet) OVERRIDE { + bool NextPacket(RtpPacket* packet) override { uint32_t length = RtpPacket::kMaxPacketBufferSize; if (NextPcap(packet->data, &length, &packet->time_ms) != kResultSuccess) return false; diff --git a/webrtc/test/rtp_file_writer.cc b/webrtc/test/rtp_file_writer.cc index 1b9bfdc2a..4acaa2781 100644 --- a/webrtc/test/rtp_file_writer.cc +++ b/webrtc/test/rtp_file_writer.cc @@ -38,7 +38,7 @@ class RtpDumpWriter : public RtpFileWriter { } } - virtual bool WritePacket(const RtpPacket* packet) OVERRIDE { + bool WritePacket(const RtpPacket* packet) override { uint16_t len = static_cast(packet->length + kPacketHeaderSize); CHECK_GE(packet->original_length, packet->length); uint16_t plen = static_cast(packet->original_length); diff --git a/webrtc/test/rtp_rtcp_observer.h b/webrtc/test/rtp_rtcp_observer.h index 37451f455..dd731f04d 100644 --- a/webrtc/test/rtp_rtcp_observer.h +++ b/webrtc/test/rtp_rtcp_observer.h @@ -127,7 +127,7 @@ class RtpRtcpObserver { on_rtcp_(on_rtcp) {} private: - virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE { + bool SendRtp(const uint8_t* packet, size_t length) override { EXPECT_FALSE(RtpHeaderParser::IsRtcp(packet, length)); Action action; { @@ -144,7 +144,7 @@ class RtpRtcpObserver { return true; // Will never happen, makes compiler happy. } - virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE { + bool SendRtcp(const uint8_t* packet, size_t length) override { EXPECT_TRUE(RtpHeaderParser::IsRtcp(packet, length)); Action action; { diff --git a/webrtc/test/testsupport/frame_reader.h b/webrtc/test/testsupport/frame_reader.h index 4ee90f90b..9b50ec7bf 100644 --- a/webrtc/test/testsupport/frame_reader.h +++ b/webrtc/test/testsupport/frame_reader.h @@ -54,12 +54,12 @@ class FrameReaderImpl : public FrameReader { // frame_length_in_bytes The size of each frame. // For YUV this is 3 * width * height / 2 FrameReaderImpl(std::string input_filename, size_t frame_length_in_bytes); - virtual ~FrameReaderImpl(); - virtual bool Init() OVERRIDE; - virtual bool ReadFrame(uint8_t* source_buffer) OVERRIDE; - virtual void Close() OVERRIDE; - virtual size_t FrameLength() OVERRIDE; - virtual int NumberOfFrames() OVERRIDE; + ~FrameReaderImpl() override; + bool Init() override; + bool ReadFrame(uint8_t* source_buffer) override; + void Close() override; + size_t FrameLength() override; + int NumberOfFrames() override; private: std::string input_filename_; diff --git a/webrtc/test/testsupport/frame_writer.h b/webrtc/test/testsupport/frame_writer.h index daa3894a5..8a6b1c215 100644 --- a/webrtc/test/testsupport/frame_writer.h +++ b/webrtc/test/testsupport/frame_writer.h @@ -52,11 +52,11 @@ class FrameWriterImpl : public FrameWriter { // frame_length_in_bytes The size of each frame. // For YUV: 3*width*height/2 FrameWriterImpl(std::string output_filename, size_t frame_length_in_bytes); - virtual ~FrameWriterImpl(); - virtual bool Init() OVERRIDE; - virtual bool WriteFrame(uint8_t* frame_buffer) OVERRIDE; - virtual void Close() OVERRIDE; - virtual size_t FrameLength() OVERRIDE; + ~FrameWriterImpl() override; + bool Init() override; + bool WriteFrame(uint8_t* frame_buffer) override; + void Close() override; + size_t FrameLength() override; private: std::string output_filename_; diff --git a/webrtc/test/testsupport/trace_to_stderr.h b/webrtc/test/testsupport/trace_to_stderr.h index 12208349d..88f181174 100644 --- a/webrtc/test/testsupport/trace_to_stderr.h +++ b/webrtc/test/testsupport/trace_to_stderr.h @@ -28,7 +28,7 @@ class TraceToStderr : public TraceCallback { // This is useful for offline test tools, where the file time is much more // informative than the real time. explicit TraceToStderr(bool override_time); - virtual ~TraceToStderr(); + ~TraceToStderr() override; // Every subsequent trace printout will use |time|. Has no effect if // |override_time| in the constructor was set to false. @@ -39,9 +39,7 @@ class TraceToStderr : public TraceCallback { virtual void SetTimeSeconds(float time); // Implements TraceCallback. - virtual void Print(TraceLevel level, - const char* msg_array, - int length) OVERRIDE; + void Print(TraceLevel level, const char* msg_array, int length) override; private: bool override_time_; diff --git a/webrtc/test/vcm_capturer.h b/webrtc/test/vcm_capturer.h index dde3edc2f..1cb5b4e00 100644 --- a/webrtc/test/vcm_capturer.h +++ b/webrtc/test/vcm_capturer.h @@ -24,13 +24,12 @@ class VcmCapturer : public VideoCapturer, public VideoCaptureDataCallback { size_t height, size_t target_fps); virtual ~VcmCapturer(); - virtual void Start() OVERRIDE; - virtual void Stop() OVERRIDE; + void Start() override; + void Stop() override; - virtual void OnIncomingCapturedFrame( - const int32_t id, I420VideoFrame& frame) OVERRIDE; // NOLINT - virtual void OnCaptureDelayChanged(const int32_t id, const int32_t delay) - OVERRIDE; + void OnIncomingCapturedFrame(const int32_t id, + I420VideoFrame& frame) override; // NOLINT + void OnCaptureDelayChanged(const int32_t id, const int32_t delay) override; private: explicit VcmCapturer(VideoSendStreamInput* input); diff --git a/webrtc/test/video_renderer.cc b/webrtc/test/video_renderer.cc index 447b5b76d..03c494891 100644 --- a/webrtc/test/video_renderer.cc +++ b/webrtc/test/video_renderer.cc @@ -17,9 +17,9 @@ namespace webrtc { namespace test { class NullRenderer : public VideoRenderer { - virtual void RenderFrame(const I420VideoFrame& video_frame, - int time_to_render_ms) override {} - virtual bool IsTextureSupported() const override { return false; } + void RenderFrame(const I420VideoFrame& video_frame, + int time_to_render_ms) override {} + bool IsTextureSupported() const override { return false; } }; VideoRenderer* VideoRenderer::Create(const char* window_title, diff --git a/webrtc/test/win/d3d_renderer.h b/webrtc/test/win/d3d_renderer.h index 7cf498207..4fa6c7ef4 100644 --- a/webrtc/test/win/d3d_renderer.h +++ b/webrtc/test/win/d3d_renderer.h @@ -27,9 +27,8 @@ class D3dRenderer : public VideoRenderer { size_t height); virtual ~D3dRenderer(); - virtual void RenderFrame(const webrtc::I420VideoFrame& frame, - int delta) override; - virtual bool IsTextureSupported() const override { return false; } + void RenderFrame(const webrtc::I420VideoFrame& frame, int delta) override; + bool IsTextureSupported() const override { return false; } private: D3dRenderer(size_t width, size_t height); diff --git a/webrtc/tools/simple_command_line_parser_unittest.cc b/webrtc/tools/simple_command_line_parser_unittest.cc index f016b17d9..48640df17 100644 --- a/webrtc/tools/simple_command_line_parser_unittest.cc +++ b/webrtc/tools/simple_command_line_parser_unittest.cc @@ -16,7 +16,7 @@ namespace test { class CommandLineParserTest : public ::testing::Test { protected: - virtual void SetUp() { + void SetUp() override { parser_ = new CommandLineParser(); test_flags_length_ = 3; @@ -29,7 +29,7 @@ class CommandLineParserTest : public ::testing::Test { strncpy(test_flags_[1], "--foo", flag_size); strncpy(test_flags_[2], "--bar=1", flag_size); } - virtual void TearDown() { + void TearDown() override { for (int i = 0; i < test_flags_length_; ++i) { delete[] test_flags_[i]; } diff --git a/webrtc/typedefs.h b/webrtc/typedefs.h index 51d89927f..8bcaa88f0 100644 --- a/webrtc/typedefs.h +++ b/webrtc/typedefs.h @@ -74,28 +74,6 @@ typedef unsigned int uint32_t; typedef unsigned __int64 uint64_t; #endif -// Borrowed from Chromium's base/compiler_specific.h. -// Annotate a virtual method indicating it must be overriding a virtual -// method in the parent class. -// Use like: -// virtual void foo() OVERRIDE; -#if defined(_MSC_VER) -#define OVERRIDE override -#elif defined(__clang__) -// Clang defaults to C++03 and warns about using override. Squelch that. -// Intentionally no push/pop here so all users of OVERRIDE ignore the warning -// too. This is like passing -Wno-c++11-extensions, except that GCC won't die -// (because it won't see this pragma). -#pragma clang diagnostic ignored "-Wc++11-extensions" -#define OVERRIDE override -#elif defined(__GNUC__) && __cplusplus >= 201103 && \ - (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40700 -// GCC 4.7 supports explicit virtual overrides when C++11 support is enabled. -#define OVERRIDE override -#else -#define OVERRIDE -#endif - // Annotate a function indicating the caller must examine the return value. // Use like: // int foo() WARN_UNUSED_RESULT; diff --git a/webrtc/video/bitrate_estimator_tests.cc b/webrtc/video/bitrate_estimator_tests.cc index 872ee4a0f..bf0f1af5d 100644 --- a/webrtc/video/bitrate_estimator_tests.cc +++ b/webrtc/video/bitrate_estimator_tests.cc @@ -67,9 +67,7 @@ class TraceObserver { : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()), done_(EventWrapper::Create()) {} - virtual void Print(TraceLevel level, - const char* message, - int length) OVERRIDE { + void Print(TraceLevel level, const char* message, int length) override { CriticalSectionScoped lock(crit_sect_.get()); std::string msg(message); if (msg.find("BitrateEstimator") != std::string::npos) { diff --git a/webrtc/video/call.cc b/webrtc/video/call.cc index 984f52910..bf80ee5b9 100644 --- a/webrtc/video/call.cc +++ b/webrtc/video/call.cc @@ -83,12 +83,12 @@ class CpuOveruseObserverProxy : public webrtc::CpuOveruseObserver { virtual ~CpuOveruseObserverProxy() {} - virtual void OveruseDetected() OVERRIDE { + void OveruseDetected() override { CriticalSectionScoped lock(crit_.get()); overuse_callback_->OnLoadUpdate(LoadObserver::kOveruse); } - virtual void NormalUsage() OVERRIDE { + void NormalUsage() override { CriticalSectionScoped lock(crit_.get()); overuse_callback_->OnLoadUpdate(LoadObserver::kUnderuse); } @@ -103,29 +103,27 @@ class Call : public webrtc::Call, public PacketReceiver { Call(webrtc::VideoEngine* video_engine, const Call::Config& config); virtual ~Call(); - virtual PacketReceiver* Receiver() OVERRIDE; + PacketReceiver* Receiver() override; - virtual VideoSendStream* CreateVideoSendStream( + VideoSendStream* CreateVideoSendStream( const VideoSendStream::Config& config, - const VideoEncoderConfig& encoder_config) OVERRIDE; + const VideoEncoderConfig& encoder_config) override; - virtual void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) - OVERRIDE; + void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override; - virtual VideoReceiveStream* CreateVideoReceiveStream( - const VideoReceiveStream::Config& config) OVERRIDE; + VideoReceiveStream* CreateVideoReceiveStream( + const VideoReceiveStream::Config& config) override; - virtual void DestroyVideoReceiveStream( - webrtc::VideoReceiveStream* receive_stream) OVERRIDE; + void DestroyVideoReceiveStream( + webrtc::VideoReceiveStream* receive_stream) override; - virtual Stats GetStats() const OVERRIDE; + Stats GetStats() const override; - virtual DeliveryStatus DeliverPacket(const uint8_t* packet, - size_t length) OVERRIDE; + DeliveryStatus DeliverPacket(const uint8_t* packet, size_t length) override; - virtual void SetBitrateConfig( - const webrtc::Call::Config::BitrateConfig& bitrate_config) OVERRIDE; - virtual void SignalNetworkState(NetworkState state) OVERRIDE; + void SetBitrateConfig( + const webrtc::Call::Config::BitrateConfig& bitrate_config) override; + void SignalNetworkState(NetworkState state) override; private: DeliveryStatus DeliverRtcp(const uint8_t* packet, size_t length); diff --git a/webrtc/video/call_perf_tests.cc b/webrtc/video/call_perf_tests.cc index 9edd55dbd..9f3dbf241 100644 --- a/webrtc/video/call_perf_tests.cc +++ b/webrtc/video/call_perf_tests.cc @@ -63,7 +63,7 @@ class SyncRtcpObserver : public test::RtpRtcpObserver { : test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs, config), crit_(CriticalSectionWrapper::CreateCriticalSection()) {} - virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtcp(const uint8_t* packet, size_t length) override { RTCPUtility::RTCPParserV2 parser(packet, length, true); EXPECT_TRUE(parser.IsValid()); @@ -137,8 +137,8 @@ class VideoRtcpAndSyncObserver : public SyncRtcpObserver, public VideoRenderer { creation_time_ms_(clock_->TimeInMilliseconds()), first_time_in_sync_(-1) {} - virtual void RenderFrame(const I420VideoFrame& video_frame, - int time_to_render_ms) OVERRIDE { + void RenderFrame(const I420VideoFrame& video_frame, + int time_to_render_ms) override { int64_t now_ms = clock_->TimeInMilliseconds(); uint32_t playout_timestamp = 0; if (voe_sync_->GetPlayoutTimestamp(voe_channel_, playout_timestamp) != 0) @@ -180,7 +180,7 @@ class VideoRtcpAndSyncObserver : public SyncRtcpObserver, public VideoRenderer { } } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } private: Clock* const clock_; @@ -198,8 +198,8 @@ void CallPerfTest::TestAudioVideoSync(bool fec) { : channel_(channel), voe_network_(voe_network), parser_(RtpHeaderParser::Create()) {} - virtual DeliveryStatus DeliverPacket(const uint8_t* packet, - size_t length) OVERRIDE { + DeliveryStatus DeliverPacket(const uint8_t* packet, + size_t length) override { int ret; if (parser_->IsRtcp(packet, length)) { ret = voe_network_->ReceivedRTCPPacket(channel_, packet, length); @@ -335,8 +335,8 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config, rtp_start_timestamp_(0) {} private: - virtual void RenderFrame(const I420VideoFrame& video_frame, - int time_to_render_ms) OVERRIDE { + void RenderFrame(const I420VideoFrame& video_frame, + int time_to_render_ms) override { if (video_frame.ntp_time_ms() <= 0) { // Haven't got enough RTCP SR in order to calculate the capture ntp // time. @@ -374,7 +374,7 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config, EXPECT_TRUE(std::abs(time_offset_ms) < threshold_ms_); } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } virtual Action OnSendRtp(const uint8_t* packet, size_t length) { RTPHeader header; @@ -396,21 +396,20 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config, return SEND_PACKET; } - virtual void OnFrameGeneratorCapturerCreated( - test::FrameGeneratorCapturer* frame_generator_capturer) OVERRIDE { + void OnFrameGeneratorCapturerCreated( + test::FrameGeneratorCapturer* frame_generator_capturer) override { capturer_ = frame_generator_capturer; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { (*receive_configs)[0].renderer = this; // Enable the receiver side rtt calculation. (*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report = true; } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for " "estimated capture NTP time to be " "within bounds."; @@ -463,25 +462,24 @@ void CallPerfTest::TestCpuOveruse(LoadObserver::Load tested_load, tested_load_(tested_load), encoder_(Clock::GetRealTimeClock(), encode_delay_ms) {} - virtual void OnLoadUpdate(Load load) OVERRIDE { + void OnLoadUpdate(Load load) override { if (load == tested_load_) observation_complete_->Set(); } - virtual Call::Config GetSenderCallConfig() OVERRIDE { + Call::Config GetSenderCallConfig() override { Call::Config config(SendTransport()); config.overuse_callback = this; return config; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = &encoder_; } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out before receiving an overuse callback."; } @@ -519,15 +517,14 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) { num_bitrate_observations_in_range_(0) {} private: - virtual void SetReceivers(PacketReceiver* send_transport_receiver, - PacketReceiver* receive_transport_receiver) - OVERRIDE { + void SetReceivers(PacketReceiver* send_transport_receiver, + PacketReceiver* receive_transport_receiver) override { send_transport_receiver_ = send_transport_receiver; test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver); } - virtual DeliveryStatus DeliverPacket(const uint8_t* packet, - size_t length) OVERRIDE { + DeliveryStatus DeliverPacket(const uint8_t* packet, + size_t length) override { VideoSendStream::Stats stats = send_stream_->GetStats(); if (stats.substreams.size() > 0) { assert(stats.substreams.size() == 1); @@ -562,16 +559,15 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) { return send_transport_receiver_->DeliverPacket(packet, length); } - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, - const std::vector& receive_streams) OVERRIDE { + const std::vector& receive_streams) override { send_stream_ = send_stream; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { if (pad_to_min_bitrate_) { encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps; } else { @@ -579,7 +575,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) { } } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timeout while waiting for send-bitrate stats."; } @@ -613,9 +609,9 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) { time_to_reconfigure_(webrtc::EventWrapper::Create()), encoder_inits_(0) {} - virtual int32_t InitEncode(const VideoCodec* config, - int32_t number_of_cores, - size_t max_payload_size) OVERRIDE { + int32_t InitEncode(const VideoCodec* config, + int32_t number_of_cores, + size_t max_payload_size) override { if (encoder_inits_ == 0) { EXPECT_EQ(kInitialBitrateKbps, config->startBitrate) << "Encoder not initialized at expected bitrate."; @@ -632,8 +628,8 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) { return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); } - virtual int32_t SetRates(uint32_t new_target_bitrate_kbps, - uint32_t framerate) OVERRIDE { + int32_t SetRates(uint32_t new_target_bitrate_kbps, + uint32_t framerate) override { last_set_bitrate_ = new_target_bitrate_kbps; if (encoder_inits_ == 1 && new_target_bitrate_kbps > kReconfigureThresholdKbps) { @@ -642,16 +638,15 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) { return FakeEncoder::SetRates(new_target_bitrate_kbps, framerate); } - Call::Config GetSenderCallConfig() OVERRIDE { + Call::Config GetSenderCallConfig() override { Call::Config config = EndToEndTest::GetSenderCallConfig(); config.stream_bitrates.start_bitrate_bps = kInitialBitrateKbps * 1000; return config; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = this; encoder_config->streams[0].min_bitrate_bps = 50000; encoder_config->streams[0].target_bitrate_bps = @@ -660,13 +655,13 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) { encoder_config_ = *encoder_config; } - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, - const std::vector& receive_streams) OVERRIDE { + const std::vector& receive_streams) override { send_stream_ = send_stream; } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { ASSERT_EQ(kEventSignaled, time_to_reconfigure_->Wait(kDefaultTimeoutMs)) << "Timed out before receiving an initial high bitrate."; encoder_config_.streams[0].width *= 2; diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc index c054645f5..a8f6f0962 100644 --- a/webrtc/video/end_to_end_tests.cc +++ b/webrtc/video/end_to_end_tests.cc @@ -59,12 +59,12 @@ class EndToEndTest : public test::CallTest { protected: class UnusedTransport : public newapi::Transport { private: - virtual bool SendRtp(const uint8_t* packet, size_t length) override { + bool SendRtp(const uint8_t* packet, size_t length) override { ADD_FAILURE() << "Unexpected RTP sent."; return false; } - virtual bool SendRtcp(const uint8_t* packet, size_t length) override { + bool SendRtcp(const uint8_t* packet, size_t length) override { ADD_FAILURE() << "Unexpected RTCP sent."; return false; } @@ -121,12 +121,12 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) { public: Renderer() : event_(EventWrapper::Create()) {} - virtual void RenderFrame(const I420VideoFrame& video_frame, - int /*time_to_render_ms*/) override { + void RenderFrame(const I420VideoFrame& video_frame, + int /*time_to_render_ms*/) override { event_->Set(); } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); } @@ -140,7 +140,7 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) { EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); } private: - virtual void FrameCallback(I420VideoFrame* frame) override { + void FrameCallback(I420VideoFrame* frame) override { SleepMs(kDelayRenderCallbackMs); event_->Set(); } @@ -189,11 +189,11 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) { public: Renderer() : event_(EventWrapper::Create()) {} - virtual void RenderFrame(const I420VideoFrame& video_frame, - int /*time_to_render_ms*/) override { + void RenderFrame(const I420VideoFrame& video_frame, + int /*time_to_render_ms*/) override { event_->Set(); } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); } @@ -240,15 +240,14 @@ TEST_F(EndToEndTest, SendsAndReceivesVP9) { decoder_(VP9Decoder::Create()), frame_counter_(0) {} - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for enough frames to be decoded."; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = encoder_.get(); send_config->encoder_settings.payload_name = "VP9"; send_config->encoder_settings.payload_type = VCM_VP9_PAYLOAD_TYPE; @@ -265,14 +264,14 @@ TEST_F(EndToEndTest, SendsAndReceivesVP9) { (*receive_configs)[0].decoders[0].decoder = decoder_.get(); } - virtual void RenderFrame(const I420VideoFrame& video_frame, - int time_to_render_ms) override { + void RenderFrame(const I420VideoFrame& video_frame, + int time_to_render_ms) override { const int kRequiredFrames = 500; if (++frame_counter_ == kRequiredFrames) observation_complete_->Set(); } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } private: rtc::scoped_ptr encoder_; @@ -291,15 +290,14 @@ TEST_F(EndToEndTest, SendsAndReceivesH264) { fake_encoder_(Clock::GetRealTimeClock()), frame_counter_(0) {} - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for enough frames to be decoded."; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->rtp.nack.rtp_history_ms = (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; send_config->encoder_settings.encoder = &fake_encoder_; @@ -318,14 +316,14 @@ TEST_F(EndToEndTest, SendsAndReceivesH264) { (*receive_configs)[0].decoders[0].decoder = &fake_decoder_; } - virtual void RenderFrame(const I420VideoFrame& video_frame, - int time_to_render_ms) override { + void RenderFrame(const I420VideoFrame& video_frame, + int time_to_render_ms) override { const int kRequiredFrames = 500; if (++frame_counter_ == kRequiredFrames) observation_complete_->Set(); } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } private: test::FakeH264Decoder fake_decoder_; @@ -341,8 +339,7 @@ TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) { public: SyncRtcpObserver() : EndToEndTest(kDefaultTimeoutMs) {} - virtual Action OnReceiveRtcp(const uint8_t* packet, - size_t length) override { + Action OnReceiveRtcp(const uint8_t* packet, size_t length) override { RTCPUtility::RTCPParserV2 parser(packet, length, true); EXPECT_TRUE(parser.IsValid()); uint32_t ssrc = 0; @@ -356,7 +353,7 @@ TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) { return SEND_PACKET; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for a receiver RTCP packet to be sent."; } @@ -379,7 +376,7 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) { nacks_left_(kNumberOfNacksToObserve) {} private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header)); @@ -413,8 +410,7 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) { return SEND_PACKET; } - virtual Action OnReceiveRtcp(const uint8_t* packet, - size_t length) override { + Action OnReceiveRtcp(const uint8_t* packet, size_t length) override { RTCPUtility::RTCPParserV2 parser(packet, length, true); EXPECT_TRUE(parser.IsValid()); @@ -429,15 +425,14 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) { return SEND_PACKET; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out waiting for packets to be NACKed, retransmitted and " "rendered."; @@ -461,7 +456,7 @@ TEST_F(EndToEndTest, CanReceiveFec) { : EndToEndTest(kDefaultTimeoutMs), state_(kFirstPacket) {} private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override + Action OnSendRtp(const uint8_t* packet, size_t length) override EXCLUSIVE_LOCKS_REQUIRED(crit_) { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); @@ -505,8 +500,8 @@ TEST_F(EndToEndTest, CanReceiveFec) { return SEND_PACKET; } - virtual void RenderFrame(const I420VideoFrame& video_frame, - int time_to_render_ms) override { + void RenderFrame(const I420VideoFrame& video_frame, + int time_to_render_ms) override { CriticalSectionScoped lock(crit_.get()); // Rendering frame with timestamp of packet that was dropped -> FEC // protection worked. @@ -514,7 +509,7 @@ TEST_F(EndToEndTest, CanReceiveFec) { observation_complete_->Set(); } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } enum { kFirstPacket, @@ -522,10 +517,9 @@ TEST_F(EndToEndTest, CanReceiveFec) { kDropNextMediaPacket, } state_; - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { // TODO(pbos): Run this test with combined NACK/FEC enabled as well. // int rtp_history_ms = 1000; // (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms; @@ -538,7 +532,7 @@ TEST_F(EndToEndTest, CanReceiveFec) { (*receive_configs)[0].renderer = this; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out waiting for dropped frames frames to be rendered."; } @@ -571,7 +565,7 @@ void EndToEndTest::TestReceivedFecPacketsNotNacked( last_sequence_number_(0) {} private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); EXPECT_EQ(kRedPayloadType, header.payloadType); @@ -617,8 +611,7 @@ void EndToEndTest::TestReceivedFecPacketsNotNacked( return SEND_PACKET; } - virtual Action OnReceiveRtcp(const uint8_t* packet, - size_t length) override { + Action OnReceiveRtcp(const uint8_t* packet, size_t length) override { if (state_ == kVerifyFecPacketNotInNackList) { test::RtcpPacketParser rtcp_parser; rtcp_parser.Parse(packet, length); @@ -633,10 +626,9 @@ void EndToEndTest::TestReceivedFecPacketsNotNacked( return SEND_PACKET; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { // Configure hybrid NACK/FEC. send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; send_config->rtp.fec.red_payload_type = kRedPayloadType; @@ -646,7 +638,7 @@ void EndToEndTest::TestReceivedFecPacketsNotNacked( (*receive_configs)[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for FEC packets to be received."; } @@ -683,7 +675,7 @@ void EndToEndTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) { frame_retransmitted_(false) {} private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); @@ -707,7 +699,7 @@ void EndToEndTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) { return SEND_PACKET; } - virtual void FrameCallback(I420VideoFrame* frame) override { + void FrameCallback(I420VideoFrame* frame) override { CriticalSectionScoped lock(crit_.get()); if (frame->timestamp() == retransmitted_timestamp_) { EXPECT_TRUE(frame_retransmitted_); @@ -715,10 +707,9 @@ void EndToEndTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) { } } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; (*receive_configs)[0].pre_render_callback = this; (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; @@ -732,7 +723,7 @@ void EndToEndTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) { } } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for retransmission to render."; } @@ -763,15 +754,15 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) { public: Renderer() : event_(EventWrapper::Create()) {} - virtual void RenderFrame(const I420VideoFrame& video_frame, - int /*time_to_render_ms*/) override { + void RenderFrame(const I420VideoFrame& video_frame, + int /*time_to_render_ms*/) override { EXPECT_EQ(0, *video_frame.buffer(kYPlane)) << "Rendered frame should have zero luma which is applied by the " "pre-render callback."; event_->Set(); } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); } rtc::scoped_ptr event_; @@ -873,7 +864,7 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) { received_pli_(false) {} private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); @@ -890,8 +881,7 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) { return SEND_PACKET; } - virtual Action OnReceiveRtcp(const uint8_t* packet, - size_t length) override { + Action OnReceiveRtcp(const uint8_t* packet, size_t length) override { RTCPUtility::RTCPParserV2 parser(packet, length, true); EXPECT_TRUE(parser.IsValid()); @@ -909,8 +899,8 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) { return SEND_PACKET; } - virtual void RenderFrame(const I420VideoFrame& video_frame, - int time_to_render_ms) override { + void RenderFrame(const I420VideoFrame& video_frame, + int time_to_render_ms) override { CriticalSectionScoped lock(crit_.get()); if (received_pli_ && video_frame.timestamp() > highest_dropped_timestamp_) { @@ -920,18 +910,17 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) { frames_to_drop_ = kPacketsToDrop; } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->rtp.nack.rtp_history_ms = rtp_history_ms_; (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_; (*receive_configs)[0].renderer = this; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out waiting for PLI to be " "received and a frame to be " "rendered afterwards."; @@ -967,8 +956,8 @@ TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) { } private: - virtual DeliveryStatus DeliverPacket(const uint8_t* packet, - size_t length) override { + DeliveryStatus DeliverPacket(const uint8_t* packet, + size_t length) override { if (RtpHeaderParser::IsRtcp(packet, length)) { return receiver_->DeliverPacket(packet, length); } else { @@ -1024,15 +1013,14 @@ void EndToEndTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) { sent_rtcp_(0) {} private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override { + Action OnSendRtp(const uint8_t* packet, size_t length) override { if (++sent_rtp_ % 3 == 0) return DROP_PACKET; return SEND_PACKET; } - virtual Action OnReceiveRtcp(const uint8_t* packet, - size_t length) override { + Action OnReceiveRtcp(const uint8_t* packet, size_t length) override { ++sent_rtcp_; RTCPUtility::RTCPParserV2 parser(packet, length, true); EXPECT_TRUE(parser.IsValid()); @@ -1069,16 +1057,15 @@ void EndToEndTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) { return SEND_PACKET; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; (*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << (rtcp_mode_ == newapi::kRtcpCompound ? "Timed out before observing enough compound packets." @@ -1118,15 +1105,15 @@ TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) { height_(height), done_(EventWrapper::Create()) {} - virtual void RenderFrame(const I420VideoFrame& video_frame, - int time_to_render_ms) override { + void RenderFrame(const I420VideoFrame& video_frame, + int time_to_render_ms) override { EXPECT_EQ(width_, video_frame.width()); EXPECT_EQ(height_, video_frame.height()); (*capturer_)->Stop(); done_->Set(); } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); } @@ -1299,8 +1286,7 @@ TEST_F(EndToEndTest, ReceiveStreamSendsRemb) { public: RembObserver() : EndToEndTest(kDefaultTimeoutMs) {} - virtual Action OnReceiveRtcp(const uint8_t* packet, - size_t length) override { + Action OnReceiveRtcp(const uint8_t* packet, size_t length) override { RTCPUtility::RTCPParserV2 parser(packet, length, true); EXPECT_TRUE(parser.IsValid()); @@ -1325,7 +1311,7 @@ TEST_F(EndToEndTest, ReceiveStreamSendsRemb) { observation_complete_->Set(); return SEND_PACKET; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for a " "receiver RTCP REMB packet to be " "sent."; @@ -1344,8 +1330,8 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) { receiver_call_(NULL), has_seen_pacer_delay_(false) {} - virtual DeliveryStatus DeliverPacket(const uint8_t* packet, - size_t length) override { + DeliveryStatus DeliverPacket(const uint8_t* packet, + size_t length) override { Call::Stats sender_stats = sender_call_->GetStats(); Call::Stats receiver_stats = receiver_call_->GetStats(); if (!has_seen_pacer_delay_) @@ -1357,20 +1343,18 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) { return receiver_call_->Receiver()->DeliverPacket(packet, length); } - virtual void OnCallsCreated(Call* sender_call, - Call* receiver_call) override { + void OnCallsCreated(Call* sender_call, Call* receiver_call) override { sender_call_ = sender_call; receiver_call_ = receiver_call; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for " "non-zero bandwidth stats."; } - virtual void SetReceivers( - PacketReceiver* send_transport_receiver, - PacketReceiver* receive_transport_receiver) override { + void SetReceivers(PacketReceiver* send_transport_receiver, + PacketReceiver* receive_transport_receiver) override { test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver); } @@ -1397,8 +1381,7 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) { private: // Receive stream should send RR packets (and RRTR packets if enabled). - virtual Action OnReceiveRtcp(const uint8_t* packet, - size_t length) override { + Action OnReceiveRtcp(const uint8_t* packet, size_t length) override { RTCPUtility::RTCPParserV2 parser(packet, length, true); EXPECT_TRUE(parser.IsValid()); @@ -1445,16 +1428,15 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) { return SEND_PACKET; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { (*receive_configs)[0].rtp.rtcp_mode = newapi::kRtcpReducedSize; (*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report = enable_rrtr_; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for RTCP SR/RR packets to be sent."; } @@ -1486,7 +1468,7 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs, } private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); @@ -1511,12 +1493,11 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs, return SEND_PACKET; } - virtual size_t GetNumStreams() const override { return num_ssrcs_; } + size_t GetNumStreams() const override { return num_ssrcs_; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { if (num_ssrcs_ > 1) { // Set low simulcast bitrates to not have to wait for bandwidth ramp-up. for (size_t i = 0; i < encoder_config->streams.size(); ++i) { @@ -1531,13 +1512,13 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs, encoder_config->streams.resize(1); } - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, const std::vector& receive_streams) override { send_stream_ = send_stream; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for " << (send_single_ssrc_first_ ? "first SSRC." : "SSRCs."); @@ -1575,16 +1556,15 @@ TEST_F(EndToEndTest, ReportsSetEncoderRates) { : EndToEndTest(kDefaultTimeoutMs), FakeEncoder(Clock::GetRealTimeClock()) {} - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, const std::vector& receive_streams) override { send_stream_ = send_stream; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = this; } @@ -1636,28 +1616,27 @@ TEST_F(EndToEndTest, GetStats) { check_stats_event_(EventWrapper::Create()) {} private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override { + Action OnSendRtp(const uint8_t* packet, size_t length) override { check_stats_event_->Set(); return SEND_PACKET; } - virtual Action OnSendRtcp(const uint8_t* packet, size_t length) override { + Action OnSendRtcp(const uint8_t* packet, size_t length) override { check_stats_event_->Set(); return SEND_PACKET; } - virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) override { + Action OnReceiveRtp(const uint8_t* packet, size_t length) override { check_stats_event_->Set(); return SEND_PACKET; } - virtual Action OnReceiveRtcp(const uint8_t* packet, - size_t length) override { + Action OnReceiveRtcp(const uint8_t* packet, size_t length) override { check_stats_event_->Set(); return SEND_PACKET; } - virtual void FrameCallback(I420VideoFrame* video_frame) override { + void FrameCallback(I420VideoFrame* video_frame) override { // Ensure that we have at least 5ms send side delay. int64_t render_time = video_frame->render_time_ms(); if (render_time > 0) @@ -1793,10 +1772,9 @@ TEST_F(EndToEndTest, GetStats) { return config; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->pre_encode_callback = this; // Used to inject delay. expected_cname_ = send_config->rtp.c_name = "SomeCName"; @@ -1808,16 +1786,16 @@ TEST_F(EndToEndTest, GetStats) { } } - virtual size_t GetNumStreams() const override { return kNumSsrcs; } + size_t GetNumStreams() const override { return kNumSsrcs; } - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, const std::vector& receive_streams) override { send_stream_ = send_stream; receive_streams_ = receive_streams; } - virtual void PerformTest() override { + void PerformTest() override { Clock* clock = Clock::GetRealTimeClock(); int64_t now = clock->TimeInMilliseconds(); int64_t stop_time = now + test::CallTest::kLongTimeoutMs; @@ -1897,13 +1875,13 @@ TEST_F(EndToEndTest, TestReceivedRtpPacketStats) { sent_rtp_(0) {} private: - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, const std::vector& receive_streams) override { receive_stream_ = receive_streams[0]; } - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override { + Action OnSendRtp(const uint8_t* packet, size_t length) override { if (sent_rtp_ >= kNumRtpPacketsToSend) { VideoReceiveStream::Stats stats = receive_stream_->GetStats(); if (kNumRtpPacketsToSend == stats.rtp_stats.transmitted.packets) { @@ -1915,7 +1893,7 @@ TEST_F(EndToEndTest, TestReceivedRtpPacketStats) { return SEND_PACKET; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while verifying number of received RTP packets."; } @@ -1948,7 +1926,7 @@ TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) { } private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); @@ -1971,12 +1949,11 @@ TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) { return SEND_PACKET; } - virtual size_t GetNumStreams() const override { return kNumSsrcs; } + size_t GetNumStreams() const override { return kNumSsrcs; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { // Set low simulcast bitrates to not have to wait for bandwidth ramp-up. for (size_t i = 0; i < encoder_config->streams.size(); ++i) { encoder_config->streams[i].min_bitrate_bps = 10000; @@ -1994,7 +1971,7 @@ TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) { encoder_config->min_transmit_bitrate_bps = 100000; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for redundant payloads on all SSRCs."; } @@ -2031,7 +2008,7 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) { } private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); const uint32_t ssrc = header.ssrc; @@ -2216,47 +2193,44 @@ TEST_F(EndToEndTest, RespectsNetworkState) { receiver_rtcp_(0), down_frames_(0) {} - virtual Action OnSendRtp(const uint8_t* packet, size_t length) override { + Action OnSendRtp(const uint8_t* packet, size_t length) override { CriticalSectionScoped lock(test_crit_.get()); ++sender_rtp_; packet_event_->Set(); return SEND_PACKET; } - virtual Action OnSendRtcp(const uint8_t* packet, size_t length) override { + Action OnSendRtcp(const uint8_t* packet, size_t length) override { CriticalSectionScoped lock(test_crit_.get()); ++sender_rtcp_; packet_event_->Set(); return SEND_PACKET; } - virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) override { + Action OnReceiveRtp(const uint8_t* packet, size_t length) override { ADD_FAILURE() << "Unexpected receiver RTP, should not be sending."; return SEND_PACKET; } - virtual Action OnReceiveRtcp(const uint8_t* packet, - size_t length) override { + Action OnReceiveRtcp(const uint8_t* packet, size_t length) override { CriticalSectionScoped lock(test_crit_.get()); ++receiver_rtcp_; packet_event_->Set(); return SEND_PACKET; } - virtual void OnCallsCreated(Call* sender_call, - Call* receiver_call) override { + void OnCallsCreated(Call* sender_call, Call* receiver_call) override { sender_call_ = sender_call; receiver_call_ = receiver_call; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = this; } - virtual void PerformTest() override { + void PerformTest() override { EXPECT_EQ(kEventSignaled, encoded_frames_->Wait(kDefaultTimeoutMs)) << "No frames received by the encoder."; // Wait for packets from both sender/receiver. @@ -2288,10 +2262,9 @@ TEST_F(EndToEndTest, RespectsNetworkState) { WaitForPacketsOrSilence(false, false); } - virtual int32_t Encode( - const I420VideoFrame& input_image, - const CodecSpecificInfo* codec_specific_info, - const std::vector* frame_types) override { + int32_t Encode(const I420VideoFrame& input_image, + const CodecSpecificInfo* codec_specific_info, + const std::vector* frame_types) override { { CriticalSectionScoped lock(test_crit_.get()); if (sender_state_ == Call::kNetworkDown) { @@ -2414,10 +2387,9 @@ TEST_F(EndToEndTest, NewSendStreamsRespectNetworkDown) { class UnusedEncoder : public test::FakeEncoder { public: UnusedEncoder() : FakeEncoder(Clock::GetRealTimeClock()) {} - virtual int32_t Encode( - const I420VideoFrame& input_image, - const CodecSpecificInfo* codec_specific_info, - const std::vector* frame_types) override { + int32_t Encode(const I420VideoFrame& input_image, + const CodecSpecificInfo* codec_specific_info, + const std::vector* frame_types) override { ADD_FAILURE() << "Unexpected frame encode."; return test::FakeEncoder::Encode( input_image, codec_specific_info, frame_types); diff --git a/webrtc/video/full_stack.cc b/webrtc/video/full_stack.cc index d6810399a..033bf4fc5 100644 --- a/webrtc/video/full_stack.cc +++ b/webrtc/video/full_stack.cc @@ -131,8 +131,7 @@ class VideoAnalyzer : public PacketReceiver, virtual void SetReceiver(PacketReceiver* receiver) { receiver_ = receiver; } - virtual DeliveryStatus DeliverPacket(const uint8_t* packet, - size_t length) OVERRIDE { + DeliveryStatus DeliverPacket(const uint8_t* packet, size_t length) override { rtc::scoped_ptr parser(RtpHeaderParser::Create()); RTPHeader header; parser->Parse(packet, length, &header); @@ -145,7 +144,7 @@ class VideoAnalyzer : public PacketReceiver, return receiver_->DeliverPacket(packet, length); } - virtual void SwapFrame(I420VideoFrame* video_frame) OVERRIDE { + void SwapFrame(I420VideoFrame* video_frame) override { I420VideoFrame* copy = NULL; { CriticalSectionScoped lock(crit_.get()); @@ -171,7 +170,7 @@ class VideoAnalyzer : public PacketReceiver, input_->SwapFrame(video_frame); } - virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE { + bool SendRtp(const uint8_t* packet, size_t length) override { rtc::scoped_ptr parser(RtpHeaderParser::Create()); RTPHeader header; parser->Parse(packet, length, &header); @@ -190,12 +189,12 @@ class VideoAnalyzer : public PacketReceiver, return transport_->SendRtp(packet, length); } - virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE { + bool SendRtcp(const uint8_t* packet, size_t length) override { return transport_->SendRtcp(packet, length); } - virtual void RenderFrame(const I420VideoFrame& video_frame, - int time_to_render_ms) OVERRIDE { + void RenderFrame(const I420VideoFrame& video_frame, + int time_to_render_ms) override { int64_t render_time_ms = Clock::GetRealTimeClock()->CurrentNtpInMilliseconds(); uint32_t send_timestamp = video_frame.timestamp() - rtp_timestamp_delta_; @@ -220,7 +219,7 @@ class VideoAnalyzer : public PacketReceiver, last_rendered_frame_.CopyFrame(video_frame); } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } void Wait() { // Frame comparisons can be very expensive. Wait for test to be done, but diff --git a/webrtc/video/rampup_tests.h b/webrtc/video/rampup_tests.h index 3fb98746c..4335fc13a 100644 --- a/webrtc/video/rampup_tests.h +++ b/webrtc/video/rampup_tests.h @@ -49,12 +49,12 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver { void set_start_bitrate_bps(unsigned int start_bitrate_bps); - virtual void OnReceiveBitrateChanged(const std::vector& ssrcs, - unsigned int bitrate) OVERRIDE; + void OnReceiveBitrateChanged(const std::vector& ssrcs, + unsigned int bitrate) override; - virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE; + bool SendRtp(const uint8_t* packet, size_t length) override; - virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE; + bool SendRtcp(const uint8_t* packet, size_t length) override; EventTypeWrapper Wait(); @@ -101,12 +101,11 @@ class LowRateStreamObserver : public test::DirectTransport, virtual void OnReceiveBitrateChanged(const std::vector& ssrcs, unsigned int bitrate); - virtual bool SendRtp(const uint8_t* data, size_t length) OVERRIDE; + bool SendRtp(const uint8_t* data, size_t length) override; - virtual DeliveryStatus DeliverPacket(const uint8_t* packet, - size_t length) OVERRIDE; + DeliveryStatus DeliverPacket(const uint8_t* packet, size_t length) override; - virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE; + bool SendRtcp(const uint8_t* packet, size_t length) override; // Produces a string similar to "1stream_nortx", depending on the values of // number_of_streams_ and rtx_used_; diff --git a/webrtc/video/receive_statistics_proxy.h b/webrtc/video/receive_statistics_proxy.h index dba5042af..e27a19ca1 100644 --- a/webrtc/video/receive_statistics_proxy.h +++ b/webrtc/video/receive_statistics_proxy.h @@ -45,38 +45,37 @@ class ReceiveStatisticsProxy : public ViEDecoderObserver, void OnRenderedFrame(); // Overrides VCMReceiveStatisticsCallback - virtual void OnReceiveRatesUpdated(uint32_t bitRate, - uint32_t frameRate) OVERRIDE; - virtual void OnFrameCountsUpdated(const FrameCounts& frame_counts) OVERRIDE; - virtual void OnDiscardedPacketsUpdated(int discarded_packets) OVERRIDE; + void OnReceiveRatesUpdated(uint32_t bitRate, uint32_t frameRate) override; + void OnFrameCountsUpdated(const FrameCounts& frame_counts) override; + void OnDiscardedPacketsUpdated(int discarded_packets) override; // Overrides ViEDecoderObserver. - virtual void IncomingCodecChanged(const int video_channel, - const VideoCodec& video_codec) OVERRIDE {} - virtual void IncomingRate(const int video_channel, - const unsigned int framerate, - const unsigned int bitrate_bps) OVERRIDE; - virtual void DecoderTiming(int decode_ms, - int max_decode_ms, - int current_delay_ms, - int target_delay_ms, - int jitter_buffer_ms, - int min_playout_delay_ms, - int render_delay_ms) OVERRIDE; - virtual void RequestNewKeyFrame(const int video_channel) OVERRIDE {} + void IncomingCodecChanged(const int video_channel, + const VideoCodec& video_codec) override {} + void IncomingRate(const int video_channel, + const unsigned int framerate, + const unsigned int bitrate_bps) override; + void DecoderTiming(int decode_ms, + int max_decode_ms, + int current_delay_ms, + int target_delay_ms, + int jitter_buffer_ms, + int min_playout_delay_ms, + int render_delay_ms) override; + void RequestNewKeyFrame(const int video_channel) override {} // Overrides RtcpStatisticsCallback. - virtual void StatisticsUpdated(const webrtc::RtcpStatistics& statistics, - uint32_t ssrc) OVERRIDE; - virtual void CNameChanged(const char* cname, uint32_t ssrc) OVERRIDE; + void StatisticsUpdated(const webrtc::RtcpStatistics& statistics, + uint32_t ssrc) override; + void CNameChanged(const char* cname, uint32_t ssrc) override; // Overrides RtcpPacketTypeCounterObserver - virtual void RtcpPacketTypesCounterUpdated( + void RtcpPacketTypesCounterUpdated( uint32_t ssrc, - const RtcpPacketTypeCounter& packet_counter) OVERRIDE; + const RtcpPacketTypeCounter& packet_counter) override; // Overrides StreamDataCountersCallback. - virtual void DataCountersUpdated(const webrtc::StreamDataCounters& counters, - uint32_t ssrc) OVERRIDE; + void DataCountersUpdated(const webrtc::StreamDataCounters& counters, + uint32_t ssrc) override; private: Clock* const clock_; diff --git a/webrtc/video/replay.cc b/webrtc/video/replay.cc index 8e9ba81de..8a84b660a 100644 --- a/webrtc/video/replay.cc +++ b/webrtc/video/replay.cc @@ -151,8 +151,8 @@ class FileRenderPassthrough : public VideoRenderer { } private: - virtual void RenderFrame(const I420VideoFrame& video_frame, - int time_to_render_ms) OVERRIDE { + void RenderFrame(const I420VideoFrame& video_frame, + int time_to_render_ms) override { if (renderer_ != NULL) renderer_->RenderFrame(video_frame, time_to_render_ms); if (basename_ == "") @@ -181,7 +181,7 @@ class FileRenderPassthrough : public VideoRenderer { PrintI420VideoFrame(video_frame, file_); } - virtual bool IsTextureSupported() const override { return false; } + bool IsTextureSupported() const override { return false; } const std::string basename_; VideoRenderer* const renderer_; diff --git a/webrtc/video/send_statistics_proxy.h b/webrtc/video/send_statistics_proxy.h index 628a28484..a60d495de 100644 --- a/webrtc/video/send_statistics_proxy.h +++ b/webrtc/video/send_statistics_proxy.h @@ -54,48 +54,48 @@ class SendStatisticsProxy : public CpuOveruseMetricsObserver, protected: // From CpuOveruseMetricsObserver. - void CpuOveruseMetricsUpdated(const CpuOveruseMetrics& metrics) OVERRIDE; + void CpuOveruseMetricsUpdated(const CpuOveruseMetrics& metrics) override; // From RtcpStatisticsCallback. - virtual void StatisticsUpdated(const RtcpStatistics& statistics, - uint32_t ssrc) OVERRIDE; - virtual void CNameChanged(const char *cname, uint32_t ssrc) OVERRIDE; + void StatisticsUpdated(const RtcpStatistics& statistics, + uint32_t ssrc) override; + void CNameChanged(const char* cname, uint32_t ssrc) override; // From RtcpPacketTypeCounterObserver - virtual void RtcpPacketTypesCounterUpdated( + void RtcpPacketTypesCounterUpdated( uint32_t ssrc, - const RtcpPacketTypeCounter& packet_counter) OVERRIDE; + const RtcpPacketTypeCounter& packet_counter) override; // From StreamDataCountersCallback. - virtual void DataCountersUpdated(const StreamDataCounters& counters, - uint32_t ssrc) OVERRIDE; + void DataCountersUpdated(const StreamDataCounters& counters, + uint32_t ssrc) override; // From BitrateStatisticsObserver. - virtual void Notify(const BitrateStatistics& total_stats, - const BitrateStatistics& retransmit_stats, - uint32_t ssrc) OVERRIDE; + void Notify(const BitrateStatistics& total_stats, + const BitrateStatistics& retransmit_stats, + uint32_t ssrc) override; // From FrameCountObserver. - virtual void FrameCountUpdated(const FrameCounts& frame_counts, - uint32_t ssrc) OVERRIDE; + void FrameCountUpdated(const FrameCounts& frame_counts, + uint32_t ssrc) override; // From ViEEncoderObserver. - virtual void OutgoingRate(const int video_channel, - const unsigned int framerate, - const unsigned int bitrate) OVERRIDE; + void OutgoingRate(const int video_channel, + const unsigned int framerate, + const unsigned int bitrate) override; - virtual void SuspendChange(int video_channel, bool is_suspended) OVERRIDE; + void SuspendChange(int video_channel, bool is_suspended) override; // From ViECaptureObserver. - virtual void BrightnessAlarm(const int capture_id, - const Brightness brightness) OVERRIDE {} + void BrightnessAlarm(const int capture_id, + const Brightness brightness) override {} - virtual void CapturedFrameRate(const int capture_id, - const unsigned char frame_rate) OVERRIDE; + void CapturedFrameRate(const int capture_id, + const unsigned char frame_rate) override; - virtual void NoPictureAlarm(const int capture_id, - const CaptureAlarm alarm) OVERRIDE {} + void NoPictureAlarm(const int capture_id, const CaptureAlarm alarm) override { + } - virtual void SendSideDelayUpdated(int avg_delay_ms, - int max_delay_ms, - uint32_t ssrc) OVERRIDE; + void SendSideDelayUpdated(int avg_delay_ms, + int max_delay_ms, + uint32_t ssrc) override; private: struct StatsUpdateTimes { diff --git a/webrtc/video/transport_adapter.h b/webrtc/video/transport_adapter.h index 89b0ca076..cd27d7cfe 100644 --- a/webrtc/video/transport_adapter.h +++ b/webrtc/video/transport_adapter.h @@ -21,12 +21,10 @@ class TransportAdapter : public webrtc::Transport { public: explicit TransportAdapter(newapi::Transport* transport); - virtual int SendPacket(int /*channel*/, - const void* packet, - size_t length) OVERRIDE; - virtual int SendRTCPPacket(int /*channel*/, - const void* packet, - size_t length) OVERRIDE; + int SendPacket(int /*channel*/, const void* packet, size_t length) override; + int SendRTCPPacket(int /*channel*/, + const void* packet, + size_t length) override; void Enable(); void Disable(); diff --git a/webrtc/video/video_receive_stream.h b/webrtc/video/video_receive_stream.h index 9f156b17d..dcc8122ee 100644 --- a/webrtc/video/video_receive_stream.h +++ b/webrtc/video/video_receive_stream.h @@ -49,25 +49,25 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, int base_channel); virtual ~VideoReceiveStream(); - virtual void Start() override; - virtual void Stop() override; - virtual Stats GetStats() const override; + void Start() override; + void Stop() override; + Stats GetStats() const override; // Overrides I420FrameCallback. - virtual void FrameCallback(I420VideoFrame* video_frame) override; + void FrameCallback(I420VideoFrame* video_frame) override; // Overrides ExternalRenderer. - virtual int FrameSizeChange(unsigned int width, - unsigned int height, - unsigned int number_of_streams) override; - virtual int DeliverFrame(unsigned char* buffer, - size_t buffer_size, - uint32_t timestamp, - int64_t ntp_time_ms, - int64_t render_time_ms, - void* handle) override; - virtual int DeliverI420Frame(const I420VideoFrame& webrtc_frame) override; - virtual bool IsTextureSupported() override; + int FrameSizeChange(unsigned int width, + unsigned int height, + unsigned int number_of_streams) override; + int DeliverFrame(unsigned char* buffer, + size_t buffer_size, + uint32_t timestamp, + int64_t ntp_time_ms, + int64_t render_time_ms, + void* handle) override; + int DeliverI420Frame(const I420VideoFrame& webrtc_frame) override; + bool IsTextureSupported() override; void SignalNetworkState(Call::NetworkState state); diff --git a/webrtc/video/video_send_stream.h b/webrtc/video/video_send_stream.h index cff2fb111..648a64ed7 100644 --- a/webrtc/video/video_send_stream.h +++ b/webrtc/video/video_send_stream.h @@ -53,21 +53,20 @@ class VideoSendStream : public webrtc::VideoSendStream, virtual ~VideoSendStream(); - virtual void Start() OVERRIDE; - virtual void Stop() OVERRIDE; + void Start() override; + void Stop() override; - virtual bool ReconfigureVideoEncoder( - const VideoEncoderConfig& config) OVERRIDE; + bool ReconfigureVideoEncoder(const VideoEncoderConfig& config) override; - virtual Stats GetStats() OVERRIDE; + Stats GetStats() override; bool DeliverRtcp(const uint8_t* packet, size_t length); // From VideoSendStreamInput. - virtual void SwapFrame(I420VideoFrame* frame) OVERRIDE; + void SwapFrame(I420VideoFrame* frame) override; // From webrtc::VideoSendStream. - virtual VideoSendStreamInput* Input() OVERRIDE; + VideoSendStreamInput* Input() override; typedef std::map RtpStateMap; RtpStateMap GetRtpStates() const; diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc index 103afa492..d351c9d24 100644 --- a/webrtc/video/video_send_stream_tests.cc +++ b/webrtc/video/video_send_stream_tests.cc @@ -95,7 +95,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) { CNameObserver() : SendTest(kDefaultTimeoutMs) {} private: - virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtcp(const uint8_t* packet, size_t length) override { RTCPUtility::RTCPParserV2 parser(packet, length, true); EXPECT_TRUE(parser.IsValid()); @@ -112,14 +112,13 @@ TEST_F(VideoSendStreamTest, SupportsCName) { return SEND_PACKET; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->rtp.c_name = kCName; } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for RTCP with CNAME."; } @@ -137,7 +136,7 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) { kRtpExtensionAbsoluteSendTime, kAbsSendTimeExtensionId)); } - virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); @@ -150,15 +149,14 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) { return SEND_PACKET; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->rtp.extensions.push_back( RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId)); } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for single RTP packet."; } @@ -180,7 +178,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) { } private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); @@ -193,16 +191,15 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) { return SEND_PACKET; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = &encoder_; send_config->rtp.extensions.push_back( RtpExtension(RtpExtension::kTOffset, kTOffsetExtensionId)); } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for a single RTP packet."; } @@ -225,11 +222,9 @@ class FakeReceiveStatistics : public NullReceiveStatistics { stats_map_[send_ssrc] = lossy_stats_.get(); } - virtual StatisticianMap GetActiveStatisticians() const OVERRIDE { - return stats_map_; - } + StatisticianMap GetActiveStatisticians() const override { return stats_map_; } - virtual StreamStatistician* GetStatistician(uint32_t ssrc) const OVERRIDE { + StreamStatistician* GetStatistician(uint32_t ssrc) const override { return lossy_stats_.get(); } @@ -243,26 +238,25 @@ class FakeReceiveStatistics : public NullReceiveStatistics { stats_.cumulative_lost = cumulative_lost; stats_.extended_max_sequence_number = extended_max_sequence_number; } - virtual bool GetStatistics(RtcpStatistics* statistics, - bool reset) OVERRIDE { + bool GetStatistics(RtcpStatistics* statistics, bool reset) override { *statistics = stats_; return true; } - virtual void GetDataCounters(size_t* bytes_received, - uint32_t* packets_received) const OVERRIDE { + void GetDataCounters(size_t* bytes_received, + uint32_t* packets_received) const override { *bytes_received = 0; *packets_received = 0; } - virtual void GetReceiveStreamDataCounters( - StreamDataCounters* data_counters) const OVERRIDE {} - virtual uint32_t BitrateReceived() const OVERRIDE { return 0; } - virtual void ResetStatistics() OVERRIDE {} - virtual bool IsRetransmitOfOldPacket(const RTPHeader& header, - int64_t min_rtt) const OVERRIDE { + void GetReceiveStreamDataCounters( + StreamDataCounters* data_counters) const override {} + uint32_t BitrateReceived() const override { return 0; } + void ResetStatistics() override {} + bool IsRetransmitOfOldPacket(const RTPHeader& header, + int64_t min_rtt) const override { return false; } - virtual bool IsPacketInOrder(uint16_t sequence_number) const OVERRIDE { + bool IsPacketInOrder(uint16_t sequence_number) const override { return true; } @@ -315,7 +309,7 @@ TEST_F(VideoSendStreamTest, SupportsFec) { } private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); @@ -352,15 +346,14 @@ TEST_F(VideoSendStreamTest, SupportsFec) { return SEND_PACKET; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->rtp.fec.red_payload_type = kRedPayloadType; send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets."; } @@ -390,7 +383,7 @@ void VideoSendStreamTest::TestNackRetransmission( } private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); @@ -432,17 +425,16 @@ void VideoSendStreamTest::TestNackRetransmission( return SEND_PACKET; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; send_config->rtp.rtx.payload_type = retransmit_payload_type_; if (retransmit_ssrc_ != kSendSsrcs[0]) send_config->rtp.rtx.ssrcs.push_back(retransmit_ssrc_); } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for NACK retransmission."; } @@ -506,7 +498,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format, } private: - virtual Action OnSendRtp(const uint8_t* packet, size_t size) OVERRIDE { + Action OnSendRtp(const uint8_t* packet, size_t size) override { size_t length = size; RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); @@ -605,10 +597,9 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format, encoder_.SetFrameSize(static_cast(current_size_frame_.Value())); } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { if (use_fec_) { send_config->rtp.fec.red_payload_type = kRedPayloadType; send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; @@ -628,7 +619,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format, RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId)); } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while observing incoming RTP packets."; } @@ -704,7 +695,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) { } private: - virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtcp(const uint8_t* packet, size_t length) override { // Receive statistics reporting having lost 0% of the packets. // This is needed for the send-side bitrate controller to work properly. CriticalSectionScoped lock(crit_.get()); @@ -712,7 +703,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) { return SEND_PACKET; } - virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtp(const uint8_t* packet, size_t length) override { CriticalSectionScoped lock(crit_.get()); ++rtp_count_; RTPHeader header; @@ -747,7 +738,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) { } // This method implements the I420FrameCallback. - void FrameCallback(I420VideoFrame* video_frame) OVERRIDE { + void FrameCallback(I420VideoFrame* video_frame) override { CriticalSectionScoped lock(crit_.get()); if (test_state_ == kDuringSuspend && ++suspended_frame_count_ > kSuspendTimeFrames) { @@ -768,22 +759,20 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) { high_remb_bps_ = value; } - virtual void SetReceivers( - PacketReceiver* send_transport_receiver, - PacketReceiver* receive_transport_receiver) OVERRIDE { + void SetReceivers(PacketReceiver* send_transport_receiver, + PacketReceiver* receive_transport_receiver) override { transport_.SetReceiver(send_transport_receiver); } - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, - const std::vector& receive_streams) OVERRIDE { + const std::vector& receive_streams) override { stream_ = send_stream; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; send_config->pre_encode_callback = this; send_config->suspend_below_min_bitrate = true; @@ -795,7 +784,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) { set_high_remb_bps(min_bitrate_bps + threshold_window + 5000); } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out during suspend-below-min-bitrate test."; transport_.StopSending(); @@ -856,14 +845,14 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) { } private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtp(const uint8_t* packet, size_t length) override { CriticalSectionScoped lock(crit_.get()); last_packet_time_ms_ = clock_->TimeInMilliseconds(); capturer_->Stop(); return SEND_PACKET; } - virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtcp(const uint8_t* packet, size_t length) override { CriticalSectionScoped lock(crit_.get()); const int kVideoMutedThresholdMs = 10000; if (last_packet_time_ms_ > 0 && @@ -885,14 +874,13 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) { return SEND_PACKET; } - virtual void SetReceivers( - PacketReceiver* send_transport_receiver, - PacketReceiver* receive_transport_receiver) OVERRIDE { + void SetReceivers(PacketReceiver* send_transport_receiver, + PacketReceiver* receive_transport_receiver) override { RtpRtcpObserver::SetReceivers(send_transport_receiver, send_transport_receiver); } - virtual size_t GetNumStreams() const OVERRIDE { return 3; } + size_t GetNumStreams() const override { return 3; } virtual void OnFrameGeneratorCapturerCreated( test::FrameGeneratorCapturer* frame_generator_capturer) { @@ -900,7 +888,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) { capturer_ = frame_generator_capturer; } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for RTP packets to stop being sent."; } @@ -941,15 +929,15 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) { rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound); } - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, - const std::vector& receive_streams) OVERRIDE { + const std::vector& receive_streams) override { stream_ = send_stream; } private: - virtual DeliveryStatus DeliverPacket(const uint8_t* packet, - size_t length) OVERRIDE { + DeliveryStatus DeliverPacket(const uint8_t* packet, + size_t length) override { if (RtpHeaderParser::IsRtcp(packet, length)) return DELIVERY_OK; @@ -981,20 +969,18 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) { return DELIVERY_OK; } - virtual void SetReceivers( - PacketReceiver* send_transport_receiver, - PacketReceiver* receive_transport_receiver) OVERRIDE { + void SetReceivers(PacketReceiver* send_transport_receiver, + PacketReceiver* receive_transport_receiver) override { RtpRtcpObserver::SetReceivers(this, send_transport_receiver); } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps; } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timeout while waiting for low bitrate stats after REMB."; } @@ -1013,7 +999,7 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndI420VideoFrames) { public: FrameObserver() : output_frame_event_(EventWrapper::Create()) {} - void FrameCallback(I420VideoFrame* video_frame) OVERRIDE { + void FrameCallback(I420VideoFrame* video_frame) override { // Clone the frame because the caller owns it. output_frames_.push_back(video_frame->CloneFrame()); output_frame_event_->Set(); @@ -1181,9 +1167,9 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) { } private: - virtual int32_t InitEncode(const VideoCodec* codecSettings, - int32_t numberOfCores, - size_t maxPayloadSize) OVERRIDE { + int32_t InitEncode(const VideoCodec* codecSettings, + int32_t numberOfCores, + size_t maxPayloadSize) override { CriticalSectionScoped lock(crit_.get()); EXPECT_FALSE(initialized_); initialized_ = true; @@ -1191,25 +1177,24 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) { return 0; } - virtual int32_t Encode( - const I420VideoFrame& inputImage, - const CodecSpecificInfo* codecSpecificInfo, - const std::vector* frame_types) OVERRIDE { + int32_t Encode(const I420VideoFrame& inputImage, + const CodecSpecificInfo* codecSpecificInfo, + const std::vector* frame_types) override { EXPECT_TRUE(IsReadyForEncode()); observation_complete_->Set(); return 0; } - virtual int32_t RegisterEncodeCompleteCallback( - EncodedImageCallback* callback) OVERRIDE { + int32_t RegisterEncodeCompleteCallback( + EncodedImageCallback* callback) override { CriticalSectionScoped lock(crit_.get()); EXPECT_TRUE(initialized_); callback_registered_ = true; return 0; } - virtual int32_t Release() OVERRIDE { + int32_t Release() override { CriticalSectionScoped lock(crit_.get()); EXPECT_TRUE(IsReadyForEncode()); EXPECT_FALSE(released_); @@ -1220,35 +1205,33 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) { return 0; } - virtual int32_t SetChannelParameters(uint32_t packetLoss, - int64_t rtt) OVERRIDE { + int32_t SetChannelParameters(uint32_t packetLoss, int64_t rtt) override { EXPECT_TRUE(IsReadyForEncode()); return 0; } - virtual int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) OVERRIDE { + int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) override { EXPECT_TRUE(IsReadyForEncode()); return 0; } - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, - const std::vector& receive_streams) OVERRIDE { + const std::vector& receive_streams) override { // Encoder initialization should be done in stream construction before // starting. EXPECT_TRUE(IsReadyForEncode()); stream_ = send_stream; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = this; encoder_config_ = *encoder_config; } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for Encode."; EXPECT_EQ(0u, num_releases()); @@ -1289,23 +1272,22 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) { num_initializations_(0) {} private: - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = this; encoder_config_ = *encoder_config; } - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, - const std::vector& receive_streams) OVERRIDE { + const std::vector& receive_streams) override { stream_ = send_stream; } - virtual int32_t InitEncode(const VideoCodec* config, - int32_t number_of_cores, - size_t max_payload_size) OVERRIDE { + int32_t InitEncode(const VideoCodec* config, + int32_t number_of_cores, + size_t max_payload_size) override { if (num_initializations_ == 0) { // Verify default values. EXPECT_EQ(kRealtimeVideo, config->mode); @@ -1317,7 +1299,7 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) { return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized."; encoder_config_.content_type = VideoEncoderConfig::kScreenshare; @@ -1348,10 +1330,9 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) { } private: - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = this; send_config->encoder_settings.payload_name = "VP8"; @@ -1364,15 +1345,15 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) { encoder_config_ = *encoder_config; } - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, - const std::vector& receive_streams) OVERRIDE { + const std::vector& receive_streams) override { stream_ = send_stream; } - virtual int32_t InitEncode(const VideoCodec* config, - int32_t number_of_cores, - size_t max_payload_size) OVERRIDE { + int32_t InitEncode(const VideoCodec* config, + int32_t number_of_cores, + size_t max_payload_size) override { EXPECT_EQ(kVideoCodecVP8, config->codecType); // Check that the number of temporal layers has propagated properly to @@ -1396,7 +1377,7 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) { return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized."; vp8_settings_.denoisingOn = true; @@ -1408,7 +1389,7 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) { int32_t Encode(const I420VideoFrame& input_image, const CodecSpecificInfo* codec_specific_info, - const std::vector* frame_types) OVERRIDE { + const std::vector* frame_types) override { // Silently skip the encode, FakeEncoder::Encode doesn't produce VP8. return 0; } @@ -1430,7 +1411,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) { media_bytes_sent_(0) {} private: - virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtp(const uint8_t* packet, size_t length) override { RTPHeader header; EXPECT_TRUE(parser_->Parse(packet, length, &header)); ++rtp_packets_sent_; @@ -1438,7 +1419,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) { return SEND_PACKET; } - virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE { + Action OnSendRtcp(const uint8_t* packet, size_t length) override { RTCPUtility::RTCPParserV2 parser(packet, length, true); EXPECT_TRUE(parser.IsValid()); @@ -1460,7 +1441,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) { return SEND_PACKET; } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for RTCP sender report."; } @@ -1482,19 +1463,18 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) { test::FakeEncoder(Clock::GetRealTimeClock()) {} private: - virtual int32_t InitEncode(const VideoCodec* config, - int32_t number_of_cores, - size_t max_payload_size) OVERRIDE { + int32_t InitEncode(const VideoCodec* config, + int32_t number_of_cores, + size_t max_payload_size) override { EXPECT_EQ(static_cast(kScreencastTargetBitrateKbps), config->targetBitrate); observation_complete_->Set(); return test::FakeEncoder::InitEncode( config, number_of_cores, max_payload_size); } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = this; EXPECT_EQ(1u, encoder_config->streams.size()); EXPECT_TRUE( @@ -1504,7 +1484,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) { encoder_config->content_type = VideoEncoderConfig::kScreenshare; } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for the encoder to be initialized."; } @@ -1531,9 +1511,9 @@ TEST_F(VideoSendStreamTest, UsesCallStreamBitratesAndCanReconfigureBitrates) { num_initializations_(0) {} private: - virtual int32_t InitEncode(const VideoCodec* codecSettings, - int32_t numberOfCores, - size_t maxPayloadSize) OVERRIDE { + int32_t InitEncode(const VideoCodec* codecSettings, + int32_t numberOfCores, + size_t maxPayloadSize) override { if (num_initializations_ == 0) { EXPECT_EQ(static_cast(kMinBitrateKbps), codecSettings->minBitrate); @@ -1560,7 +1540,7 @@ TEST_F(VideoSendStreamTest, UsesCallStreamBitratesAndCanReconfigureBitrates) { maxPayloadSize); } - virtual Call::Config GetSenderCallConfig() OVERRIDE { + Call::Config GetSenderCallConfig() override { Call::Config config(SendTransport()); config.stream_bitrates.min_bitrate_bps = kMinBitrateKbps * 1000; config.stream_bitrates.start_bitrate_bps = kStartBitrateKbps * 1000; @@ -1568,10 +1548,9 @@ TEST_F(VideoSendStreamTest, UsesCallStreamBitratesAndCanReconfigureBitrates) { return config; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = this; // Set bitrates lower/higher than min/max to make sure they are properly // capped. @@ -1581,13 +1560,11 @@ TEST_F(VideoSendStreamTest, UsesCallStreamBitratesAndCanReconfigureBitrates) { (kIncreasedMaxBitrateKbps + 10) * 1000; } - virtual void OnCallsCreated(Call* sender_call, - Call* receiver_call) OVERRIDE { + void OnCallsCreated(Call* sender_call, Call* receiver_call) override { call_ = sender_call; } - - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting encoder to be configured."; Call::Config::BitrateConfig bitrate_config; @@ -1627,10 +1604,9 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) { test::FakeEncoder(Clock::GetRealTimeClock()) {} private: - virtual int32_t Encode( - const I420VideoFrame& input_image, - const CodecSpecificInfo* codecSpecificInfo, - const std::vector* frame_types) OVERRIDE { + int32_t Encode(const I420VideoFrame& input_image, + const CodecSpecificInfo* codecSpecificInfo, + const std::vector* frame_types) override { CodecSpecificInfo specifics; memset(&specifics, 0, sizeof(specifics)); specifics.codecType = kVideoCodecGeneric; @@ -1653,17 +1629,16 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) { observation_complete_->Set(); return 0; } - virtual void ModifyConfigs( - VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) OVERRIDE { + void ModifyConfigs(VideoSendStream::Config* send_config, + std::vector* receive_configs, + VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = this; EXPECT_EQ(kNumStreams, encoder_config->streams.size()); } - virtual size_t GetNumStreams() const OVERRIDE { return kNumStreams; } + size_t GetNumStreams() const override { return kNumStreams; } - virtual void PerformTest() OVERRIDE { + void PerformTest() override { EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for the encoder to send one frame."; VideoSendStream::Stats stats = send_stream_->GetStats(); @@ -1680,9 +1655,9 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) { } } - virtual void OnStreamsCreated( + void OnStreamsCreated( VideoSendStream* send_stream, - const std::vector& receive_streams) OVERRIDE { + const std::vector& receive_streams) override { send_stream_ = send_stream; } diff --git a/webrtc/video_engine/call_stats.h b/webrtc/video_engine/call_stats.h index 43e4fc07b..79a8af626 100644 --- a/webrtc/video_engine/call_stats.h +++ b/webrtc/video_engine/call_stats.h @@ -32,8 +32,8 @@ class CallStats : public Module { ~CallStats(); // Implements Module, to use the process thread. - virtual int64_t TimeUntilNextProcess() OVERRIDE; - virtual int32_t Process() OVERRIDE; + int64_t TimeUntilNextProcess() override; + int32_t Process() override; // Returns a RtcpRttStats to register at a statistics provider. The object // has the same lifetime as the CallStats instance. diff --git a/webrtc/video_engine/overuse_frame_detector.h b/webrtc/video_engine/overuse_frame_detector.h index 92d0ea38d..7c04cf775 100644 --- a/webrtc/video_engine/overuse_frame_detector.h +++ b/webrtc/video_engine/overuse_frame_detector.h @@ -81,8 +81,8 @@ class OveruseFrameDetector : public Module { int FramesInQueue() const; // Implements Module. - virtual int64_t TimeUntilNextProcess() OVERRIDE; - virtual int32_t Process() OVERRIDE; + int64_t TimeUntilNextProcess() override; + int32_t Process() override; private: class EncodeTimeAvg; diff --git a/webrtc/video_engine/overuse_frame_detector_unittest.cc b/webrtc/video_engine/overuse_frame_detector_unittest.cc index d14fe9dca..cfb7f01d4 100644 --- a/webrtc/video_engine/overuse_frame_detector_unittest.cc +++ b/webrtc/video_engine/overuse_frame_detector_unittest.cc @@ -62,8 +62,7 @@ class OveruseFrameDetectorTest : public ::testing::Test, overuse_detector_->SetObserver(observer_.get()); } - virtual void CpuOveruseMetricsUpdated( - const CpuOveruseMetrics& metrics) override { + void CpuOveruseMetricsUpdated(const CpuOveruseMetrics& metrics) override { metrics_ = metrics; } diff --git a/webrtc/video_engine/report_block_stats_unittest.cc b/webrtc/video_engine/report_block_stats_unittest.cc index e688d2eb0..13b7af5ba 100644 --- a/webrtc/video_engine/report_block_stats_unittest.cc +++ b/webrtc/video_engine/report_block_stats_unittest.cc @@ -18,7 +18,7 @@ class ReportBlockStatsTest : public ::testing::Test { protected: ReportBlockStatsTest() : kSsrc1(0x12345), kSsrc2(0x23456) {} - virtual void SetUp() OVERRIDE { + void SetUp() override { // kSsrc1: block 1-3. block1_1_.cumulativeLost = 10; block1_1_.fractionLost = 123; diff --git a/webrtc/video_engine/test/auto_test/automated/vie_network_test.cc b/webrtc/video_engine/test/auto_test/automated/vie_network_test.cc index 9c77674a6..4fd2422a9 100644 --- a/webrtc/video_engine/test/auto_test/automated/vie_network_test.cc +++ b/webrtc/video_engine/test/auto_test/automated/vie_network_test.cc @@ -25,15 +25,13 @@ class RtcpCollectorTransport : public webrtc::Transport { RtcpCollectorTransport() : packets_() {} virtual ~RtcpCollectorTransport() {} - virtual int SendPacket(int /*channel*/, - const void* /*data*/, - size_t /*len*/) OVERRIDE { + int SendPacket(int /*channel*/, + const void* /*data*/, + size_t /*len*/) override { EXPECT_TRUE(false); return 0; } - virtual int SendRTCPPacket(int channel, - const void* data, - size_t len) OVERRIDE { + int SendRTCPPacket(int channel, const void* data, size_t len) override { const uint8_t* buf = static_cast(data); webrtc::RtpUtility::RtpHeaderParser parser(buf, len); if (parser.RTCP()) { @@ -109,13 +107,13 @@ class ViENetworkTest : public testing::Test { ViENetworkTest() : vie_("ViENetworkTest"), channel_(-1), transport() {} virtual ~ViENetworkTest() {} - virtual void SetUp() OVERRIDE { + void SetUp() override { EXPECT_EQ(0, vie_.base->CreateChannel(channel_)); EXPECT_EQ(0, vie_.rtp_rtcp->SetRembStatus(channel_, false, true)); EXPECT_EQ(0, vie_.network->RegisterSendTransport(channel_, transport)); } - virtual void TearDown() OVERRIDE { + void TearDown() override { EXPECT_EQ(0, vie_.network->DeregisterSendTransport(channel_)); } diff --git a/webrtc/video_engine/test/auto_test/primitives/framedrop_primitives.h b/webrtc/video_engine/test/auto_test/primitives/framedrop_primitives.h index a8cdfbd7b..92d7bcc33 100644 --- a/webrtc/video_engine/test/auto_test/primitives/framedrop_primitives.h +++ b/webrtc/video_engine/test/auto_test/primitives/framedrop_primitives.h @@ -222,15 +222,16 @@ class FrameDropMonitoringRemoteFileRenderer : public ViEToFileRenderer { virtual ~FrameDropMonitoringRemoteFileRenderer() {} // Implementation of ExternalRenderer: - int FrameSizeChange(unsigned int width, unsigned int height, - unsigned int number_of_streams) OVERRIDE; + int FrameSizeChange(unsigned int width, + unsigned int height, + unsigned int number_of_streams) override; int DeliverFrame(unsigned char* buffer, size_t buffer_size, uint32_t time_stamp, int64_t ntp_time_ms, int64_t render_time, - void* handle) OVERRIDE; - int DeliverI420Frame(const webrtc::I420VideoFrame& webrtc_frame) OVERRIDE; + void* handle) override; + int DeliverI420Frame(const webrtc::I420VideoFrame& webrtc_frame) override; private: void ReportFrameStats(uint32_t time_stamp, int64_t render_time); diff --git a/webrtc/video_engine/test/auto_test/source/vie_autotest_codec.cc b/webrtc/video_engine/test/auto_test/source/vie_autotest_codec.cc index 6d1027fcb..5345dc84d 100644 --- a/webrtc/video_engine/test/auto_test/source/vie_autotest_codec.cc +++ b/webrtc/video_engine/test/auto_test/source/vie_autotest_codec.cc @@ -100,7 +100,7 @@ class TestCodecObserver : public webrtc::ViEEncoderObserver, last_outgoing_bitrate_ += bitrate; } - virtual void SuspendChange(int video_channel, bool is_suspended) OVERRIDE { + void SuspendChange(int video_channel, bool is_suspended) override { suspend_change_called_++; } diff --git a/webrtc/video_engine/test/auto_test/source/vie_autotest_custom_call.cc b/webrtc/video_engine/test/auto_test/source/vie_autotest_custom_call.cc index 225e30aac..dd4eae5a3 100644 --- a/webrtc/video_engine/test/auto_test/source/vie_autotest_custom_call.cc +++ b/webrtc/video_engine/test/auto_test/source/vie_autotest_custom_call.cc @@ -73,7 +73,7 @@ class ViEAutotestEncoderObserver : public webrtc::ViEEncoderObserver { << " BR: " << bitrate << std::endl; } - virtual void SuspendChange(int video_channel, bool is_suspended) OVERRIDE { + void SuspendChange(int video_channel, bool is_suspended) override { std::cout << "SuspendChange: " << is_suspended << std::endl; } }; diff --git a/webrtc/video_engine/test/libvietest/include/tb_I420_codec.h b/webrtc/video_engine/test/libvietest/include/tb_I420_codec.h index 3c4757fdf..918edf96c 100644 --- a/webrtc/video_engine/test/libvietest/include/tb_I420_codec.h +++ b/webrtc/video_engine/test/libvietest/include/tb_I420_codec.h @@ -24,29 +24,28 @@ public: TbI420Encoder(); virtual ~TbI420Encoder(); - virtual int32_t InitEncode(const webrtc::VideoCodec* codecSettings, - int32_t numberOfCores, - size_t maxPayloadSize) OVERRIDE; + int32_t InitEncode(const webrtc::VideoCodec* codecSettings, + int32_t numberOfCores, + size_t maxPayloadSize) override; - virtual int32_t Encode( + int32_t Encode( const webrtc::I420VideoFrame& inputImage, const webrtc::CodecSpecificInfo* codecSpecificInfo, - const std::vector* frameTypes) OVERRIDE; + const std::vector* frameTypes) override; - virtual int32_t RegisterEncodeCompleteCallback( - webrtc::EncodedImageCallback* callback) OVERRIDE; + int32_t RegisterEncodeCompleteCallback( + webrtc::EncodedImageCallback* callback) override; - virtual int32_t Release() OVERRIDE; + int32_t Release() override; - virtual int32_t SetChannelParameters(uint32_t packetLoss, - int64_t rtt) OVERRIDE; + int32_t SetChannelParameters(uint32_t packetLoss, int64_t rtt) override; - virtual int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) OVERRIDE; + int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) override; - virtual int32_t SetPeriodicKeyFrames(bool enable) OVERRIDE; + int32_t SetPeriodicKeyFrames(bool enable) override; - virtual int32_t CodecConfigParameters(uint8_t* /*buffer*/, - int32_t /*size*/) OVERRIDE; + int32_t CodecConfigParameters(uint8_t* /*buffer*/, + int32_t /*size*/) override; struct FunctionCalls { @@ -82,19 +81,18 @@ public: TbI420Decoder(); virtual ~TbI420Decoder(); - virtual int32_t InitDecode(const webrtc::VideoCodec* inst, - int32_t numberOfCores) OVERRIDE; - virtual int32_t Decode( - const webrtc::EncodedImage& inputImage, - bool missingFrames, - const webrtc::RTPFragmentationHeader* fragmentation, - const webrtc::CodecSpecificInfo* codecSpecificInfo = NULL, - int64_t renderTimeMs = -1) OVERRIDE; + int32_t InitDecode(const webrtc::VideoCodec* inst, + int32_t numberOfCores) override; + int32_t Decode(const webrtc::EncodedImage& inputImage, + bool missingFrames, + const webrtc::RTPFragmentationHeader* fragmentation, + const webrtc::CodecSpecificInfo* codecSpecificInfo = NULL, + int64_t renderTimeMs = -1) override; - virtual int32_t RegisterDecodeCompleteCallback( - webrtc::DecodedImageCallback* callback) OVERRIDE; - virtual int32_t Release() OVERRIDE; - virtual int32_t Reset() OVERRIDE; + int32_t RegisterDecodeCompleteCallback( + webrtc::DecodedImageCallback* callback) override; + int32_t Release() override; + int32_t Reset() override; struct FunctionCalls { diff --git a/webrtc/video_engine/test/libvietest/include/tb_external_transport.h b/webrtc/video_engine/test/libvietest/include/tb_external_transport.h index b713aee9f..5d69e70be 100644 --- a/webrtc/video_engine/test/libvietest/include/tb_external_transport.h +++ b/webrtc/video_engine/test/libvietest/include/tb_external_transport.h @@ -85,10 +85,8 @@ public: TbExternalTransport::SsrcChannelMap* receive_channels); ~TbExternalTransport(void); - virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE; - virtual int SendRTCPPacket(int channel, - const void *data, - size_t len) OVERRIDE; + int SendPacket(int channel, const void* data, size_t len) override; + int SendRTCPPacket(int channel, const void* data, size_t len) override; // Should only be called before/after traffic is being processed. // Only one observer can be set (multiple calls will overwrite each other). diff --git a/webrtc/video_engine/test/libvietest/include/vie_to_file_renderer.h b/webrtc/video_engine/test/libvietest/include/vie_to_file_renderer.h index 612a81cf4..d873cd7a6 100644 --- a/webrtc/video_engine/test/libvietest/include/vie_to_file_renderer.h +++ b/webrtc/video_engine/test/libvietest/include/vie_to_file_renderer.h @@ -54,19 +54,20 @@ class ViEToFileRenderer: public webrtc::ExternalRenderer { bool SaveOutputFile(const std::string& prefix); // Implementation of ExternalRenderer: - int FrameSizeChange(unsigned int width, unsigned int height, - unsigned int number_of_streams) OVERRIDE; + int FrameSizeChange(unsigned int width, + unsigned int height, + unsigned int number_of_streams) override; int DeliverFrame(unsigned char* buffer, size_t buffer_size, uint32_t time_stamp, int64_t ntp_time_ms, int64_t render_time, - void* handle) OVERRIDE; + void* handle) override; - int DeliverI420Frame(const webrtc::I420VideoFrame& webrtc_frame) OVERRIDE; + int DeliverI420Frame(const webrtc::I420VideoFrame& webrtc_frame) override; - bool IsTextureSupported() OVERRIDE; + bool IsTextureSupported() override; const std::string GetFullOutputPath() const; diff --git a/webrtc/video_engine/vie_base_impl.h b/webrtc/video_engine/vie_base_impl.h index 7e025c740..958e1c15c 100644 --- a/webrtc/video_engine/vie_base_impl.h +++ b/webrtc/video_engine/vie_base_impl.h @@ -35,13 +35,13 @@ class ViEBaseImpl CpuOveruseObserver* observer); virtual int SetCpuOveruseOptions(int channel, const CpuOveruseOptions& options); - virtual void RegisterCpuOveruseMetricsObserver( + void RegisterCpuOveruseMetricsObserver( int channel, CpuOveruseMetricsObserver* observer) override; virtual int GetCpuOveruseMetrics(int channel, CpuOveruseMetrics* metrics); - virtual void RegisterSendSideDelayObserver(int channel, - SendSideDelayObserver* observer) OVERRIDE; + void RegisterSendSideDelayObserver(int channel, + SendSideDelayObserver* observer) override; virtual int CreateChannel(int& video_channel); // NOLINT virtual int CreateChannel(int& video_channel, // NOLINT const Config* config); @@ -73,12 +73,12 @@ class ViEBaseImpl int CreateChannel(int& video_channel, int original_channel, // NOLINT bool sender, bool disable_default_encoder); - virtual void RegisterSendStatisticsProxy( + void RegisterSendStatisticsProxy( int channel, - SendStatisticsProxy* send_statistics_proxy) OVERRIDE; - virtual void RegisterReceiveStatisticsProxy( + SendStatisticsProxy* send_statistics_proxy) override; + void RegisterReceiveStatisticsProxy( int channel, - ReceiveStatisticsProxy* receive_statistics_proxy) OVERRIDE; + ReceiveStatisticsProxy* receive_statistics_proxy) override; // ViEBaseImpl owns ViESharedData used by all interface implementations. ViESharedData shared_data_; }; diff --git a/webrtc/video_engine/vie_capturer.cc b/webrtc/video_engine/vie_capturer.cc index 9d41a40c9..62a8a52cd 100644 --- a/webrtc/video_engine/vie_capturer.cc +++ b/webrtc/video_engine/vie_capturer.cc @@ -34,8 +34,7 @@ const int kThreadWaitTimeMs = 100; class RegistrableCpuOveruseMetricsObserver : public CpuOveruseMetricsObserver { public: - virtual void CpuOveruseMetricsUpdated( - const CpuOveruseMetrics& metrics) override { + void CpuOveruseMetricsUpdated(const CpuOveruseMetrics& metrics) override { rtc::CritScope lock(&crit_); if (observer_) observer_->CpuOveruseMetricsUpdated(metrics); diff --git a/webrtc/video_engine/vie_capturer.h b/webrtc/video_engine/vie_capturer.h index 4dfcfbf9a..9f077e101 100644 --- a/webrtc/video_engine/vie_capturer.h +++ b/webrtc/video_engine/vie_capturer.h @@ -79,7 +79,7 @@ class ViECapturer virtual int IncomingFrameI420(const ViEVideoFrameI420& video_frame, unsigned long long capture_time = 0); // NOLINT - virtual void SwapFrame(I420VideoFrame* frame) OVERRIDE; + void SwapFrame(I420VideoFrame* frame) override; // Start/Stop. int32_t Start( diff --git a/webrtc/video_engine/vie_channel.h b/webrtc/video_engine/vie_channel.h index 089ad075f..3744d8881 100644 --- a/webrtc/video_engine/vie_channel.h +++ b/webrtc/video_engine/vie_channel.h @@ -321,10 +321,9 @@ class ViEChannel virtual void IncomingCodecChanged(const VideoCodec& codec); // Implements VCMReceiveStatisticsCallback. - virtual void OnReceiveRatesUpdated(uint32_t bit_rate, - uint32_t frame_rate) OVERRIDE; - virtual void OnDiscardedPacketsUpdated(int discarded_packets) OVERRIDE; - virtual void OnFrameCountsUpdated(const FrameCounts& frame_counts) OVERRIDE; + void OnReceiveRatesUpdated(uint32_t bit_rate, uint32_t frame_rate) override; + void OnDiscardedPacketsUpdated(int discarded_packets) override; + void OnFrameCountsUpdated(const FrameCounts& frame_counts) override; // Implements VCMDecoderTimingCallback. virtual void OnDecoderTiming(int decode_ms, @@ -456,9 +455,9 @@ class ViEChannel class RegisterableSendSideDelayObserver : public RegisterableCallback { - virtual void SendSideDelayUpdated(int avg_delay_ms, - int max_delay_ms, - uint32_t ssrc) OVERRIDE { + void SendSideDelayUpdated(int avg_delay_ms, + int max_delay_ms, + uint32_t ssrc) override { CriticalSectionScoped cs(critsect_.get()); if (callback_) callback_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms, ssrc); @@ -468,7 +467,7 @@ class ViEChannel class RegisterableRtcpPacketTypeCounterObserver : public RegisterableCallback { public: - virtual void RtcpPacketTypesCounterUpdated( + void RtcpPacketTypesCounterUpdated( uint32_t ssrc, const RtcpPacketTypeCounter& packet_counter) override { CriticalSectionScoped cs(critsect_.get()); diff --git a/webrtc/video_engine/vie_channel_group.cc b/webrtc/video_engine/vie_channel_group.cc index 8386dc361..c91c9a97d 100644 --- a/webrtc/video_engine/vie_channel_group.cc +++ b/webrtc/video_engine/vie_channel_group.cc @@ -48,41 +48,41 @@ class WrappingBitrateEstimator : public RemoteBitrateEstimator { virtual ~WrappingBitrateEstimator() {} - virtual void IncomingPacket(int64_t arrival_time_ms, - size_t payload_size, - const RTPHeader& header) OVERRIDE { + void IncomingPacket(int64_t arrival_time_ms, + size_t payload_size, + const RTPHeader& header) override { CriticalSectionScoped cs(crit_sect_.get()); PickEstimatorFromHeader(header); rbe_->IncomingPacket(arrival_time_ms, payload_size, header); } - virtual int32_t Process() OVERRIDE { + int32_t Process() override { CriticalSectionScoped cs(crit_sect_.get()); return rbe_->Process(); } - virtual int64_t TimeUntilNextProcess() OVERRIDE { + int64_t TimeUntilNextProcess() override { CriticalSectionScoped cs(crit_sect_.get()); return rbe_->TimeUntilNextProcess(); } - virtual void OnRttUpdate(int64_t rtt) OVERRIDE { + void OnRttUpdate(int64_t rtt) override { CriticalSectionScoped cs(crit_sect_.get()); rbe_->OnRttUpdate(rtt); } - virtual void RemoveStream(unsigned int ssrc) OVERRIDE { + void RemoveStream(unsigned int ssrc) override { CriticalSectionScoped cs(crit_sect_.get()); rbe_->RemoveStream(ssrc); } - virtual bool LatestEstimate(std::vector* ssrcs, - unsigned int* bitrate_bps) const OVERRIDE { + bool LatestEstimate(std::vector* ssrcs, + unsigned int* bitrate_bps) const override { CriticalSectionScoped cs(crit_sect_.get()); return rbe_->LatestEstimate(ssrcs, bitrate_bps); } - virtual bool GetStats(ReceiveBandwidthEstimatorStats* output) const OVERRIDE { + bool GetStats(ReceiveBandwidthEstimatorStats* output) const override { CriticalSectionScoped cs(crit_sect_.get()); return rbe_->GetStats(output); } diff --git a/webrtc/video_engine/vie_encoder.h b/webrtc/video_engine/vie_encoder.h index 517f6f60b..a8be5266d 100644 --- a/webrtc/video_engine/vie_encoder.h +++ b/webrtc/video_engine/vie_encoder.h @@ -107,17 +107,15 @@ class ViEEncoder int32_t ScaleInputImage(bool enable); // Implementing ViEFrameCallback. - virtual void DeliverFrame(int id, - I420VideoFrame* video_frame, - const std::vector& csrcs) OVERRIDE; - virtual void DelayChanged(int id, int frame_delay) OVERRIDE; - virtual int GetPreferedFrameSettings(int* width, - int* height, - int* frame_rate) OVERRIDE; + void DeliverFrame(int id, + I420VideoFrame* video_frame, + const std::vector& csrcs) override; + void DelayChanged(int id, int frame_delay) override; + int GetPreferedFrameSettings(int* width, + int* height, + int* frame_rate) override; - virtual void ProviderDestroyed(int id) OVERRIDE { - return; - } + void ProviderDestroyed(int id) override { return; } int32_t SendKeyFrame(); int32_t SendCodecStatistics(uint32_t* num_key_frames, @@ -137,23 +135,22 @@ class ViEEncoder void OnSetRates(uint32_t bitrate_bps, int framerate) override; // Implements VCMPacketizationCallback. - virtual int32_t SendData(uint8_t payload_type, - const EncodedImage& encoded_image, - const RTPFragmentationHeader& fragmentation_header, - const RTPVideoHeader* rtp_video_hdr) OVERRIDE; + int32_t SendData(uint8_t payload_type, + const EncodedImage& encoded_image, + const RTPFragmentationHeader& fragmentation_header, + const RTPVideoHeader* rtp_video_hdr) override; // Implements VideoSendStatisticsCallback. - virtual int32_t SendStatistics(const uint32_t bit_rate, - const uint32_t frame_rate) OVERRIDE; + int32_t SendStatistics(const uint32_t bit_rate, + const uint32_t frame_rate) override; int32_t RegisterCodecObserver(ViEEncoderObserver* observer); // Implements RtcpIntraFrameObserver. - virtual void OnReceivedIntraFrameRequest(uint32_t ssrc) OVERRIDE; - virtual void OnReceivedSLI(uint32_t ssrc, uint8_t picture_id) OVERRIDE; - virtual void OnReceivedRPSI(uint32_t ssrc, uint64_t picture_id) OVERRIDE; - virtual void OnLocalSsrcChanged(uint32_t old_ssrc, - uint32_t new_ssrc) OVERRIDE; + void OnReceivedIntraFrameRequest(uint32_t ssrc) override; + void OnReceivedSLI(uint32_t ssrc, uint8_t picture_id) override; + void OnReceivedRPSI(uint32_t ssrc, uint64_t picture_id) override; + void OnLocalSsrcChanged(uint32_t old_ssrc, uint32_t new_ssrc) override; // Sets SSRCs for all streams. bool SetSsrcs(const std::list& ssrcs); diff --git a/webrtc/video_engine/vie_image_process_impl.h b/webrtc/video_engine/vie_image_process_impl.h index 38a6a08cf..64775b1e1 100644 --- a/webrtc/video_engine/vie_image_process_impl.h +++ b/webrtc/video_engine/vie_image_process_impl.h @@ -37,25 +37,25 @@ class ViEImageProcessImpl virtual int EnableDeflickering(const int capture_id, const bool enable); virtual int EnableColorEnhancement(const int video_channel, const bool enable); - virtual void RegisterPreEncodeCallback( + void RegisterPreEncodeCallback( int video_channel, - I420FrameCallback* pre_encode_callback) OVERRIDE; - virtual void DeRegisterPreEncodeCallback(int video_channel) OVERRIDE; + I420FrameCallback* pre_encode_callback) override; + void DeRegisterPreEncodeCallback(int video_channel) override; - virtual void RegisterPostEncodeImageCallback( + void RegisterPostEncodeImageCallback( int video_channel, - EncodedImageCallback* post_encode_callback) OVERRIDE; - virtual void DeRegisterPostEncodeCallback(int video_channel) OVERRIDE; + EncodedImageCallback* post_encode_callback) override; + void DeRegisterPostEncodeCallback(int video_channel) override; - virtual void RegisterPreDecodeImageCallback( - int video_channel, - EncodedImageCallback* post_encode_callback) OVERRIDE; - virtual void DeRegisterPreDecodeCallback(int video_channel) OVERRIDE; - - virtual void RegisterPreRenderCallback( + void RegisterPreDecodeImageCallback( int video_channel, - I420FrameCallback* pre_render_callback) OVERRIDE; - virtual void DeRegisterPreRenderCallback(int video_channel) OVERRIDE; + EncodedImageCallback* post_encode_callback) override; + void DeRegisterPreDecodeCallback(int video_channel) override; + + void RegisterPreRenderCallback( + int video_channel, + I420FrameCallback* pre_render_callback) override; + void DeRegisterPreRenderCallback(int video_channel) override; protected: explicit ViEImageProcessImpl(ViESharedData* shared_data); diff --git a/webrtc/video_engine/vie_network_impl.h b/webrtc/video_engine/vie_network_impl.h index f2d5772c1..7a09a2c7a 100644 --- a/webrtc/video_engine/vie_network_impl.h +++ b/webrtc/video_engine/vie_network_impl.h @@ -24,25 +24,25 @@ class ViENetworkImpl public ViERefCount { public: // Implements ViENetwork. - virtual int Release() OVERRIDE; - virtual void SetNetworkTransmissionState(const int video_channel, - const bool is_transmitting) OVERRIDE; - virtual int RegisterSendTransport(const int video_channel, - Transport& transport) OVERRIDE; - virtual int DeregisterSendTransport(const int video_channel) OVERRIDE; - virtual int ReceivedRTPPacket(const int video_channel, - const void* data, - const size_t length, - const PacketTime& packet_time) OVERRIDE; - virtual int ReceivedRTCPPacket(const int video_channel, - const void* data, - const size_t length) OVERRIDE; - virtual int SetMTU(int video_channel, unsigned int mtu) OVERRIDE; + int Release() override; + void SetNetworkTransmissionState(const int video_channel, + const bool is_transmitting) override; + int RegisterSendTransport(const int video_channel, + Transport& transport) override; + int DeregisterSendTransport(const int video_channel) override; + int ReceivedRTPPacket(const int video_channel, + const void* data, + const size_t length, + const PacketTime& packet_time) override; + int ReceivedRTCPPacket(const int video_channel, + const void* data, + const size_t length) override; + int SetMTU(int video_channel, unsigned int mtu) override; - virtual int ReceivedBWEPacket(const int video_channel, - int64_t arrival_time_ms, - size_t payload_size, - const RTPHeader& header) OVERRIDE; + int ReceivedBWEPacket(const int video_channel, + int64_t arrival_time_ms, + size_t payload_size, + const RTPHeader& header) override; protected: explicit ViENetworkImpl(ViESharedData* shared_data); diff --git a/webrtc/video_engine/vie_receiver.h b/webrtc/video_engine/vie_receiver.h index b7f185993..e2e3daf26 100644 --- a/webrtc/video_engine/vie_receiver.h +++ b/webrtc/video_engine/vie_receiver.h @@ -77,12 +77,10 @@ class ViEReceiver : public RtpData { int ReceivedRTCPPacket(const void* rtcp_packet, size_t rtcp_packet_length); // Implements RtpData. - virtual int32_t OnReceivedPayloadData( - const uint8_t* payload_data, - const size_t payload_size, - const WebRtcRTPHeader* rtp_header) OVERRIDE; - virtual bool OnRecoveredPacket(const uint8_t* packet, - size_t packet_length) OVERRIDE; + int32_t OnReceivedPayloadData(const uint8_t* payload_data, + const size_t payload_size, + const WebRtcRTPHeader* rtp_header) override; + bool OnRecoveredPacket(const uint8_t* packet, size_t packet_length) override; ReceiveStatistics* GetReceiveStatistics() const; diff --git a/webrtc/video_engine/vie_rtp_rtcp_impl.h b/webrtc/video_engine/vie_rtp_rtcp_impl.h index 0c0a995cb..7512222a2 100644 --- a/webrtc/video_engine/vie_rtp_rtcp_impl.h +++ b/webrtc/video_engine/vie_rtp_rtcp_impl.h @@ -45,11 +45,10 @@ class ViERTP_RTCPImpl const uint8_t payload_type); virtual int SetStartSequenceNumber(const int video_channel, uint16_t sequence_number); - virtual void SetRtpStateForSsrc(int video_channel, - uint32_t ssrc, - const RtpState& rtp_state) OVERRIDE; - virtual RtpState GetRtpStateForSsrc(int video_channel, - uint32_t ssrc) OVERRIDE; + void SetRtpStateForSsrc(int video_channel, + uint32_t ssrc, + const RtpState& rtp_state) override; + RtpState GetRtpStateForSsrc(int video_channel, uint32_t ssrc) override; virtual int SetRTCPStatus(const int video_channel, const ViERTCPMode rtcp_mode); virtual int GetRTCPStatus(const int video_channel, @@ -155,7 +154,7 @@ class ViERTP_RTCPImpl int channel, FrameCountObserver* callback); virtual int DeregisterSendFrameCountObserver( int channel, FrameCountObserver* callback); - virtual int RegisterRtcpPacketTypeCounterObserver( + int RegisterRtcpPacketTypeCounterObserver( int video_channel, RtcpPacketTypeCounterObserver* observer) override; diff --git a/webrtc/video_engine/vie_sender.h b/webrtc/video_engine/vie_sender.h index 3a8047905..3e6bd9554 100644 --- a/webrtc/video_engine/vie_sender.h +++ b/webrtc/video_engine/vie_sender.h @@ -40,8 +40,8 @@ class ViESender: public Transport { int StopRTPDump(); // Implements Transport. - virtual int SendPacket(int vie_id, const void* data, size_t len) OVERRIDE; - virtual int SendRTCPPacket(int vie_id, const void* data, size_t len) OVERRIDE; + int SendPacket(int vie_id, const void* data, size_t len) override; + int SendRTCPPacket(int vie_id, const void* data, size_t len) override; private: const int32_t channel_id_; diff --git a/webrtc/video_engine/vie_sync_module.h b/webrtc/video_engine/vie_sync_module.h index 994cdb2f6..a75d716c0 100644 --- a/webrtc/video_engine/vie_sync_module.h +++ b/webrtc/video_engine/vie_sync_module.h @@ -45,8 +45,8 @@ class ViESyncModule : public Module { int SetTargetBufferingDelay(int target_delay_ms); // Implements Module. - virtual int64_t TimeUntilNextProcess() OVERRIDE; - virtual int32_t Process() OVERRIDE; + int64_t TimeUntilNextProcess() override; + int32_t Process() override; private: rtc::scoped_ptr data_cs_; diff --git a/webrtc/voice_engine/channel.cc b/webrtc/voice_engine/channel.cc index 0a5d8e607..95bcc5cfa 100644 --- a/webrtc/voice_engine/channel.cc +++ b/webrtc/voice_engine/channel.cc @@ -59,8 +59,8 @@ class StatisticsProxy : public RtcpStatisticsCallback { ssrc_(ssrc) {} virtual ~StatisticsProxy() {} - virtual void StatisticsUpdated(const RtcpStatistics& statistics, - uint32_t ssrc) OVERRIDE { + void StatisticsUpdated(const RtcpStatistics& statistics, + uint32_t ssrc) override { if (ssrc != ssrc_) return; @@ -71,7 +71,7 @@ class StatisticsProxy : public RtcpStatisticsCallback { } } - virtual void CNameChanged(const char* cname, uint32_t ssrc) OVERRIDE {} + void CNameChanged(const char* cname, uint32_t ssrc) override {} void ResetStatistics() { CriticalSectionScoped cs(stats_lock_.get()); @@ -101,10 +101,9 @@ class VoERtcpObserver : public RtcpBandwidthObserver { // Not used for Voice Engine. } - virtual void OnReceivedRtcpReceiverReport( - const ReportBlockList& report_blocks, - int64_t rtt, - int64_t now_ms) override { + void OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks, + int64_t rtt, + int64_t now_ms) override { // TODO(mflodman): Do we need to aggregate reports here or can we jut send // what we get? I.e. do we ever get multiple reports bundled into one RTCP // report for VoiceEngine? diff --git a/webrtc/voice_engine/channel.h b/webrtc/voice_engine/channel.h index 29f9fe644..7629ceb65 100644 --- a/webrtc/voice_engine/channel.h +++ b/webrtc/voice_engine/channel.h @@ -345,64 +345,55 @@ public: void SetVideoEngineBWETarget(ViENetwork* vie_network, int video_channel); // From AudioPacketizationCallback in the ACM - virtual int32_t SendData( - FrameType frameType, - uint8_t payloadType, - uint32_t timeStamp, - const uint8_t* payloadData, - size_t payloadSize, - const RTPFragmentationHeader* fragmentation) OVERRIDE; + int32_t SendData(FrameType frameType, + uint8_t payloadType, + uint32_t timeStamp, + const uint8_t* payloadData, + size_t payloadSize, + const RTPFragmentationHeader* fragmentation) override; // From ACMVADCallback in the ACM - virtual int32_t InFrameType(int16_t frameType) OVERRIDE; + int32_t InFrameType(int16_t frameType) override; int32_t OnRxVadDetected(int vadDecision); // From RtpData in the RTP/RTCP module - virtual int32_t OnReceivedPayloadData( - const uint8_t* payloadData, - size_t payloadSize, - const WebRtcRTPHeader* rtpHeader) OVERRIDE; - virtual bool OnRecoveredPacket(const uint8_t* packet, - size_t packet_length) OVERRIDE; + int32_t OnReceivedPayloadData(const uint8_t* payloadData, + size_t payloadSize, + const WebRtcRTPHeader* rtpHeader) override; + bool OnRecoveredPacket(const uint8_t* packet, + size_t packet_length) override; // From RtpFeedback in the RTP/RTCP module - virtual int32_t OnInitializeDecoder( - int32_t id, - int8_t payloadType, - const char payloadName[RTP_PAYLOAD_NAME_SIZE], - int frequency, - uint8_t channels, - uint32_t rate) OVERRIDE; - virtual void OnIncomingSSRCChanged(int32_t id, - uint32_t ssrc) OVERRIDE; - virtual void OnIncomingCSRCChanged(int32_t id, - uint32_t CSRC, bool added) OVERRIDE; - virtual void ResetStatistics(uint32_t ssrc) OVERRIDE; + int32_t OnInitializeDecoder(int32_t id, + int8_t payloadType, + const char payloadName[RTP_PAYLOAD_NAME_SIZE], + int frequency, + uint8_t channels, + uint32_t rate) override; + void OnIncomingSSRCChanged(int32_t id, uint32_t ssrc) override; + void OnIncomingCSRCChanged(int32_t id, uint32_t CSRC, bool added) override; + void ResetStatistics(uint32_t ssrc) override; // From RtpAudioFeedback in the RTP/RTCP module - virtual void OnPlayTelephoneEvent(int32_t id, - uint8_t event, - uint16_t lengthMs, - uint8_t volume) OVERRIDE; + void OnPlayTelephoneEvent(int32_t id, + uint8_t event, + uint16_t lengthMs, + uint8_t volume) override; // From Transport (called by the RTP/RTCP module) - virtual int SendPacket(int /*channel*/, - const void *data, - size_t len) OVERRIDE; - virtual int SendRTCPPacket(int /*channel*/, - const void *data, - size_t len) OVERRIDE; + int SendPacket(int /*channel*/, const void* data, size_t len) override; + int SendRTCPPacket(int /*channel*/, const void* data, size_t len) override; // From MixerParticipant - virtual int32_t GetAudioFrame(int32_t id, AudioFrame& audioFrame) OVERRIDE; - virtual int32_t NeededFrequency(int32_t id) OVERRIDE; + int32_t GetAudioFrame(int32_t id, AudioFrame& audioFrame) override; + int32_t NeededFrequency(int32_t id) override; // From FileCallback - virtual void PlayNotification(int32_t id, uint32_t durationMs) OVERRIDE; - virtual void RecordNotification(int32_t id, uint32_t durationMs) OVERRIDE; - virtual void PlayFileEnded(int32_t id) OVERRIDE; - virtual void RecordFileEnded(int32_t id) OVERRIDE; + void PlayNotification(int32_t id, uint32_t durationMs) override; + void RecordNotification(int32_t id, uint32_t durationMs) override; + void PlayFileEnded(int32_t id) override; + void RecordFileEnded(int32_t id) override; uint32_t InstanceId() const { diff --git a/webrtc/voice_engine/monitor_module.h b/webrtc/voice_engine/monitor_module.h index 8a399eb3d..42ea74d7e 100644 --- a/webrtc/voice_engine/monitor_module.h +++ b/webrtc/voice_engine/monitor_module.h @@ -40,9 +40,10 @@ public: virtual ~MonitorModule(); public: // module - virtual int64_t TimeUntilNextProcess() OVERRIDE; + int64_t TimeUntilNextProcess() override; + + int32_t Process() override; - virtual int32_t Process() OVERRIDE; private: MonitorObserver* _observerPtr; CriticalSectionWrapper& _callbackCritSect; diff --git a/webrtc/voice_engine/test/android/android_test/jni/android_test.cc b/webrtc/voice_engine/test/android/android_test/jni/android_test.cc index b744d1d73..28eeef0a0 100644 --- a/webrtc/voice_engine/test/android/android_test/jni/android_test.cc +++ b/webrtc/voice_engine/test/android/android_test/jni/android_test.cc @@ -139,10 +139,9 @@ class my_transportation : public Transport netw(network) { } - virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE; - virtual int SendRTCPPacket(int channel, - const void *data, - size_t len) OVERRIDE; + int SendPacket(int channel, const void* data, size_t len) override; + int SendRTCPPacket(int channel, const void* data, size_t len) override; + private: VoENetwork * netw; }; diff --git a/webrtc/voice_engine/test/auto_test/fakes/fake_external_transport.h b/webrtc/voice_engine/test/auto_test/fakes/fake_external_transport.h index 029b19ed1..4b20b4758 100644 --- a/webrtc/voice_engine/test/auto_test/fakes/fake_external_transport.h +++ b/webrtc/voice_engine/test/auto_test/fakes/fake_external_transport.h @@ -23,10 +23,8 @@ class FakeExternalTransport : public webrtc::Transport { public: explicit FakeExternalTransport(webrtc::VoENetwork* ptr); virtual ~FakeExternalTransport(); - virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE; - virtual int SendRTCPPacket(int channel, - const void *data, - size_t len) OVERRIDE; + int SendPacket(int channel, const void* data, size_t len) override; + int SendRTCPPacket(int channel, const void* data, size_t len) override; void SetDelayStatus(bool enabled, unsigned int delayInMs = 100); webrtc::VoENetwork* my_network_; diff --git a/webrtc/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h b/webrtc/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h index 32ec8679c..67f5af3a7 100644 --- a/webrtc/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h +++ b/webrtc/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h @@ -37,14 +37,12 @@ class LoopBackTransport : public webrtc::Transport { ~LoopBackTransport() { thread_->Stop(); } - virtual int SendPacket(int channel, const void* data, size_t len) OVERRIDE { + int SendPacket(int channel, const void* data, size_t len) override { StorePacket(Packet::Rtp, channel, data, len); return static_cast(len); } - virtual int SendRTCPPacket(int channel, - const void* data, - size_t len) OVERRIDE { + int SendRTCPPacket(int channel, const void* data, size_t len) override { StorePacket(Packet::Rtcp, channel, data, len); return static_cast(len); } diff --git a/webrtc/voice_engine/test/auto_test/standard/rtp_rtcp_extensions.cc b/webrtc/voice_engine/test/auto_test/standard/rtp_rtcp_extensions.cc index ec9787cf5..bde16220e 100644 --- a/webrtc/voice_engine/test/auto_test/standard/rtp_rtcp_extensions.cc +++ b/webrtc/voice_engine/test/auto_test/standard/rtp_rtcp_extensions.cc @@ -29,7 +29,7 @@ class ExtensionVerifyTransport : public webrtc::Transport { audio_level_id_(-1), absolute_sender_time_id_(-1) {} - virtual int SendPacket(int channel, const void* data, size_t len) OVERRIDE { + int SendPacket(int channel, const void* data, size_t len) override { webrtc::RTPHeader header; if (parser_->Parse(reinterpret_cast(data), len, &header)) { bool ok = true; @@ -52,9 +52,7 @@ class ExtensionVerifyTransport : public webrtc::Transport { return static_cast(len); } - virtual int SendRTCPPacket(int channel, - const void* data, - size_t len) OVERRIDE { + int SendRTCPPacket(int channel, const void* data, size_t len) override { return static_cast(len); } @@ -93,14 +91,12 @@ class ExtensionVerifyTransport : public webrtc::Transport { class SendRtpRtcpHeaderExtensionsTest : public BeforeStreamingFixture { protected: - virtual void SetUp() OVERRIDE { + void SetUp() override { EXPECT_EQ(0, voe_network_->DeRegisterExternalTransport(channel_)); EXPECT_EQ(0, voe_network_->RegisterExternalTransport(channel_, verifying_transport_)); } - virtual void TearDown() OVERRIDE { - PausePlaying(); - } + void TearDown() override { PausePlaying(); } ExtensionVerifyTransport verifying_transport_; }; @@ -176,7 +172,7 @@ class MockViENetwork : public webrtc::ViENetwork { class ReceiveRtpRtcpHeaderExtensionsTest : public BeforeStreamingFixture { protected: - virtual void SetUp() OVERRIDE { + void SetUp() override { EXPECT_EQ(0, voe_rtp_rtcp_->SetSendAbsoluteSenderTimeStatus(channel_, true, 11)); EXPECT_EQ(0, diff --git a/webrtc/voice_engine/test/win_test/WinTestDlg.cc b/webrtc/voice_engine/test/win_test/WinTestDlg.cc index 03011b64f..4436a86d8 100644 --- a/webrtc/voice_engine/test/win_test/WinTestDlg.cc +++ b/webrtc/voice_engine/test/win_test/WinTestDlg.cc @@ -129,12 +129,9 @@ class MyTransport : public Transport { public: MyTransport(VoENetwork* veNetwork); - virtual int SendPacket(int channel, - const void *data, - size_t len) OVERRIDE; - virtual int SendRTCPPacket(int channel, - const void *data, - size_t len) OVERRIDE; + int SendPacket(int channel, const void* data, size_t len) override; + int SendRTCPPacket(int channel, const void* data, size_t len) override; + private: VoENetwork* _veNetworkPtr; }; diff --git a/webrtc/voice_engine/voe_network_impl.h b/webrtc/voice_engine/voe_network_impl.h index dc9eb3802..ee9b92ec3 100644 --- a/webrtc/voice_engine/voe_network_impl.h +++ b/webrtc/voice_engine/voe_network_impl.h @@ -22,22 +22,17 @@ namespace webrtc class VoENetworkImpl: public VoENetwork { public: - virtual int RegisterExternalTransport(int channel, - Transport& transport) OVERRIDE; + int RegisterExternalTransport(int channel, Transport& transport) override; - virtual int DeRegisterExternalTransport(int channel) OVERRIDE; + int DeRegisterExternalTransport(int channel) override; - virtual int ReceivedRTPPacket(int channel, - const void* data, - size_t length) OVERRIDE; - virtual int ReceivedRTPPacket(int channel, - const void* data, - size_t length, - const PacketTime& packet_time) OVERRIDE; + int ReceivedRTPPacket(int channel, const void* data, size_t length) override; + int ReceivedRTPPacket(int channel, + const void* data, + size_t length, + const PacketTime& packet_time) override; - virtual int ReceivedRTCPPacket(int channel, - const void* data, - size_t length) OVERRIDE; + int ReceivedRTCPPacket(int channel, const void* data, size_t length) override; protected: VoENetworkImpl(voe::SharedData* shared);