Roll chromium_revision e144d30..6fdb142 (318658:318841) + remove OVERRIDE macro
Clang version changed 223108:230914
Details: https://chromium.googlesource.com/chromium/src/+/e144d30..6fdb142/tools/clang/scripts/update.sh
Removes the OVERRIDE macro defined in:
* webrtc/base/common.h
* webrtc/typedefs.h
The majority of the source changes were done by running this in src/:
perl -0pi -e "s/virtual\s([^({;]*(\([^({;]*\)[^({;]*))(OVERRIDE|override)/\1override/sg" `find {talk,webrtc} -name "*.h" -o -name "*.cc*" -o -name "*.mm*"`
which converted all:
virtual Foo() OVERRIDE
functions to:
Foo() override
Then I manually edited:
* talk/media/webrtc/fakewebrtccommon.h
* webrtc/test/fake_common.h
Remaining uses of OVERRIDE was fixed by search+replace.
Manual edits were done to fix virtual destructors that were
overriding inherited ones.
Finally a build error related to the pure virtual definitions of
Read, Write and Rewind in common_types.h required a bit of
refactoring in:
* webrtc/common_types.cc
* webrtc/common_types.h
* webrtc/system_wrappers/interface/file_wrapper.h
* webrtc/system_wrappers/source/file_impl.cc
This roll should make it possible for us to finally re-enable deadlock
detection for TSan on the buildbots.
BUG=4106
R=pbos@webrtc.org, tommi@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/41069004
Cr-Commit-Position: refs/heads/master@{#8596}
git-svn-id: http://webrtc.googlecode.com/svn/trunk@8596 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/DEPS b/DEPS
index acd5719..6a678d9 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 d351b2a..750f272 100644
--- a/talk/app/webrtc/audiotrack.h
+++ b/talk/app/webrtc/audiotrack.h
@@ -42,21 +42,20 @@
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<AudioProcessorInterface> 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<AudioProcessorInterface> 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 8227272..e22805f 100644
--- a/talk/app/webrtc/audiotrackrenderer.h
+++ b/talk/app/webrtc/audiotrackrenderer.h
@@ -47,8 +47,8 @@
~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 188b0e3..ec9a36e 100644
--- a/talk/app/webrtc/dtmfsender.h
+++ b/talk/app/webrtc/dtmfsender.h
@@ -78,15 +78,16 @@
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 861a695..64f43e4 100644
--- a/talk/app/webrtc/dtmfsender_unittest.cc
+++ b/talk/app/webrtc/dtmfsender_unittest.cc
@@ -50,7 +50,7 @@
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 @@
}
// 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 9149f2c..e6717db 100644
--- a/talk/app/webrtc/java/jni/androidvideocapturer_jni.h
+++ b/talk/app/webrtc/java/jni/androidvideocapturer_jni.h
@@ -57,7 +57,7 @@
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 8f5e7f2..f269858 100644
--- a/talk/app/webrtc/java/jni/peerconnection_jni.cc
+++ b/talk/app/webrtc/java/jni/peerconnection_jni.cc
@@ -212,7 +212,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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<Pair<String, String>> to a Constraints.
@@ -493,7 +489,7 @@
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 @@
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 @@
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 @@
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 @@
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<char*>(buffer.data.data()),
@@ -628,7 +624,7 @@
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 @@
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 @@
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 cbe6712..240512d 100644
--- a/talk/app/webrtc/mediastream.h
+++ b/talk/app/webrtc/mediastream.h
@@ -42,19 +42,19 @@
public:
static rtc::scoped_refptr<MediaStream> 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<AudioTrackInterface>
FindAudioTrack(const std::string& track_id);
virtual rtc::scoped_refptr<VideoTrackInterface>
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 ef858e5..801648d 100644
--- a/talk/app/webrtc/mediastreamhandler.h
+++ b/talk/app/webrtc/mediastreamhandler.h
@@ -78,12 +78,14 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 e3126f8..07b90d9 100644
--- a/talk/app/webrtc/objc/RTCDataChannel.mm
+++ b/talk/app/webrtc/objc/RTCDataChannel.mm
@@ -39,11 +39,11 @@
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 65f3bc6..c529f5a 100644
--- a/talk/app/webrtc/objc/RTCMediaStreamTrack.mm
+++ b/talk/app/webrtc/objc/RTCMediaStreamTrack.mm
@@ -38,7 +38,7 @@
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 a06a892..769219e 100644
--- a/talk/app/webrtc/objc/RTCPeerConnection.mm
+++ b/talk/app/webrtc/objc/RTCPeerConnection.mm
@@ -62,7 +62,7 @@
_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 @@
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 @@
_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 @@
_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 fd09d0a..9b981b9 100644
--- a/talk/app/webrtc/objc/RTCPeerConnectionObserver.h
+++ b/talk/app/webrtc/objc/RTCPeerConnectionObserver.h
@@ -42,31 +42,31 @@
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 0188088..99cb128 100644
--- a/talk/app/webrtc/objc/RTCVideoRendererAdapter.mm
+++ b/talk/app/webrtc/objc/RTCVideoRendererAdapter.mm
@@ -40,11 +40,11 @@
_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 9b4c2b7..bea9c2f 100644
--- a/talk/app/webrtc/peerconnection.h
+++ b/talk/app/webrtc/peerconnection.h
@@ -118,34 +118,30 @@
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 78245fc..76a5c1e 100644
--- a/talk/app/webrtc/proxy.h
+++ b/talk/app/webrtc/proxy.h
@@ -312,72 +312,70 @@
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<c##Proxy, void> call(this, &c##Proxy::Release_s);\
- call.Marshal(owner_thread_);\
- }\
- public:\
- static rtc::scoped_refptr<C> Create(rtc::Thread* thread, \
- C* c) {\
- return new rtc::RefCountedObject<c##Proxy>(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<c##Proxy, void> call(this, &c##Proxy::Release_s); \
+ call.Marshal(owner_thread_); \
+ } \
+ \
+ public: \
+ static rtc::scoped_refptr<C> Create(rtc::Thread* thread, C* c) { \
+ return new rtc::RefCountedObject<c##Proxy>(thread, c); \
+ }
-#define PROXY_METHOD0(r, method)\
- r method() OVERRIDE {\
- MethodCall0<C, r> call(c_.get(), &C::method);\
- return call.Marshal(owner_thread_);\
- }\
+#define PROXY_METHOD0(r, method) \
+ r method() override { \
+ MethodCall0<C, r> call(c_.get(), &C::method); \
+ return call.Marshal(owner_thread_); \
+ }
-#define PROXY_CONSTMETHOD0(r, method)\
- r method() const OVERRIDE {\
- ConstMethodCall0<C, r> call(c_.get(), &C::method);\
- return call.Marshal(owner_thread_);\
- }\
+#define PROXY_CONSTMETHOD0(r, method) \
+ r method() const override { \
+ ConstMethodCall0<C, r> call(c_.get(), &C::method); \
+ return call.Marshal(owner_thread_); \
+ }
-#define PROXY_METHOD1(r, method, t1)\
- r method(t1 a1) OVERRIDE {\
- MethodCall1<C, r, t1> call(c_.get(), &C::method, a1);\
- return call.Marshal(owner_thread_);\
- }\
+#define PROXY_METHOD1(r, method, t1) \
+ r method(t1 a1) override { \
+ MethodCall1<C, r, t1> call(c_.get(), &C::method, a1); \
+ return call.Marshal(owner_thread_); \
+ }
-#define PROXY_CONSTMETHOD1(r, method, t1)\
- r method(t1 a1) const OVERRIDE {\
- ConstMethodCall1<C, r, t1> call(c_.get(), &C::method, a1);\
- return call.Marshal(owner_thread_);\
- }\
+#define PROXY_CONSTMETHOD1(r, method, t1) \
+ r method(t1 a1) const override { \
+ ConstMethodCall1<C, r, t1> 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<C, r, t1, t2> 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<C, r, t1, t2> 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<C, r, t1, t2, t3> 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<C, r, t1, t2, t3> 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<C, r, t1, t2, t3, t4> 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<C, r, t1, t2, t3, t4> 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<C, r, t1, t2, t3, t4, t5> 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<C, r, t1, t2, t3, t4, t5> 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 b05ed3d..e49aca5 100644
--- a/talk/app/webrtc/remoteaudiosource.h
+++ b/talk/app/webrtc/remoteaudiosource.h
@@ -51,12 +51,12 @@
typedef std::list<AudioObserver*> 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 b11d91d..1bb4d07 100644
--- a/talk/app/webrtc/remotevideocapturer.h
+++ b/talk/app/webrtc/remotevideocapturer.h
@@ -47,14 +47,14 @@
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<uint32>* 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<uint32>* 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 373c127..e7a9664 100644
--- a/talk/app/webrtc/statscollector_unittest.cc
+++ b/talk/app/webrtc/statscollector_unittest.cc
@@ -113,8 +113,7 @@
~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 @@
explicit FakeAudioTrack(const std::string& id)
: webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(id),
processor_(new rtc::RefCountedObject<FakeAudioProcessor>()) {}
- 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<webrtc::AudioProcessorInterface>
- GetAudioProcessor() OVERRIDE {
+ rtc::scoped_refptr<webrtc::AudioProcessorInterface> GetAudioProcessor()
+ override {
return processor_;
}
diff --git a/talk/app/webrtc/test/fakeaudiocapturemodule.h b/talk/app/webrtc/test/fakeaudiocapturemodule.h
index 1c54a04..57c1e58 100644
--- a/talk/app/webrtc/test/fakeaudiocapturemodule.h
+++ b/talk/app/webrtc/test/fakeaudiocapturemodule.h
@@ -76,133 +76,129 @@
// 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 75de524..41d6737 100644
--- a/talk/app/webrtc/test/fakedatachannelprovider.h
+++ b/talk/app/webrtc/test/fakedatachannelprovider.h
@@ -36,9 +36,9 @@
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 @@
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 @@
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 @@
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 2935c09..d6e92b0 100644
--- a/talk/app/webrtc/videosource.cc
+++ b/talk/app/webrtc/videosource.cc
@@ -305,11 +305,9 @@
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 4f37340..7b4d1f4 100644
--- a/talk/app/webrtc/webrtcsession.h
+++ b/talk/app/webrtc/webrtcsession.h
@@ -180,21 +180,23 @@
// 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 @@
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<DataChannel> 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 f253927..b23ba54 100644
--- a/talk/app/webrtc/webrtcsession_unittest.cc
+++ b/talk/app/webrtc/webrtcsession_unittest.cc
@@ -154,12 +154,11 @@
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 @@
[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 @@
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 626d6ec..c7b52c4 100644
--- a/talk/media/base/fakemediaengine.h
+++ b/talk/media/base/fakemediaengine.h
@@ -432,14 +432,12 @@
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 4e86707..96fff42 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 e86b423..93406cd 100644
--- a/talk/media/webrtc/fakewebrtcvideocapturemodule.h
+++ b/talk/media/webrtc/fakewebrtcvideocapturemodule.h
@@ -46,73 +46,63 @@
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 65807fc..bb529e2 100644
--- a/talk/media/webrtc/fakewebrtcvoiceengine.h
+++ b/talk/media/webrtc/fakewebrtcvoiceengine.h
@@ -145,25 +145,15 @@
WEBRTC_STUB(StartDebugRecording, (const char filename[kMaxFilenameSize]));
WEBRTC_STUB(StartDebugRecording, (FILE* handle));
WEBRTC_STUB(StopDebugRecording, ());
- virtual webrtc::EchoCancellation* echo_cancellation() const OVERRIDE {
+ webrtc::EchoCancellation* echo_cancellation() const override { return NULL; }
+ webrtc::EchoControlMobile* echo_control_mobile() 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 {
- 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 @@
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 b4436cd..044fc0e 100644
--- a/talk/media/webrtc/webrtcmediaengine.h
+++ b/talk/media/webrtc/webrtcmediaengine.h
@@ -97,90 +97,83 @@
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<AudioCodec>& audio_codecs() OVERRIDE {
+ const std::vector<AudioCodec>& audio_codecs() override {
return delegate_->audio_codecs();
}
- virtual const std::vector<RtpHeaderExtension>&
- audio_rtp_header_extensions() OVERRIDE {
+ const std::vector<RtpHeaderExtension>& audio_rtp_header_extensions()
+ override {
return delegate_->audio_rtp_header_extensions();
}
- virtual const std::vector<VideoCodec>& video_codecs() OVERRIDE {
+ const std::vector<VideoCodec>& video_codecs() override {
return delegate_->video_codecs();
}
- virtual const std::vector<RtpHeaderExtension>&
- video_rtp_header_extensions() OVERRIDE {
+ const std::vector<RtpHeaderExtension>& 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<VideoCapturer*, CaptureState>&
diff --git a/talk/media/webrtc/webrtcpassthroughrender.h b/talk/media/webrtc/webrtcpassthroughrender.h
index e8e1ed6..bbe225b 100644
--- a/talk/media/webrtc/webrtcpassthroughrender.h
+++ b/talk/media/webrtc/webrtcpassthroughrender.h
@@ -41,139 +41,138 @@
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<uint32_t>(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 d860e48..075a692 100644
--- a/talk/media/webrtc/webrtcvideoengine.cc
+++ b/talk/media/webrtc/webrtcvideoengine.cc
@@ -127,11 +127,11 @@
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 @@
// 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 @@
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 3c2e379..35b34a1 100644
--- a/talk/media/webrtc/webrtcvideoengine.h
+++ b/talk/media/webrtc/webrtcvideoengine.h
@@ -266,43 +266,42 @@
int GetDefaultChannelId() const { return default_channel_id_; }
// VideoMediaChannel implementation
- virtual bool SetRecvCodecs(const std::vector<VideoCodec> &codecs) OVERRIDE;
- virtual bool SetSendCodecs(const std::vector<VideoCodec> &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<VideoCodec>& codecs) override;
+ bool SetSendCodecs(const std::vector<VideoCodec>& 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<RtpHeaderExtension>& extensions) OVERRIDE;
- virtual bool SetSendRtpHeaderExtensions(
- const std::vector<RtpHeaderExtension>& 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<RtpHeaderExtension>& extensions) override;
+ bool SetSendRtpHeaderExtensions(
+ const std::vector<RtpHeaderExtension>& 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 @@
}
// 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 @@
static bool UseSimulcastEncoderFactory(const std::vector<VideoCodec>& codecs);
- virtual webrtc::VideoEncoder* CreateVideoEncoder(
- webrtc::VideoCodecType type) OVERRIDE;
- virtual const std::vector<VideoCodec>& codecs() const OVERRIDE;
- virtual void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) OVERRIDE;
+ webrtc::VideoEncoder* CreateVideoEncoder(
+ webrtc::VideoCodecType type) override;
+ const std::vector<VideoCodec>& 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 b0da327..b5d69c6 100644
--- a/talk/media/webrtc/webrtcvideoengine2.h
+++ b/talk/media/webrtc/webrtcvideoengine2.h
@@ -89,8 +89,7 @@
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 @@
bool Init();
// VideoMediaChannel implementation
- virtual bool SetRecvCodecs(const std::vector<VideoCodec>& codecs) override;
- virtual bool SetSendCodecs(const std::vector<VideoCodec>& 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<VideoCodec>& codecs) override;
+ bool SetSendCodecs(const std::vector<VideoCodec>& 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<RtpHeaderExtension>& extensions) override;
- virtual bool SetSendRtpHeaderExtensions(
+ bool SetSendRtpHeaderExtensions(
const std::vector<RtpHeaderExtension>& 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 @@
void SetRecvCodecs(const std::vector<VideoCodecSettings>& recv_codecs);
void SetRtpExtensions(const std::vector<webrtc::RtpExtension>& 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 @@
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 2967ea6..174c3e9 100644
--- a/talk/media/webrtc/webrtcvideoengine2_unittest.cc
+++ b/talk/media/webrtc/webrtcvideoengine2_unittest.cc
@@ -392,8 +392,7 @@
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 @@
protected:
typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base;
- virtual cricket::VideoCodec DefaultCodec() OVERRIDE { return kVp8Codec; }
+ cricket::VideoCodec DefaultCodec() override { return kVp8Codec; }
};
#define WEBRTC_BASE_TEST(test) \
@@ -923,7 +922,7 @@
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 @@
}
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 @@
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 @@
}
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 cf2539b..1149949 100644
--- a/talk/media/webrtc/webrtcvideoengine2_unittest.h
+++ b/talk/media/webrtc/webrtcvideoengine2_unittest.h
@@ -54,16 +54,16 @@
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 @@
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 @@
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 51f60aa..5557a35
--- a/talk/media/webrtc/webrtcvideoframefactory.h
+++ b/talk/media/webrtc/webrtcvideoframefactory.h
@@ -37,8 +37,9 @@
// 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 80b3be9..20c2e50 100644
--- a/talk/media/webrtc/webrtcvoiceengine.cc
+++ b/talk/media/webrtc/webrtcvoiceengine.cc
@@ -1790,11 +1790,11 @@
// 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 @@
// 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 6dc1f25..b896f21 100644
--- a/talk/media/webrtc/webrtcvoiceengine.h
+++ b/talk/media/webrtc/webrtcvoiceengine.h
@@ -69,8 +69,8 @@
}
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 @@
// 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 @@
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 @@
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 @@
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<int>(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<int>(len) : -1;
}
diff --git a/webrtc/base/common.h b/webrtc/base/common.h
index 2a8ac33..e39b75d 100644
--- a/webrtc/base/common.h
+++ b/webrtc/base/common.h
@@ -183,28 +183,6 @@
#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 03053ad..3c49631 100644
--- a/webrtc/base/thread_checker_unittest.cc
+++ b/webrtc/base/thread_checker_unittest.cc
@@ -61,9 +61,7 @@
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 @@
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 6b97ed9..9e99886 100644
--- a/webrtc/common_audio/blocker_unittest.cc
+++ b/webrtc/common_audio/blocker_unittest.cc
@@ -17,11 +17,11 @@
// 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 @@
// 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 f1a3baa..c651235 100644
--- a/webrtc/common_audio/fir_filter.cc
+++ b/webrtc/common_audio/fir_filter.cc
@@ -25,7 +25,7 @@
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 9301109..d7399ad 100644
--- a/webrtc/common_audio/fir_filter_neon.h
+++ b/webrtc/common_audio/fir_filter_neon.h
@@ -23,7 +23,7 @@
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 4e67b04..d396831 100644
--- a/webrtc/common_audio/fir_filter_sse.h
+++ b/webrtc/common_audio/fir_filter_sse.h
@@ -23,7 +23,7 @@
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 7e9fe75..d6b8ce3 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 @@
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 bffc3ee..73afa43 100644
--- a/webrtc/common_types.cc
+++ b/webrtc/common_types.cc
@@ -12,11 +12,19 @@
#include <string.h>
+#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 fbf9a6d..bdba653 100644
--- a/webrtc/common_types.h
+++ b/webrtc/common_types.h
@@ -56,6 +56,8 @@
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 @@
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 c2a9ce3..03e7ba0 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 @@
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 @@
// 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 2f51676..1d3c2f3 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 @@
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 903b220..3967c5e 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 @@
: 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 @@
: 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 @@
: 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 65a0d4b..229c06e 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 @@
};
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 25c397a..fc3aa0d 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 @@
};
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 38d5903..c918eaf 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 @@
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 d93fae3..bb76257 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 @@
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 93aca6c..417faf8 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 @@
};
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 ebe4a35..b39de49 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 @@
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 a5a040f..99ecd24 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 @@
: 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 beea1cf..39f1615 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 @@
// 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 b3a76a5..ea3ad43 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 @@
.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 63c35e4..5e5ff9a 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 @@
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 2eb1bf9..602c31a 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 @@
~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 @@
rtp_header_.type.Audio.isCNG = false;
}
- virtual void TearDown() OVERRIDE {
- }
+ void TearDown() override {}
void InsertOnePacketOfSilence(int codec_id) {
CodecInst codec;
@@ -115,13 +114,12 @@
}
}
- 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 e9096ff..aeacc06 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 @@
~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 @@
rtp_header_.type.Audio.isCNG = false;
}
- virtual void TearDown() OVERRIDE {
- }
+ void TearDown() override {}
void InsertOnePacketOfSilence(int codec_id) {
CodecInst codec;
@@ -115,13 +114,12 @@
}
}
- 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 769a327..4c4db5b 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 @@
// 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 05a29df..52cb415 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 @@
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 10423a7..ef69ba5 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 @@
//
// 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 @@
// (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 @@
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<uint16_t> GetNackList(
- int64_t round_trip_time_ms) const OVERRIDE;
+ std::vector<uint16_t> 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 @@
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<uint16_t> GetNackList(
- int round_trip_time_ms) const OVERRIDE;
+ std::vector<uint16_t> 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 b37ef9d..8527767 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 @@
: 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 @@
~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 @@
config_.clock = fake_clock_.get();
}
- virtual void SetUp() OVERRIDE {
+ void SetUp() override {
AudioCodingModuleTest::SetUp();
CreateAcm();
StartThreads();
@@ -321,7 +320,7 @@
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 @@
~AcmIsacMtTest() {}
- virtual void SetUp() OVERRIDE {
+ void SetUp() override {
AudioCodingModuleTest::SetUp();
CreateAcm();
@@ -459,7 +458,7 @@
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 @@
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 @@
&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 @@
// 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 122d027..14a73fd 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 @@
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 @@
// 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 @@
}
// 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 55167d3..c4ad7d1 100644
--- a/webrtc/modules/audio_coding/main/test/Channel.h
+++ b/webrtc/modules/audio_coding/main/test/Channel.h
@@ -50,13 +50,12 @@
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 4ee4fa2..44fb0b2 100644
--- a/webrtc/modules/audio_coding/main/test/EncodeDecodeTest.h
+++ b/webrtc/modules/audio_coding/main/test/EncodeDecodeTest.h
@@ -29,13 +29,12 @@
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 @@
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 70fa9ff..d25dea2 100644
--- a/webrtc/modules/audio_coding/main/test/PacketLossTest.h
+++ b/webrtc/modules/audio_coding/main/test/PacketLossTest.h
@@ -23,7 +23,8 @@
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 9a2d43a..346440b 100644
--- a/webrtc/modules/audio_coding/main/test/RTPFile.h
+++ b/webrtc/modules/audio_coding/main/test/RTPFile.h
@@ -65,14 +65,19 @@
~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 @@
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 4292d77..1cdc0cb 100644
--- a/webrtc/modules/audio_coding/main/test/TestAllCodecs.h
+++ b/webrtc/modules/audio_coding/main/test/TestAllCodecs.h
@@ -28,13 +28,12 @@
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 @@
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 89914cc..c6412c7 100644
--- a/webrtc/modules/audio_coding/main/test/TestStereo.h
+++ b/webrtc/modules/audio_coding/main/test/TestStereo.h
@@ -35,13 +35,12 @@
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 @@
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 2da9993..6e3aa46 100644
--- a/webrtc/modules/audio_coding/neteq/accelerate.h
+++ b/webrtc/modules/audio_coding/neteq/accelerate.h
@@ -49,16 +49,18 @@
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 7d36a39..7e80a36 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 @@
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 01a948f..97c481d 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 @@
// 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 8a382e9..28e901e 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 @@
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 b82b43e..ac4689b 100644
--- a/webrtc/modules/audio_coding/neteq/neteq_impl.h
+++ b/webrtc/modules/audio_coding/neteq/neteq_impl.h
@@ -79,10 +79,10 @@
// 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 @@
// 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 @@
// 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<int>* waiting_times) OVERRIDE;
+ void WaitingTimes(std::vector<int>* 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 9f09c94..1ac6c9a 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 b672a0c..7abf5a1 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 @@
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 e1f53af..55ef0c7 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 @@
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 173713a..b4a6a81 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 @@
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 474ec1c..b7b3ed1 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 @@
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 fcf4f13..b780fbf 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 @@
// 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 6207fde..cb40b1c 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 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 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 @@
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 1d61280..ff30f67 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 @@
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 1f72162..1b1ed42 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 @@
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 70b5216..d711685 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 @@
// 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 2280436..e09f6e4 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 @@
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 c9cc6ef..b9be6c6 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 @@
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 e3367f2..b1a812a 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 @@
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 010d643..294d3ba 100644
--- a/webrtc/modules/audio_device/audio_device_impl.h
+++ b/webrtc/modules/audio_device/audio_device_impl.h
@@ -43,8 +43,8 @@
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 @@
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 41e52e9..75c599e 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 @@
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 e05e30b..90aa6c2 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 @@
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 6f417eb..14936f5 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 @@
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 1d75c8e..d5be88c 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 @@
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 cde7e46..1644df9 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 @@
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 0dc2646..f29e211 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 @@
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 5029bc7..200aa8b 100644
--- a/webrtc/modules/audio_processing/audio_processing_impl.cc
+++ b/webrtc/modules/audio_processing/audio_processing_impl.cc
@@ -75,60 +75,49 @@
}
// 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 d82ef02..68abdf6 100644
--- a/webrtc/modules/audio_processing/audio_processing_impl.h
+++ b/webrtc/modules/audio_processing/audio_processing_impl.h
@@ -91,57 +91,55 @@
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 4545938..ed3d7b5 100644
--- a/webrtc/modules/audio_processing/echo_cancellation_impl.h
+++ b/webrtc/modules/audio_processing/echo_cancellation_impl.h
@@ -30,39 +30,40 @@
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 4f5b593..f399f48 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 @@
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 8115987..d648943 100644
--- a/webrtc/modules/audio_processing/gain_control_impl.h
+++ b/webrtc/modules/audio_processing/gain_control_impl.h
@@ -33,36 +33,36 @@
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 6f91f3b..90b393e 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 @@
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 b38337d..0d0050c 100644
--- a/webrtc/modules/audio_processing/level_estimator_impl.h
+++ b/webrtc/modules/audio_processing/level_estimator_impl.h
@@ -30,20 +30,20 @@
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 14abe66..33a0e06 100644
--- a/webrtc/modules/audio_processing/noise_suppression_impl.h
+++ b/webrtc/modules/audio_processing/noise_suppression_impl.h
@@ -30,22 +30,22 @@
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 1dfdf20..32f031e 100644
--- a/webrtc/modules/audio_processing/voice_detection_impl.h
+++ b/webrtc/modules/audio_processing/voice_detection_impl.h
@@ -28,28 +28,28 @@
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 586d8da..477276b 100644
--- a/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc
+++ b/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc
@@ -27,14 +27,13 @@
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 1646f75..f089be9 100644
--- a/webrtc/modules/bitrate_controller/bitrate_controller_impl.h
+++ b/webrtc/modules/bitrate_controller/bitrate_controller_impl.h
@@ -32,23 +32,23 @@
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 7ce99a1..834ec5f 100644
--- a/webrtc/modules/bitrate_controller/remb_suppressor_unittest.cc
+++ b/webrtc/modules/bitrate_controller/remb_suppressor_unittest.cc
@@ -20,7 +20,7 @@
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 4c30066..e0f598c 100644
--- a/webrtc/modules/desktop_capture/cropping_window_capturer.h
+++ b/webrtc/modules/desktop_capture/cropping_window_capturer.h
@@ -28,19 +28,19 @@
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 fc1858e..deffe66 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 @@
: 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 d402486..b16cf45 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 @@
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<DesktopCapturer> desktop_capturer_;
rtc::scoped_ptr<MouseCursorMonitor> 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 f1129ab..7fdfa1c 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 @@
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 @@
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<DesktopFrame> image(
new BasicDesktopFrame(DesktopSize(kCursorWidth, kCursorHeight)));
@@ -172,13 +168,9 @@
}
// 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 325feae..5a080fa 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 @@
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 36963a9..7238628 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 @@
}
// 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 8421161..3f4991e 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 @@
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 b116474..9b3cc17 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 @@
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 af98e73..93e9a6f 100644
--- a/webrtc/modules/desktop_capture/screen_capturer_mac.mm
+++ b/webrtc/modules/desktop_capture/screen_capturer_mac.mm
@@ -196,11 +196,11 @@
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 c99138d..e3d037b 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 @@
void CaptureDoneCallback2(DesktopFrame* frame);
protected:
- virtual void SetUp() OVERRIDE {
- capturer_.reset(ScreenCapturer::Create());
- }
+ void SetUp() override { capturer_.reset(ScreenCapturer::Create()); }
rtc::scoped_ptr<ScreenCapturer> capturer_;
MockScreenCapturerCallback callback_;
diff --git a/webrtc/modules/desktop_capture/screen_capturer_unittest.cc b/webrtc/modules/desktop_capture/screen_capturer_unittest.cc
index 34eab7e..606c061 100644
--- a/webrtc/modules/desktop_capture/screen_capturer_unittest.cc
+++ b/webrtc/modules/desktop_capture/screen_capturer_unittest.cc
@@ -30,7 +30,7 @@
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 0a758f9..1597e3f 100644
--- a/webrtc/modules/desktop_capture/screen_capturer_x11.cc
+++ b/webrtc/modules/desktop_capture/screen_capturer_x11.cc
@@ -50,18 +50,18 @@
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 34de7de..6014a18 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 @@
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 53caaa2..5bc0f81 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 @@
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 e69fc11..daa9fc7 100644
--- a/webrtc/modules/desktop_capture/window_capturer_mac.mm
+++ b/webrtc/modules/desktop_capture/window_capturer_mac.mm
@@ -50,13 +50,13 @@
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 5f9010d..d9ad0ca 100755
--- a/webrtc/modules/desktop_capture/window_capturer_null.cc
+++ b/webrtc/modules/desktop_capture/window_capturer_null.cc
@@ -24,13 +24,13 @@
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 ac62c96..bb4ddf0 100644
--- a/webrtc/modules/desktop_capture/window_capturer_unittest.cc
+++ b/webrtc/modules/desktop_capture/window_capturer_unittest.cc
@@ -22,22 +22,17 @@
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<WindowCapturer> capturer_;
diff --git a/webrtc/modules/desktop_capture/window_capturer_win.cc b/webrtc/modules/desktop_capture/window_capturer_win.cc
index 5d6bf64..c7e1fd8 100644
--- a/webrtc/modules/desktop_capture/window_capturer_win.cc
+++ b/webrtc/modules/desktop_capture/window_capturer_win.cc
@@ -72,13 +72,13 @@
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 0a90b0c..8dacd46 100755
--- a/webrtc/modules/desktop_capture/window_capturer_x11.cc
+++ b/webrtc/modules/desktop_capture/window_capturer_x11.cc
@@ -92,16 +92,16 @@
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 9b14a86..c5038bb 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 @@
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 efd4217..645999d 100644
--- a/webrtc/modules/pacing/include/paced_sender.h
+++ b/webrtc/modules/pacing/include/paced_sender.h
@@ -121,10 +121,10 @@
// 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 b5aee76..56f1c1a 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 @@
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 de28c9a..9964293 100644
--- a/webrtc/modules/remote_bitrate_estimator/bwe_simulations.cc
+++ b/webrtc/modules/remote_bitrate_estimator/bwe_simulations.cc
@@ -30,7 +30,7 @@
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 1b1862c..d157993 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 @@
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 c20683d..65e5401 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 @@
uint32_t min_bitrate_bps);
virtual ~RemoteBitrateEstimatorAbsSendTimeImpl() {}
- virtual void IncomingPacketFeedbackVector(
- const std::vector<PacketInfo>& packet_feedback_vector) OVERRIDE;
+ void IncomingPacketFeedbackVector(
+ const std::vector<PacketInfo>& 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<unsigned int>* 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<unsigned int>* ssrcs,
+ unsigned int* bitrate_bps) const override;
+ bool GetStats(ReceiveBandwidthEstimatorStats* output) const override;
private:
typedef std::map<unsigned int, int64_t> 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 f9eef2a..72c476d 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 @@
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<unsigned int>* 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<unsigned int>* 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 83cd97f..8da880f 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 @@
TestBitrateObserver() : updated_(false), latest_bitrate_(0) {}
virtual ~TestBitrateObserver() {}
- virtual void OnReceiveBitrateChanged(const std::vector<unsigned int>& ssrcs,
- unsigned int bitrate) OVERRIDE;
+ void OnReceiveBitrateChanged(const std::vector<unsigned int>& 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 c81764e..d1b9ea7 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 @@
}
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 3221d2b..bd22e3e 100644
--- a/webrtc/modules/remote_bitrate_estimator/test/bwe.cc
+++ b/webrtc/modules/remote_bitrate_estimator/test/bwe.cc
@@ -26,12 +26,12 @@
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<int64_t>::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 902e48f..9e893de 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 @@
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 @@
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 18fd978..6d94ea7 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 @@
~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 e5cbbcb..8c13cb1 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 @@
// 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 @@
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<Module*>& modules);
diff --git a/webrtc/modules/rtp_rtcp/interface/receive_statistics.h b/webrtc/modules/rtp_rtcp/interface/receive_statistics.h
index 3bd953f..f7de91f 100644
--- a/webrtc/modules/rtp_rtcp/interface/receive_statistics.h
+++ b/webrtc/modules/rtp_rtcp/interface/receive_statistics.h
@@ -85,20 +85,20 @@
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 76091a1..4938b5f 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 @@
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 @@
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 @@
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 2f4b0fb..24db39b 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 @@
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<CriticalSectionWrapper> 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 e7022b5..e5c4faf 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 @@
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 @@
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 @@
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<const unsigned char*>(data);
uint32_t ssrc = (ptr[8] << 24) + (ptr[9] << 16) + (ptr[10] << 8) + ptr[11];
@@ -146,9 +145,7 @@
return static_cast<int>(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<int>(len);
}
@@ -177,7 +174,7 @@
fake_clock(123456) {}
~RtpRtcpRtxNackTest() {}
- virtual void SetUp() OVERRIDE {
+ void SetUp() override {
RtpRtcp::Configuration configuration;
configuration.id = kTestId;
configuration.audio = false;
@@ -284,9 +281,7 @@
receiver_.sequence_numbers_.sort();
}
- virtual void TearDown() OVERRIDE {
- delete rtp_rtcp_module_;
- }
+ void TearDown() override { delete rtp_rtcp_module_; }
rtc::scoped_ptr<ReceiveStatistics> 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 7828036..cd41744 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 @@
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 @@
~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<uint32_t, StreamStatisticianImpl*> StatisticianImplMap;
diff --git a/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc b/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc
index 7da5285..8b25bcf 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 @@
++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 cb89287..3c1a9a3 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 @@
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 @@
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 0ea98a2..150b5b4 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h
@@ -90,8 +90,9 @@
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 @@
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 @@
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 @@
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 @@
};
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 f90c598..f2ea04b 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 @@
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 @@
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 5563b0d..a35b7c3 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 @@
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 @@
return static_cast<int>(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 ba293c8..4e92895 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 @@
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 @@
// 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 @@
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 2fd6aad..2e7bca5 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 @@
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 @@
// 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 @@
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 dab7921..d73dfc1b 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 @@
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 @@
// 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 @@
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 9a4cb64..0b8280d 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 @@
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<CriticalSectionWrapper> 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 25be1a5..9a98e2a 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 @@
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 @@
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 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 9ca87f6..cd146b9 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 @@
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 @@
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 3b2bbf6..539c226 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 @@
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 c355e80..d617d0a 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 @@
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 2b88aef..4c007eb 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 @@
// 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<uint32_t>& csrcs) OVERRIDE;
+ void SetCsrcs(const std::vector<uint32_t>& 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<RTCPReportBlock>* receive_blocks) const OVERRIDE;
+ int32_t RemoteRTCPStat(
+ std::vector<RTCPReportBlock>* 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<uint32_t>& ssrcs) OVERRIDE;
+ void SetREMBData(uint32_t bitrate,
+ const std::vector<uint32_t>& 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 @@
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 e32a535..e7b58a2 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 @@
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 @@
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<RtpHeaderParser> parser(RtpHeaderParser::Create());
EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data), len, &header));
@@ -74,9 +70,7 @@
last_rtp_header_ = header;
return static_cast<int>(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<const uint8_t*>(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 5f5a71a..e6a912e 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -73,7 +73,7 @@
: 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 1fa46d1..9342e5e 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.h
@@ -81,7 +81,7 @@
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 @@
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 @@
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<uint32_t>& csrcs);
@@ -193,28 +193,29 @@
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 8787ad6..f57ee27 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 @@
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<int>(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 @@
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 @@
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 @@
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 @@
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 @@
: 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 77ee6fb..ea8ac98 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc
@@ -32,15 +32,15 @@
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 30a84c9..9ebc5a5 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h
@@ -69,43 +69,38 @@
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 {}
+ 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 {}
// 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;
+ 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;
/////////////////////////////////
// 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 d265c86..6b4e55d 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 @@
}
~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 677d3b1..069cdc7 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 @@
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 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 c8b83d3..61923aa 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 @@
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 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 @@
}
~RtpRtcpAudioTest() {}
- virtual void SetUp() OVERRIDE {
+ void SetUp() override {
audioFeedback = new NullRtpAudioFeedback();
data_receiver1 = new VerifyingAudioReceiver();
data_receiver2 = new VerifyingAudioReceiver();
@@ -133,7 +132,7 @@
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 a821246..57eada1 100644
--- a/webrtc/modules/utility/source/coder.h
+++ b/webrtc/modules/utility/source/coder.h
@@ -42,13 +42,12 @@
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<AudioCodingModule> _acm;
diff --git a/webrtc/modules/utility/source/file_player_unittests.cc b/webrtc/modules/utility/source/file_player_unittests.cc
index d430d9f..7ce9d47 100644
--- a/webrtc/modules/utility/source/file_player_unittests.cc
+++ b/webrtc/modules/utility/source/file_player_unittests.cc
@@ -35,7 +35,7 @@
: 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 @@
}
}
- 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 5be9cbe..b49a690 100644
--- a/webrtc/modules/utility/source/rtp_dump_impl.h
+++ b/webrtc/modules/utility/source/rtp_dump_impl.h
@@ -22,11 +22,11 @@
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 476e919..e10db4a 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 @@
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 ff8345f..1afcbad 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 @@
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 7fef060..f115907 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 @@
//
// 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 @@
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK.
// <0 - Error
- virtual int Encode(
- const I420VideoFrame& inputImage,
- const CodecSpecificInfo* /*codecSpecificInfo*/,
- const std::vector<VideoFrameType>* /*frame_types*/) OVERRIDE;
+ int Encode(const I420VideoFrame& inputImage,
+ const CodecSpecificInfo* /*codecSpecificInfo*/,
+ const std::vector<VideoFrameType>* /*frame_types*/) override;
// Register an encode complete callback object.
//
@@ -59,26 +58,22 @@
// - 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 @@
//
// 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 @@
//
// 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 @@
// - 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 3cf7233..5a1654a 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 @@
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 fcd5064..082712d 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 @@
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<double> random_results_;
diff --git a/webrtc/modules/video_coding/codecs/test/videoprocessor.h b/webrtc/modules/video_coding/codecs/test/videoprocessor.h
index b092363..63d7363 100644
--- a/webrtc/modules/video_coding/codecs/test/videoprocessor.h
+++ b/webrtc/modules/video_coding/codecs/test/videoprocessor.h
@@ -163,8 +163,8 @@
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 @@
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 @@
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 @@
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 fdf378f..40677bb 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 @@
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 2d8a47d..d185d15 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 @@
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<VideoFrameType>* 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<VideoFrameType>* 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 762c507..2c2a323 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 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 b2029b1..4925b93 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 @@
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 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 414b3a7..f701481 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 @@
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 9d46d0d..019e73e 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 @@
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<VideoFrameType>* frame_types) OVERRIDE;
+ int Encode(const I420VideoFrame& input_image,
+ const CodecSpecificInfo* codec_specific_info,
+ const std::vector<VideoFrameType>* 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 @@
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 ff2ab93..4f86153 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 @@
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 @@
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 @@
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 @@
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 6666e4b..de596d8 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 @@
class EmptyFrameGenerator : public FrameGenerator {
public:
- virtual I420VideoFrame* NextFrame() OVERRIDE {
+ I420VideoFrame* NextFrame() override {
frame_.reset(new I420VideoFrame());
return frame_.get();
}
@@ -86,10 +86,10 @@
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 @@
// 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 @@
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 @@
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 @@
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 3b3ddce..9b041ce 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 @@
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 @@
{
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 78d73e2..c76736e 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 @@
// 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 b2fb387..0015171 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 @@
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 @@
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 de1eb63..eb0a35a 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 @@
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 3fe991a..3d3c543 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 @@
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 @@
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 @@
_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 @@
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 @@
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 @@
class KeyFrameReqTest: public VCMFrameTypeCallback
{
public:
- virtual int32_t RequestKeyFrame() OVERRIDE;
+ int32_t RequestKeyFrame() override;
};
@@ -222,8 +221,8 @@
{
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 @@
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 3f2d609..e8dbe8d 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 @@
}
// 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 a4425af..fb6770b 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 @@
/**
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 69dcec4..14a9e54 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 @@
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 600615f..15dfd92 100644
--- a/webrtc/modules/video_render/include/video_render.h
+++ b/webrtc/modules/video_render/include/video_render.h
@@ -52,8 +52,8 @@
*/
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 53020b6..2d635a7 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 @@
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 7e3029c..7fb46bf 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 @@
~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 @@
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 6f43b65..f942487 100644
--- a/webrtc/p2p/base/fakesession.h
+++ b/webrtc/p2p/base/fakesession.h
@@ -295,7 +295,7 @@
}
}
- 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 a2a8b6f..1911a0b 100644
--- a/webrtc/p2p/base/teststunserver.h
+++ b/webrtc/p2p/base/teststunserver.h
@@ -39,7 +39,7 @@
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 4da3203..a103d951 100644
--- a/webrtc/system_wrappers/interface/clock.h
+++ b/webrtc/system_wrappers/interface/clock.h
@@ -53,22 +53,21 @@
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 a618634..8f4e09f 100644
--- a/webrtc/system_wrappers/interface/file_wrapper.h
+++ b/webrtc/system_wrappers/interface/file_wrapper.h
@@ -66,20 +66,11 @@
// 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 8e69652..a7f261a 100644
--- a/webrtc/system_wrappers/source/clock.cc
+++ b/webrtc/system_wrappers/source/clock.cc
@@ -36,19 +36,18 @@
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 @@
}
// 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 @@
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 @@
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 a014a3b..b29e116 100644
--- a/webrtc/system_wrappers/source/condition_variable_posix.h
+++ b/webrtc/system_wrappers/source/condition_variable_posix.h
@@ -21,13 +21,13 @@
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 a5ec367..d71c93d 100644
--- a/webrtc/system_wrappers/source/critical_section_posix.h
+++ b/webrtc/system_wrappers/source/critical_section_posix.h
@@ -21,10 +21,10 @@
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 6561aa1..7512c88 100644
--- a/webrtc/system_wrappers/source/event_posix.h
+++ b/webrtc/system_wrappers/source/event_posix.h
@@ -29,13 +29,13 @@
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 eb199a8..dfb1388 100644
--- a/webrtc/system_wrappers/source/file_impl.cc
+++ b/webrtc/system_wrappers/source/file_impl.cc
@@ -19,6 +19,7 @@
#include <string.h>
#endif
+#include "webrtc/base/checks.h"
#include "webrtc/system_wrappers/interface/rw_lock_wrapper.h"
namespace webrtc {
@@ -269,4 +270,9 @@
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 26e9d4d..e6679aa 100644
--- a/webrtc/system_wrappers/source/file_impl.h
+++ b/webrtc/system_wrappers/source/file_impl.h
@@ -23,31 +23,30 @@
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 dd69f52..653564c 100644
--- a/webrtc/system_wrappers/source/rw_lock_generic.h
+++ b/webrtc/system_wrappers/source/rw_lock_generic.h
@@ -22,13 +22,13 @@
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 6ce2b2d..bec3c2d 100644
--- a/webrtc/system_wrappers/source/rw_lock_posix.h
+++ b/webrtc/system_wrappers/source/rw_lock_posix.h
@@ -21,13 +21,13 @@
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 d1f1a90..9d7c811 100644
--- a/webrtc/system_wrappers/source/scoped_vector_unittest.cc
+++ b/webrtc/system_wrappers/source/scoped_vector_unittest.cc
@@ -73,7 +73,7 @@
// 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 @@
// 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 2f0abc6..89420c6 100644
--- a/webrtc/system_wrappers/source/trace_posix.h
+++ b/webrtc/system_wrappers/source/trace_posix.h
@@ -19,14 +19,13 @@
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 502d613..4771dee 100644
--- a/webrtc/test/call_test.h
+++ b/webrtc/test/call_test.h
@@ -109,7 +109,7 @@
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 @@
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 df22012..77107d9 100644
--- a/webrtc/test/channel_transport/include/channel_transport.h
+++ b/webrtc/test/channel_transport/include/channel_transport.h
@@ -28,15 +28,15 @@
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 @@
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 6971154..5d6b212 100644
--- a/webrtc/test/channel_transport/udp_socket2_win.h
+++ b/webrtc/test/channel_transport/udp_socket2_win.h
@@ -42,35 +42,41 @@
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 478d76b..f41de2f 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 @@
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;
- virtual bool AddSocket(UdpSocketWrapper* s) OVERRIDE;
- virtual bool RemoveSocket(UdpSocketWrapper* s) OVERRIDE;
+ bool AddSocket(UdpSocketWrapper* s) override;
+ 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 15fdca4..6ddf7e5 100644
--- a/webrtc/test/channel_transport/udp_socket_posix.h
+++ b/webrtc/test/channel_transport/udp_socket_posix.h
@@ -33,35 +33,37 @@
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 c367b2f..ab7a1ff 100644
--- a/webrtc/test/channel_transport/udp_transport_impl.cc
+++ b/webrtc/test/channel_transport/udp_transport_impl.cc
@@ -68,12 +68,12 @@
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 65ad095..5dbf5d8 100644
--- a/webrtc/test/channel_transport/udp_transport_impl.h
+++ b/webrtc/test/channel_transport/udp_transport_impl.h
@@ -47,98 +47,89 @@
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 24f6be8..eed4498 100644
--- a/webrtc/test/configurable_frame_size_encoder.h
+++ b/webrtc/test/configurable_frame_size_encoder.h
@@ -24,28 +24,26 @@
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<VideoFrameType>* frame_types)
- OVERRIDE;
+ int32_t Encode(const I420VideoFrame& input_image,
+ const CodecSpecificInfo* codec_specific_info,
+ const std::vector<VideoFrameType>* 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 b9fd454..338be75 100644
--- a/webrtc/test/direct_transport.h
+++ b/webrtc/test/direct_transport.h
@@ -39,8 +39,8 @@
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 ce5231e..6df53e9 100644
--- a/webrtc/test/fake_audio_device.h
+++ b/webrtc/test/fake_audio_device.h
@@ -33,12 +33,12 @@
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 a074808..ec81798 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 2cb28ca..096b9c2 100644
--- a/webrtc/test/fake_encoder.h
+++ b/webrtc/test/fake_encoder.h
@@ -28,20 +28,17 @@
// 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<VideoFrameType>* 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<VideoFrameType>* 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 @@
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 @@
DelayedEncoder(Clock* clock, int delay_ms);
virtual ~DelayedEncoder() {}
- virtual int32_t Encode(
- const I420VideoFrame& input_image,
- const CodecSpecificInfo* codec_specific_info,
- const std::vector<VideoFrameType>* frame_types) OVERRIDE;
+ int32_t Encode(const I420VideoFrame& input_image,
+ const CodecSpecificInfo* codec_specific_info,
+ const std::vector<VideoFrameType>* frame_types) override;
private:
const int delay_ms_;
diff --git a/webrtc/test/frame_generator.cc b/webrtc/test/frame_generator.cc
index fe6b1b1..71be89e 100644
--- a/webrtc/test/frame_generator.cc
+++ b/webrtc/test/frame_generator.cc
@@ -28,7 +28,7 @@
assert(height > 0);
}
- virtual I420VideoFrame* NextFrame() OVERRIDE {
+ I420VideoFrame* NextFrame() override {
frame_.CreateEmptyFrame(static_cast<int>(width_),
static_cast<int>(height_),
static_cast<int>(width_),
@@ -77,7 +77,7 @@
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 69b9f5f..1064a5f 100644
--- a/webrtc/test/frame_generator_capturer.h
+++ b/webrtc/test/frame_generator_capturer.h
@@ -42,8 +42,8 @@
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 c2110b2..b712f25 100644
--- a/webrtc/test/gl/gl_renderer.h
+++ b/webrtc/test/gl/gl_renderer.h
@@ -26,8 +26,8 @@
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 8def121..6d9e4e6 100644
--- a/webrtc/test/linux/glx_renderer.h
+++ b/webrtc/test/linux/glx_renderer.h
@@ -26,9 +26,8 @@
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 330fd04..6237709 100644
--- a/webrtc/test/mac/video_renderer_mac.h
+++ b/webrtc/test/mac/video_renderer_mac.h
@@ -27,8 +27,8 @@
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 e8d4d10..b80f751b 100644
--- a/webrtc/test/null_transport.h
+++ b/webrtc/test/null_transport.h
@@ -19,8 +19,8 @@
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 34290ac..26151bb 100644
--- a/webrtc/test/rtp_file_reader.cc
+++ b/webrtc/test/rtp_file_reader.cc
@@ -168,7 +168,7 @@
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 @@
}
}
- bool Init(const std::string& filename) OVERRIDE {
+ bool Init(const std::string& filename) override {
return Initialize(filename) == kResultSuccess;
}
@@ -334,7 +334,7 @@
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 1b9bfdc..4acaa27 100644
--- a/webrtc/test/rtp_file_writer.cc
+++ b/webrtc/test/rtp_file_writer.cc
@@ -38,7 +38,7 @@
}
}
- virtual bool WritePacket(const RtpPacket* packet) OVERRIDE {
+ bool WritePacket(const RtpPacket* packet) override {
uint16_t len = static_cast<uint16_t>(packet->length + kPacketHeaderSize);
CHECK_GE(packet->original_length, packet->length);
uint16_t plen = static_cast<uint16_t>(packet->original_length);
diff --git a/webrtc/test/rtp_rtcp_observer.h b/webrtc/test/rtp_rtcp_observer.h
index 37451f4..dd731f0 100644
--- a/webrtc/test/rtp_rtcp_observer.h
+++ b/webrtc/test/rtp_rtcp_observer.h
@@ -127,7 +127,7 @@
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 @@
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 4ee90f9..9b50ec7 100644
--- a/webrtc/test/testsupport/frame_reader.h
+++ b/webrtc/test/testsupport/frame_reader.h
@@ -54,12 +54,12 @@
// 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 daa3894..8a6b1c2 100644
--- a/webrtc/test/testsupport/frame_writer.h
+++ b/webrtc/test/testsupport/frame_writer.h
@@ -52,11 +52,11 @@
// 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 1220834..88f1811 100644
--- a/webrtc/test/testsupport/trace_to_stderr.h
+++ b/webrtc/test/testsupport/trace_to_stderr.h
@@ -28,7 +28,7 @@
// 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 @@
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 dde3edc..1cb5b4e 100644
--- a/webrtc/test/vcm_capturer.h
+++ b/webrtc/test/vcm_capturer.h
@@ -24,13 +24,12 @@
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 447b5b7..03c4948 100644
--- a/webrtc/test/video_renderer.cc
+++ b/webrtc/test/video_renderer.cc
@@ -17,9 +17,9 @@
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 7cf4982..4fa6c7e 100644
--- a/webrtc/test/win/d3d_renderer.h
+++ b/webrtc/test/win/d3d_renderer.h
@@ -27,9 +27,8 @@
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 f016b17..48640df 100644
--- a/webrtc/tools/simple_command_line_parser_unittest.cc
+++ b/webrtc/tools/simple_command_line_parser_unittest.cc
@@ -16,7 +16,7 @@
class CommandLineParserTest : public ::testing::Test {
protected:
- virtual void SetUp() {
+ void SetUp() override {
parser_ = new CommandLineParser();
test_flags_length_ = 3;
@@ -29,7 +29,7 @@
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 51d8992..8bcaa88 100644
--- a/webrtc/typedefs.h
+++ b/webrtc/typedefs.h
@@ -74,28 +74,6 @@
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 872ee4a..bf0f1af 100644
--- a/webrtc/video/bitrate_estimator_tests.cc
+++ b/webrtc/video/bitrate_estimator_tests.cc
@@ -67,9 +67,7 @@
: 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 984f529..bf80ee5 100644
--- a/webrtc/video/call.cc
+++ b/webrtc/video/call.cc
@@ -83,12 +83,12 @@
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 @@
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 9edd55d..9f3dbf2 100644
--- a/webrtc/video/call_perf_tests.cc
+++ b/webrtc/video/call_perf_tests.cc
@@ -63,7 +63,7 @@
: 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 @@
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 @@
}
}
- virtual bool IsTextureSupported() const override { return false; }
+ bool IsTextureSupported() const override { return false; }
private:
Clock* const clock_;
@@ -198,8 +198,8 @@
: 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 @@
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 @@
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 @@
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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
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 @@
return send_transport_receiver_->DeliverPacket(packet, length);
}
- virtual void OnStreamsCreated(
+ void OnStreamsCreated(
VideoSendStream* send_stream,
- const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
+ const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
if (pad_to_min_bitrate_) {
encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps;
} else {
@@ -579,7 +575,7 @@
}
}
- virtual void PerformTest() OVERRIDE {
+ void PerformTest() override {
EXPECT_EQ(kEventSignaled, Wait())
<< "Timeout while waiting for send-bitrate stats.";
}
@@ -613,9 +609,9 @@
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 @@
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 @@
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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
encoder_config_ = *encoder_config;
}
- virtual void OnStreamsCreated(
+ void OnStreamsCreated(
VideoSendStream* send_stream,
- const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
+ const std::vector<VideoReceiveStream*>& 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 c054645..a8f6f09 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -59,12 +59,12 @@
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 @@
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 @@
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 @@
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 @@
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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
(*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<webrtc::VideoEncoder> encoder_;
@@ -291,15 +290,14 @@
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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
(*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 @@
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 @@
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 @@
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 @@
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 @@
return SEND_PACKET;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
: 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 @@
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 @@
observation_complete_->Set();
}
- virtual bool IsTextureSupported() const override { return false; }
+ bool IsTextureSupported() const override { return false; }
enum {
kFirstPacket,
@@ -522,10 +517,9 @@
kDropNextMediaPacket,
} state_;
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
(*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 @@
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 @@
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 @@
return SEND_PACKET;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
(*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 @@
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 @@
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 @@
}
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
}
}
- virtual void PerformTest() override {
+ void PerformTest() override {
EXPECT_EQ(kEventSignaled, Wait())
<< "Timed out while waiting for retransmission to render.";
}
@@ -763,15 +754,15 @@
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<EventWrapper> event_;
@@ -873,7 +864,7 @@
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 @@
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 @@
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 @@
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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
}
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 @@
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 @@
return SEND_PACKET;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
return SEND_PACKET;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
}
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 @@
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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
encoder_config->streams.resize(1);
}
- virtual void OnStreamsCreated(
+ void OnStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& 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 @@
: EndToEndTest(kDefaultTimeoutMs),
FakeEncoder(Clock::GetRealTimeClock()) {}
- virtual void OnStreamsCreated(
+ void OnStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
}
@@ -1636,28 +1616,27 @@
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 @@
return config;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
}
}
- 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<VideoReceiveStream*>& 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 @@
sent_rtp_(0) {}
private:
- virtual void OnStreamsCreated(
+ void OnStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& 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 @@
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 @@
}
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 @@
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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
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 @@
}
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 @@
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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
WaitForPacketsOrSilence(false, false);
}
- virtual int32_t Encode(
- const I420VideoFrame& input_image,
- const CodecSpecificInfo* codec_specific_info,
- const std::vector<VideoFrameType>* frame_types) override {
+ int32_t Encode(const I420VideoFrame& input_image,
+ const CodecSpecificInfo* codec_specific_info,
+ const std::vector<VideoFrameType>* frame_types) override {
{
CriticalSectionScoped lock(test_crit_.get());
if (sender_state_ == Call::kNetworkDown) {
@@ -2414,10 +2387,9 @@
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<VideoFrameType>* frame_types) override {
+ int32_t Encode(const I420VideoFrame& input_image,
+ const CodecSpecificInfo* codec_specific_info,
+ const std::vector<VideoFrameType>* 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 d681039..033bf4f 100644
--- a/webrtc/video/full_stack.cc
+++ b/webrtc/video/full_stack.cc
@@ -131,8 +131,7 @@
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<RtpHeaderParser> parser(RtpHeaderParser::Create());
RTPHeader header;
parser->Parse(packet, length, &header);
@@ -145,7 +144,7 @@
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 @@
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<RtpHeaderParser> parser(RtpHeaderParser::Create());
RTPHeader header;
parser->Parse(packet, length, &header);
@@ -190,12 +189,12 @@
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 @@
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 3fb9874..4335fc1 100644
--- a/webrtc/video/rampup_tests.h
+++ b/webrtc/video/rampup_tests.h
@@ -49,12 +49,12 @@
void set_start_bitrate_bps(unsigned int start_bitrate_bps);
- virtual void OnReceiveBitrateChanged(const std::vector<unsigned int>& ssrcs,
- unsigned int bitrate) OVERRIDE;
+ void OnReceiveBitrateChanged(const std::vector<unsigned int>& 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 @@
virtual void OnReceiveBitrateChanged(const std::vector<unsigned int>& 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 dba5042..e27a19c 100644
--- a/webrtc/video/receive_statistics_proxy.h
+++ b/webrtc/video/receive_statistics_proxy.h
@@ -45,38 +45,37 @@
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 8e9ba81..8a84b66 100644
--- a/webrtc/video/replay.cc
+++ b/webrtc/video/replay.cc
@@ -151,8 +151,8 @@
}
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 @@
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 628a284..a60d495 100644
--- a/webrtc/video/send_statistics_proxy.h
+++ b/webrtc/video/send_statistics_proxy.h
@@ -54,48 +54,48 @@
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 89b0ca0..cd27d7c 100644
--- a/webrtc/video/transport_adapter.h
+++ b/webrtc/video/transport_adapter.h
@@ -21,12 +21,10 @@
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 9f156b1..dcc8122 100644
--- a/webrtc/video/video_receive_stream.h
+++ b/webrtc/video/video_receive_stream.h
@@ -49,25 +49,25 @@
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 cff2fb1..648a64e 100644
--- a/webrtc/video/video_send_stream.h
+++ b/webrtc/video/video_send_stream.h
@@ -53,21 +53,20 @@
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<uint32_t, RtpState> RtpStateMap;
RtpStateMap GetRtpStates() const;
diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc
index 103afa4..d351c9d 100644
--- a/webrtc/video/video_send_stream_tests.cc
+++ b/webrtc/video/video_send_stream_tests.cc
@@ -95,7 +95,7 @@
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 @@
return SEND_PACKET;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
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 @@
return SEND_PACKET;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
}
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 @@
return SEND_PACKET;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
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 @@
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 @@
}
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 @@
return SEND_PACKET;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
}
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 @@
return SEND_PACKET;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
}
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 @@
encoder_.SetFrameSize(static_cast<size_t>(current_size_frame_.Value()));
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
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 @@
}
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 @@
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 @@
}
// 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 @@
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<VideoReceiveStream*>& receive_streams) OVERRIDE {
+ const std::vector<VideoReceiveStream*>& receive_streams) override {
stream_ = send_stream;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
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 @@
}
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 @@
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 @@
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 @@
rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
}
- virtual void OnStreamsCreated(
+ void OnStreamsCreated(
VideoSendStream* send_stream,
- const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
+ const std::vector<VideoReceiveStream*>& 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 @@
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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
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 @@
}
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 @@
return 0;
}
- virtual int32_t Encode(
- const I420VideoFrame& inputImage,
- const CodecSpecificInfo* codecSpecificInfo,
- const std::vector<VideoFrameType>* frame_types) OVERRIDE {
+ int32_t Encode(const I420VideoFrame& inputImage,
+ const CodecSpecificInfo* codecSpecificInfo,
+ const std::vector<VideoFrameType>* 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 @@
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<VideoReceiveStream*>& receive_streams) OVERRIDE {
+ const std::vector<VideoReceiveStream*>& 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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
num_initializations_(0) {}
private:
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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<VideoReceiveStream*>& receive_streams) OVERRIDE {
+ const std::vector<VideoReceiveStream*>& 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 @@
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 @@
}
private:
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
send_config->encoder_settings.payload_name = "VP8";
@@ -1364,15 +1345,15 @@
encoder_config_ = *encoder_config;
}
- virtual void OnStreamsCreated(
+ void OnStreamsCreated(
VideoSendStream* send_stream,
- const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
+ const std::vector<VideoReceiveStream*>& 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 @@
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 @@
int32_t Encode(const I420VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
- const std::vector<VideoFrameType>* frame_types) OVERRIDE {
+ const std::vector<VideoFrameType>* frame_types) override {
// Silently skip the encode, FakeEncoder::Encode doesn't produce VP8.
return 0;
}
@@ -1430,7 +1411,7 @@
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 @@
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 @@
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::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<unsigned int>(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<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
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 @@
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<unsigned int>(kMinBitrateKbps),
codecSettings->minBitrate);
@@ -1560,7 +1540,7 @@
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 @@
return config;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
(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::FakeEncoder(Clock::GetRealTimeClock()) {}
private:
- virtual int32_t Encode(
- const I420VideoFrame& input_image,
- const CodecSpecificInfo* codecSpecificInfo,
- const std::vector<VideoFrameType>* frame_types) OVERRIDE {
+ int32_t Encode(const I420VideoFrame& input_image,
+ const CodecSpecificInfo* codecSpecificInfo,
+ const std::vector<VideoFrameType>* frame_types) override {
CodecSpecificInfo specifics;
memset(&specifics, 0, sizeof(specifics));
specifics.codecType = kVideoCodecGeneric;
@@ -1653,17 +1629,16 @@
observation_complete_->Set();
return 0;
}
- virtual void ModifyConfigs(
- VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) OVERRIDE {
+ void ModifyConfigs(VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* 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 @@
}
}
- virtual void OnStreamsCreated(
+ void OnStreamsCreated(
VideoSendStream* send_stream,
- const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
+ const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
}
diff --git a/webrtc/video_engine/call_stats.h b/webrtc/video_engine/call_stats.h
index 43e4fc0..79a8af6 100644
--- a/webrtc/video_engine/call_stats.h
+++ b/webrtc/video_engine/call_stats.h
@@ -32,8 +32,8 @@
~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 92d0ea3..7c04cf7 100644
--- a/webrtc/video_engine/overuse_frame_detector.h
+++ b/webrtc/video_engine/overuse_frame_detector.h
@@ -81,8 +81,8 @@
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 d14fe9d..cfb7f01d 100644
--- a/webrtc/video_engine/overuse_frame_detector_unittest.cc
+++ b/webrtc/video_engine/overuse_frame_detector_unittest.cc
@@ -62,8 +62,7 @@
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 e688d2e..13b7af5 100644
--- a/webrtc/video_engine/report_block_stats_unittest.cc
+++ b/webrtc/video_engine/report_block_stats_unittest.cc
@@ -18,7 +18,7 @@
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 9c77674..4fd2422 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 @@
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<const uint8_t*>(data);
webrtc::RtpUtility::RtpHeaderParser parser(buf, len);
if (parser.RTCP()) {
@@ -109,13 +107,13 @@
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 a8cdfbd..92d7bcc 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 @@
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 6d1027f..5345dc8 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 @@
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 225e30a..dd4eae5 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 @@
<< " 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 3c4757f..918edf9 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 @@
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<webrtc::VideoFrameType>* frameTypes) OVERRIDE;
+ const std::vector<webrtc::VideoFrameType>* 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 @@
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 b713aee..5d69e70 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 @@
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 612a81c..d873cd7 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 @@
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 7e025c7..958e1c1 100644
--- a/webrtc/video_engine/vie_base_impl.h
+++ b/webrtc/video_engine/vie_base_impl.h
@@ -35,13 +35,13 @@
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 @@
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 9d41a40..62a8a52 100644
--- a/webrtc/video_engine/vie_capturer.cc
+++ b/webrtc/video_engine/vie_capturer.cc
@@ -34,8 +34,7 @@
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 4dfcfbf..9f077e1 100644
--- a/webrtc/video_engine/vie_capturer.h
+++ b/webrtc/video_engine/vie_capturer.h
@@ -79,7 +79,7 @@
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 089ad07..3744d88 100644
--- a/webrtc/video_engine/vie_channel.h
+++ b/webrtc/video_engine/vie_channel.h
@@ -321,10 +321,9 @@
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 RegisterableSendSideDelayObserver :
public RegisterableCallback<SendSideDelayObserver> {
- 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 RegisterableRtcpPacketTypeCounterObserver
: public RegisterableCallback<RtcpPacketTypeCounterObserver> {
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 8386dc3..c91c9a9 100644
--- a/webrtc/video_engine/vie_channel_group.cc
+++ b/webrtc/video_engine/vie_channel_group.cc
@@ -48,41 +48,41 @@
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<unsigned int>* ssrcs,
- unsigned int* bitrate_bps) const OVERRIDE {
+ bool LatestEstimate(std::vector<unsigned int>* 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 517f6f6..a8be526 100644
--- a/webrtc/video_engine/vie_encoder.h
+++ b/webrtc/video_engine/vie_encoder.h
@@ -107,17 +107,15 @@
int32_t ScaleInputImage(bool enable);
// Implementing ViEFrameCallback.
- virtual void DeliverFrame(int id,
- I420VideoFrame* video_frame,
- const std::vector<uint32_t>& 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<uint32_t>& 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 @@
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<unsigned int>& ssrcs);
diff --git a/webrtc/video_engine/vie_image_process_impl.h b/webrtc/video_engine/vie_image_process_impl.h
index 38a6a08..64775b1 100644
--- a/webrtc/video_engine/vie_image_process_impl.h
+++ b/webrtc/video_engine/vie_image_process_impl.h
@@ -37,25 +37,25 @@
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 f2d5772..7a09a2c 100644
--- a/webrtc/video_engine/vie_network_impl.h
+++ b/webrtc/video_engine/vie_network_impl.h
@@ -24,25 +24,25 @@
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 b7f1859..e2e3daf 100644
--- a/webrtc/video_engine/vie_receiver.h
+++ b/webrtc/video_engine/vie_receiver.h
@@ -77,12 +77,10 @@
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 0c0a995..7512222 100644
--- a/webrtc/video_engine/vie_rtp_rtcp_impl.h
+++ b/webrtc/video_engine/vie_rtp_rtcp_impl.h
@@ -45,11 +45,10 @@
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 @@
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 3a80479..3e6bd95 100644
--- a/webrtc/video_engine/vie_sender.h
+++ b/webrtc/video_engine/vie_sender.h
@@ -40,8 +40,8 @@
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 994cdb2..a75d716 100644
--- a/webrtc/video_engine/vie_sync_module.h
+++ b/webrtc/video_engine/vie_sync_module.h
@@ -45,8 +45,8 @@
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<CriticalSectionWrapper> data_cs_;
diff --git a/webrtc/voice_engine/channel.cc b/webrtc/voice_engine/channel.cc
index 0a5d8e6..95bcc5c 100644
--- a/webrtc/voice_engine/channel.cc
+++ b/webrtc/voice_engine/channel.cc
@@ -59,8 +59,8 @@
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 @@
}
}
- 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 @@
// 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 29f9fe6..7629ceb 100644
--- a/webrtc/voice_engine/channel.h
+++ b/webrtc/voice_engine/channel.h
@@ -345,64 +345,55 @@
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 8a399eb..42ea74d 100644
--- a/webrtc/voice_engine/monitor_module.h
+++ b/webrtc/voice_engine/monitor_module.h
@@ -40,9 +40,10 @@
virtual ~MonitorModule();
public: // module
- virtual int64_t TimeUntilNextProcess() OVERRIDE;
+ int64_t TimeUntilNextProcess() override;
- virtual int32_t Process() OVERRIDE;
+ 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 b744d1d..28eeef0 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 @@
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 029b19e..4b20b47 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 @@
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 32ec867..67f5af3 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 @@
~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<int>(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<int>(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 ec9787c..bde1622 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 @@
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<const uint8_t*>(data), len, &header)) {
bool ok = true;
@@ -52,9 +52,7 @@
return static_cast<int>(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<int>(len);
}
@@ -93,14 +91,12 @@
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 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 03011b6..4436a86 100644
--- a/webrtc/voice_engine/test/win_test/WinTestDlg.cc
+++ b/webrtc/voice_engine/test/win_test/WinTestDlg.cc
@@ -129,12 +129,9 @@
{
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 dc9eb38..ee9b92e 100644
--- a/webrtc/voice_engine/voe_network_impl.h
+++ b/webrtc/voice_engine/voe_network_impl.h
@@ -22,22 +22,17 @@
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);
