zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Roll chromium_revision e144d30..6fdb142 (318658:318841) + remove OVERRIDE macro

Browse Source 
Clang version changed 223108:230914
Details: 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
This commit is contained in:
kjellander@webrtc.org
2015-03-04 12:58:35 +00:00
parent 792f1a14e2
commit 14665ff7d4
286 changed files with 3546 additions and 3920 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
webrtc/modules/video_coding/codecs/i420/main/interface/i420.h
View File

@ -34,9 +34,9 @@ class I420Encoder : public VideoEncoder {
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK.
// <0 - Error
virtual int InitEncode(const VideoCodec* codecSettings,
int /*numberOfCores*/,
size_t /*maxPayloadSize*/) OVERRIDE;
int InitEncode(const VideoCodec* codecSettings,
int /*numberOfCores*/,
size_t /*maxPayloadSize*/) override;
// "Encode" an I420 image (as a part of a video stream). The encoded image
// will be returned to the user via the encode complete callback.
@ -48,10 +48,9 @@ class I420Encoder : public VideoEncoder {
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK.
// <0 - Error
virtual int Encode(
const I420VideoFrame& inputImage,
const CodecSpecificInfo* /*codecSpecificInfo*/,
const std::vector<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 @@ class I420Encoder : public VideoEncoder {
// - callback : Callback object which handles encoded images.
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
virtual int RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) OVERRIDE;
int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
// Free encoder memory.
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
virtual int Release() OVERRIDE;
int Release() override;
virtual int SetRates(uint32_t /*newBitRate*/,
uint32_t /*frameRate*/) OVERRIDE {
int SetRates(uint32_t /*newBitRate*/, uint32_t /*frameRate*/) override {
return WEBRTC_VIDEO_CODEC_OK;
}
virtual int SetChannelParameters(uint32_t /*packetLoss*/,
int64_t /*rtt*/) OVERRIDE {
int SetChannelParameters(uint32_t /*packetLoss*/, int64_t /*rtt*/) override {
return WEBRTC_VIDEO_CODEC_OK;
}
virtual int CodecConfigParameters(uint8_t* /*buffer*/,
int /*size*/) OVERRIDE {
int CodecConfigParameters(uint8_t* /*buffer*/, int /*size*/) override {
return WEBRTC_VIDEO_CODEC_OK;
}
@ -102,11 +97,11 @@ class I420Decoder : public VideoDecoder {
//
// Return value : WEBRTC_VIDEO_CODEC_OK.
// <0 - Errors
virtual int InitDecode(const VideoCodec* codecSettings,
int /*numberOfCores*/) OVERRIDE;
int InitDecode(const VideoCodec* codecSettings,
int /*numberOfCores*/) override;
virtual int SetCodecConfigParameters(const uint8_t* /*buffer*/,
int /*size*/) OVERRIDE {
int SetCodecConfigParameters(const uint8_t* /*buffer*/,
int /*size*/) override {
return WEBRTC_VIDEO_CODEC_OK;
}
@ -122,11 +117,11 @@ class I420Decoder : public VideoDecoder {
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK
// <0 - Error
virtual int Decode(const EncodedImage& inputImage,
bool missingFrames,
const RTPFragmentationHeader* /*fragmentation*/,
const CodecSpecificInfo* /*codecSpecificInfo*/,
int64_t /*renderTimeMs*/) OVERRIDE;
int Decode(const EncodedImage& inputImage,
bool missingFrames,
const RTPFragmentationHeader* /*fragmentation*/,
const CodecSpecificInfo* /*codecSpecificInfo*/,
int64_t /*renderTimeMs*/) override;
// Register a decode complete callback object.
//
@ -134,20 +129,19 @@ class I420Decoder : public VideoDecoder {
// - callback : Callback object which handles decoded images.
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
virtual int RegisterDecodeCompleteCallback(
DecodedImageCallback* callback) OVERRIDE;
int RegisterDecodeCompleteCallback(DecodedImageCallback* callback) override;
// Free decoder memory.
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK.
// <0 - Error
virtual int Release() OVERRIDE;
int Release() override;
// Reset decoder state and prepare for a new call.
//
// Return value : WEBRTC_VIDEO_CODEC_OK.
// <0 - Error
virtual int Reset() OVERRIDE;
int Reset() override;
private:
static const uint8_t* ExtractHeader(const uint8_t* buffer,

2
webrtc/modules/video_coding/codecs/test/packet_manipulator.h
View File

@ -91,7 +91,7 @@ class PacketManipulatorImpl : public PacketManipulator {
const NetworkingConfig& config,
bool verbose);
virtual ~PacketManipulatorImpl();
virtual int ManipulatePackets(webrtc::EncodedImage* encoded_image) OVERRIDE;
int ManipulatePackets(webrtc::EncodedImage* encoded_image) override;
virtual void InitializeRandomSeed(unsigned int seed);
protected:
// Returns a uniformly distributed random value between 0.0 and 1.0

2
webrtc/modules/video_coding/codecs/test/predictive_packet_manipulator.h
View File

@ -33,7 +33,7 @@ class PredictivePacketManipulator : public PacketManipulatorImpl {
void AddRandomResult(double result);
protected:
// Returns a uniformly distributed random value between 0.0 and 1.0
virtual double RandomUniform() OVERRIDE;
double RandomUniform() override;
private:
std::queue<double> random_results_;

18
webrtc/modules/video_coding/codecs/test/videoprocessor.h
View File

@ -163,8 +163,8 @@ class VideoProcessorImpl : public VideoProcessor {
const TestConfig& config,
Stats* stats);
virtual ~VideoProcessorImpl();
virtual bool Init() OVERRIDE;
virtual bool ProcessFrame(int frame_number) OVERRIDE;
bool Init() override;
bool ProcessFrame(int frame_number) override;
private:
// Invoked by the callback when a frame has completed encoding.
@ -176,13 +176,13 @@ class VideoProcessorImpl : public VideoProcessor {
int GetElapsedTimeMicroseconds(const webrtc::TickTime& start,
const webrtc::TickTime& stop);
// Updates the encoder with the target bit rate and the frame rate.
virtual void SetRates(int bit_rate, int frame_rate) OVERRIDE;
void SetRates(int bit_rate, int frame_rate) override;
// Return the size of the encoded frame in bytes.
virtual size_t EncodedFrameSize() OVERRIDE;
size_t EncodedFrameSize() override;
// Return the number of dropped frames.
virtual int NumberDroppedFrames() OVERRIDE;
int NumberDroppedFrames() override;
// Return the number of spatial resizes.
virtual int NumberSpatialResizes() OVERRIDE;
int NumberSpatialResizes() override;
webrtc::VideoEncoder* encoder_;
webrtc::VideoDecoder* decoder_;
@ -225,10 +225,10 @@ class VideoProcessorImpl : public VideoProcessor {
public:
explicit VideoProcessorEncodeCompleteCallback(VideoProcessorImpl* vp)
: video_processor_(vp) {}
virtual int32_t Encoded(
int32_t Encoded(
const webrtc::EncodedImage& encoded_image,
const webrtc::CodecSpecificInfo* codec_specific_info,
const webrtc::RTPFragmentationHeader* fragmentation) OVERRIDE;
const webrtc::RTPFragmentationHeader* fragmentation) override;
private:
VideoProcessorImpl* video_processor_;
@ -241,7 +241,7 @@ class VideoProcessorImpl : public VideoProcessor {
explicit VideoProcessorDecodeCompleteCallback(VideoProcessorImpl* vp)
: video_processor_(vp) {
}
virtual int32_t Decoded(webrtc::I420VideoFrame& image) OVERRIDE;
int32_t Decoded(webrtc::I420VideoFrame& image) override;
private:
VideoProcessorImpl* video_processor_;

2
webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
View File

@ -46,7 +46,7 @@ class ScreenshareLayersFT : public ScreenshareLayers {
virtual ~ScreenshareLayersFT() {}
protected:
virtual bool TargetBitrateExperimentEnabled() OVERRIDE { return true; }
bool TargetBitrateExperimentEnabled() override { return true; }
};
class ScreenshareLayerTest : public ::testing::Test {

29
webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h
View File

@ -37,24 +37,21 @@ class SimulcastEncoderAdapter : public VP8Encoder,
virtual ~SimulcastEncoderAdapter();
// Implements VideoEncoder
virtual int Release() OVERRIDE;
virtual int InitEncode(const VideoCodec* inst,
int number_of_cores,
size_t max_payload_size) OVERRIDE;
virtual int Encode(const I420VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<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 {

6
webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc
View File

@ -145,15 +145,13 @@ class MockVideoEncoder : public VideoEncoder {
class MockVideoEncoderFactory : public VideoEncoderFactory {
public:
virtual VideoEncoder* Create() OVERRIDE {
VideoEncoder* Create() override {
MockVideoEncoder* encoder = new MockVideoEncoder();
encoders_.push_back(encoder);
return encoder;
}
virtual void Destroy(VideoEncoder* encoder) OVERRIDE {
delete encoder;
}
void Destroy(VideoEncoder* encoder) override { delete encoder; }
virtual ~MockVideoEncoderFactory() {}

24
webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
View File

@ -186,28 +186,26 @@ class SkipEncodingUnusedStreamsTest {
return layers_->EncodeFlags(timestamp);
}
virtual bool ConfigureBitrates(int bitrate_kbit,
int max_bitrate_kbit,
int framerate,
vpx_codec_enc_cfg_t* cfg) OVERRIDE {
bool ConfigureBitrates(int bitrate_kbit,
int max_bitrate_kbit,
int framerate,
vpx_codec_enc_cfg_t* cfg) override {
configured_bitrate_ = bitrate_kbit;
return layers_->ConfigureBitrates(
bitrate_kbit, max_bitrate_kbit, framerate, cfg);
}
virtual void PopulateCodecSpecific(bool base_layer_sync,
CodecSpecificInfoVP8* vp8_info,
uint32_t timestamp) OVERRIDE {
void PopulateCodecSpecific(bool base_layer_sync,
CodecSpecificInfoVP8* vp8_info,
uint32_t timestamp) override {
layers_->PopulateCodecSpecific(base_layer_sync, vp8_info, timestamp);
}
virtual void FrameEncoded(unsigned int size, uint32_t timestamp) OVERRIDE {
void FrameEncoded(unsigned int size, uint32_t timestamp) override {
layers_->FrameEncoded(size, timestamp);
}
virtual int CurrentLayerId() const OVERRIDE {
return layers_->CurrentLayerId();
}
int CurrentLayerId() const override { return layers_->CurrentLayerId(); }
int configured_bitrate_;
TemporalLayers* layers_;
@ -216,8 +214,8 @@ class SkipEncodingUnusedStreamsTest {
class SpyingTemporalLayersFactory : public TemporalLayers::Factory {
public:
virtual ~SpyingTemporalLayersFactory() {}
virtual TemporalLayers* Create(int temporal_layers,
uint8_t initial_tl0_pic_idx) const OVERRIDE {
TemporalLayers* Create(int temporal_layers,
uint8_t initial_tl0_pic_idx) const override {
SpyingTemporalLayers* layers =
new SpyingTemporalLayers(TemporalLayers::Factory::Create(
temporal_layers, initial_tl0_pic_idx));

8
webrtc/modules/video_coding/codecs/vp8/vp8_factory.cc
View File

@ -19,13 +19,9 @@ bool VP8EncoderFactoryConfig::use_simulcast_adapter_ = false;
class VP8EncoderImplFactory : public VideoEncoderFactory {
public:
virtual VideoEncoder* Create() OVERRIDE {
return new VP8EncoderImpl();
}
VideoEncoder* Create() override { return new VP8EncoderImpl(); }
virtual void Destroy(VideoEncoder* encoder) OVERRIDE {
delete encoder;
}
void Destroy(VideoEncoder* encoder) override { delete encoder; }
virtual ~VP8EncoderImplFactory() {}
};

40
webrtc/modules/video_coding/codecs/vp9/vp9_impl.h
View File

@ -25,22 +25,21 @@ class VP9EncoderImpl : public VP9Encoder {
virtual ~VP9EncoderImpl();
virtual int Release() OVERRIDE;
int Release() override;
virtual int InitEncode(const VideoCodec* codec_settings,
int number_of_cores,
size_t max_payload_size) OVERRIDE;
int InitEncode(const VideoCodec* codec_settings,
int number_of_cores,
size_t max_payload_size) override;
virtual int Encode(const I420VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<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 @@ class VP9DecoderImpl : public VP9Decoder {
virtual ~VP9DecoderImpl();
virtual int InitDecode(const VideoCodec* inst, int number_of_cores) OVERRIDE;
int InitDecode(const VideoCodec* inst, int number_of_cores) override;
virtual int Decode(const EncodedImage& input_image,
bool missing_frames,
const RTPFragmentationHeader* fragmentation,
const CodecSpecificInfo* codec_specific_info,
int64_t /*render_time_ms*/) OVERRIDE;
int Decode(const EncodedImage& input_image,
bool missing_frames,
const RTPFragmentationHeader* fragmentation,
const CodecSpecificInfo* codec_specific_info,
int64_t /*render_time_ms*/) override;
virtual int RegisterDecodeCompleteCallback(DecodedImageCallback* callback)
OVERRIDE;
int RegisterDecodeCompleteCallback(DecodedImageCallback* callback) override;
virtual int Release() OVERRIDE;
int Release() override;
virtual int Reset() OVERRIDE;
int Reset() override;
private:
int ReturnFrame(const vpx_image_t* img, uint32_t timeStamp);