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

Add RTC_ prefix to contructormagic macros.

Browse Source 
We must remove dependency on Chromium, i.e. we can't use Chromium's base/logging.h. That means we need to define these macros in WebRTC also when doing Chromium builds. And this causes redefinition.

* DISALLOW_ASSIGN -> RTC_DISALLOW_ASSIGN
* DISALLOW_COPY_AND_ASSIGN -> RTC_DISALLOW_COPY_AND_ASSIGN
* DISALLOW_IMPLICIT_CONSTRUCTORS -> RTC_DISALLOW_IMPLICIT_CONSTRUCTORS

Related CL: https://codereview.webrtc.org/1335923002/

BUG=chromium:468375
NOTRY=true

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

Cr-Commit-Position: refs/heads/master@{#9953}
This commit is contained in:
henrikg
2015-09-16 05:37:44 -07:00
committed by Commit bot
parent afb6b5e3e0
commit 3c089d751e
258 changed files with 411 additions and 418 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
talk/app/webrtc/dtmfsender.h
View File

@ -116,7 +116,7 @@ class DtmfSender
int duration_; int duration_;
int inter_tone_gap_; int inter_tone_gap_;
DISALLOW_COPY_AND_ASSIGN(DtmfSender); RTC_DISALLOW_COPY_AND_ASSIGN(DtmfSender);
}; };
// Define proxy for DtmfSenderInterface. // Define proxy for DtmfSenderInterface.

2
talk/app/webrtc/java/jni/androidvideocapturer_jni.h
View File

@ -102,7 +102,7 @@ private:
static jobject application_context_; static jobject application_context_;
DISALLOW_COPY_AND_ASSIGN(AndroidVideoCapturerJni); RTC_DISALLOW_COPY_AND_ASSIGN(AndroidVideoCapturerJni);
}; };
} // namespace webrtc_jni } // namespace webrtc_jni

2
talk/app/webrtc/jsepicecandidate.h
View File

@ -63,7 +63,7 @@ class JsepIceCandidate : public IceCandidateInterface {
int sdp_mline_index_; int sdp_mline_index_;
cricket::Candidate candidate_; cricket::Candidate candidate_;
DISALLOW_COPY_AND_ASSIGN(JsepIceCandidate); RTC_DISALLOW_COPY_AND_ASSIGN(JsepIceCandidate);
}; };
// Implementation of IceCandidateCollection. // Implementation of IceCandidateCollection.

2
talk/app/webrtc/jsepsessiondescription.h
View File

@ -98,7 +98,7 @@ class JsepSessionDescription : public SessionDescriptionInterface {
bool GetMediasectionIndex(const IceCandidateInterface* candidate, bool GetMediasectionIndex(const IceCandidateInterface* candidate,
size_t* index); size_t* index);
DISALLOW_COPY_AND_ASSIGN(JsepSessionDescription); RTC_DISALLOW_COPY_AND_ASSIGN(JsepSessionDescription);
}; };
} // namespace webrtc } // namespace webrtc

2
talk/app/webrtc/mediacontroller.cc
View File

@ -74,7 +74,7 @@ class MediaController : public webrtc::MediaControllerInterface {
rtc::Thread* worker_thread_; rtc::Thread* worker_thread_;
rtc::scoped_ptr<webrtc::Call> call_; rtc::scoped_ptr<webrtc::Call> call_;
DISALLOW_IMPLICIT_CONSTRUCTORS(MediaController); RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(MediaController);
}; };
} // namespace { } // namespace {

2
talk/app/webrtc/remotevideocapturer.h
View File

@ -57,7 +57,7 @@ class RemoteVideoCapturer : public cricket::VideoCapturer {
bool IsScreencast() const override; bool IsScreencast() const override;
private: private:
DISALLOW_COPY_AND_ASSIGN(RemoteVideoCapturer); RTC_DISALLOW_COPY_AND_ASSIGN(RemoteVideoCapturer);
}; };
} // namespace webrtc } // namespace webrtc

4
talk/app/webrtc/statstypes.h
View File

@ -321,7 +321,7 @@ class StatsReport {
} value_; } value_;
private: private:
DISALLOW_COPY_AND_ASSIGN(Value); RTC_DISALLOW_COPY_AND_ASSIGN(Value);
}; };
// TODO(tommi): Consider using a similar approach to how we store Ids using // TODO(tommi): Consider using a similar approach to how we store Ids using
@ -371,7 +371,7 @@ class StatsReport {
double timestamp_; // Time since 1970-01-01T00:00:00Z in milliseconds. double timestamp_; // Time since 1970-01-01T00:00:00Z in milliseconds.
Values values_; Values values_;
DISALLOW_COPY_AND_ASSIGN(StatsReport); RTC_DISALLOW_COPY_AND_ASSIGN(StatsReport);
}; };
// Typedef for an array of const StatsReport pointers. // Typedef for an array of const StatsReport pointers.

2
talk/app/webrtc/videosource.cc
View File

@ -321,7 +321,7 @@ class FrameInputWrapper : public cricket::VideoRenderer {
int width_; int width_;
int height_; int height_;
DISALLOW_COPY_AND_ASSIGN(FrameInputWrapper); RTC_DISALLOW_COPY_AND_ASSIGN(FrameInputWrapper);
}; };
} // anonymous namespace } // anonymous namespace

4
talk/app/webrtc/webrtcsession.h
View File

@ -107,7 +107,7 @@ class IceObserver {
~IceObserver() {} ~IceObserver() {}
private: private:
DISALLOW_COPY_AND_ASSIGN(IceObserver); RTC_DISALLOW_COPY_AND_ASSIGN(IceObserver);
}; };
class WebRtcSession : public cricket::BaseSession, class WebRtcSession : public cricket::BaseSession,
@ -414,7 +414,7 @@ class WebRtcSession : public cricket::BaseSession,
// Declares the RTCP mux policy for the WebRTCSession. // Declares the RTCP mux policy for the WebRTCSession.
PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy_; PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy_;
DISALLOW_COPY_AND_ASSIGN(WebRtcSession); RTC_DISALLOW_COPY_AND_ASSIGN(WebRtcSession);
}; };
} // namespace webrtc } // namespace webrtc

2
talk/app/webrtc/webrtcsessiondescriptionfactory.h
View File

@ -197,7 +197,7 @@ class WebRtcSessionDescriptionFactory : public rtc::MessageHandler,
const cricket::DataChannelType data_channel_type_; const cricket::DataChannelType data_channel_type_;
CertificateRequestState certificate_request_state_; CertificateRequestState certificate_request_state_;
DISALLOW_COPY_AND_ASSIGN(WebRtcSessionDescriptionFactory); RTC_DISALLOW_COPY_AND_ASSIGN(WebRtcSessionDescriptionFactory);
}; };
} // namespace webrtc } // namespace webrtc

4
talk/media/base/cpuid.h
View File

@ -28,7 +28,7 @@
#ifndef TALK_MEDIA_BASE_CPUID_H_ #ifndef TALK_MEDIA_BASE_CPUID_H_
#define TALK_MEDIA_BASE_CPUID_H_ #define TALK_MEDIA_BASE_CPUID_H_
#include "webrtc/base/basictypes.h" // For DISALLOW_IMPLICIT_CONSTRUCTORS #include "webrtc/base/basictypes.h" // For RTC_DISALLOW_IMPLICIT_CONSTRUCTORS
namespace cricket { namespace cricket {
@ -65,7 +65,7 @@ class CpuInfo {
static void MaskCpuFlagsForTest(int enable_flags); static void MaskCpuFlagsForTest(int enable_flags);
private: private:
DISALLOW_IMPLICIT_CONSTRUCTORS(CpuInfo); RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(CpuInfo);
}; };
// Detect an Intel Core I5 or better such as 4th generation Macbook Air. // Detect an Intel Core I5 or better such as 4th generation Macbook Air.

6
talk/media/base/rtpdump.h
View File

@ -133,7 +133,7 @@ class RtpDumpReader {
uint32 start_time_ms_; uint32 start_time_ms_;
uint32 ssrc_override_; uint32 ssrc_override_;
DISALLOW_COPY_AND_ASSIGN(RtpDumpReader); RTC_DISALLOW_COPY_AND_ASSIGN(RtpDumpReader);
}; };
// RtpDumpLoopReader reads RTP dump packets from the input stream and rewinds // RtpDumpLoopReader reads RTP dump packets from the input stream and rewinds
@ -181,7 +181,7 @@ class RtpDumpLoopReader : public RtpDumpReader {
int prev_rtp_seq_num_; int prev_rtp_seq_num_;
uint32 prev_rtp_timestamp_; uint32 prev_rtp_timestamp_;
DISALLOW_COPY_AND_ASSIGN(RtpDumpLoopReader); RTC_DISALLOW_COPY_AND_ASSIGN(RtpDumpLoopReader);
}; };
class RtpDumpWriter { class RtpDumpWriter {
@ -225,7 +225,7 @@ class RtpDumpWriter {
uint32 start_time_ms_; // Time when the record starts. uint32 start_time_ms_; // Time when the record starts.
// If writing to the stream takes longer than this many ms, log a warning. // If writing to the stream takes longer than this many ms, log a warning.
uint32 warn_slow_writes_delay_; uint32 warn_slow_writes_delay_;
DISALLOW_COPY_AND_ASSIGN(RtpDumpWriter); RTC_DISALLOW_COPY_AND_ASSIGN(RtpDumpWriter);
}; };
} // namespace cricket } // namespace cricket

2
talk/media/base/streamparams.h
View File

@ -246,7 +246,7 @@ struct MediaStreams {
std::vector<StreamParams> video_; std::vector<StreamParams> video_;
std::vector<StreamParams> data_; std::vector<StreamParams> data_;
DISALLOW_COPY_AND_ASSIGN(MediaStreams); RTC_DISALLOW_COPY_AND_ASSIGN(MediaStreams);
}; };
// A request for a specific format of a specific stream. // A request for a specific format of a specific stream.

4
talk/media/base/videoadapter.h
View File

@ -92,7 +92,7 @@ class VideoAdapter {
// The critical section to protect the above variables. // The critical section to protect the above variables.
rtc::CriticalSection critical_section_; rtc::CriticalSection critical_section_;
DISALLOW_COPY_AND_ASSIGN(VideoAdapter); RTC_DISALLOW_COPY_AND_ASSIGN(VideoAdapter);
}; };
// CoordinatedVideoAdapter adapts the video input to the encoder by coordinating // CoordinatedVideoAdapter adapts the video input to the encoder by coordinating
@ -201,7 +201,7 @@ class CoordinatedVideoAdapter
// adaptation is on), but only used if cpu_smoothing_ is set. // adaptation is on), but only used if cpu_smoothing_ is set.
float system_load_average_; float system_load_average_;
DISALLOW_COPY_AND_ASSIGN(CoordinatedVideoAdapter); RTC_DISALLOW_COPY_AND_ASSIGN(CoordinatedVideoAdapter);
}; };
} // namespace cricket } // namespace cricket

4
talk/media/base/videocapturer.h
View File

@ -104,7 +104,7 @@ struct CapturedFrame {
// memory or points to an existing memory. // memory or points to an existing memory.
private: private:
DISALLOW_COPY_AND_ASSIGN(CapturedFrame); RTC_DISALLOW_COPY_AND_ASSIGN(CapturedFrame);
}; };
// VideoCapturer is an abstract class that defines the interfaces for video // VideoCapturer is an abstract class that defines the interfaces for video
@ -397,7 +397,7 @@ class VideoCapturer
// Whether capturer should apply rotation to the frame before signaling it. // Whether capturer should apply rotation to the frame before signaling it.
bool apply_rotation_; bool apply_rotation_;
DISALLOW_COPY_AND_ASSIGN(VideoCapturer); RTC_DISALLOW_COPY_AND_ASSIGN(VideoCapturer);
}; };
} // namespace cricket } // namespace cricket

2
talk/media/base/yuvframegenerator.h
View File

@ -97,7 +97,7 @@ class YuvFrameGenerator {
int barcode_start_x_; int barcode_start_x_;
int barcode_start_y_; int barcode_start_y_;
DISALLOW_COPY_AND_ASSIGN(YuvFrameGenerator); RTC_DISALLOW_COPY_AND_ASSIGN(YuvFrameGenerator);
}; };
} // namespace cricket } // namespace cricket

2
talk/media/devices/filevideocapturer.cc
View File

@ -150,7 +150,7 @@ class FileVideoCapturer::FileReadThread
mutable rtc::CriticalSection crit_; mutable rtc::CriticalSection crit_;
bool finished_; bool finished_;
DISALLOW_COPY_AND_ASSIGN(FileReadThread); RTC_DISALLOW_COPY_AND_ASSIGN(FileReadThread);
}; };
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////

4
talk/media/devices/filevideocapturer.h
View File

@ -71,7 +71,7 @@ class VideoRecorder {
rtc::FileStream video_file_; rtc::FileStream video_file_;
bool write_header_; bool write_header_;
DISALLOW_COPY_AND_ASSIGN(VideoRecorder); RTC_DISALLOW_COPY_AND_ASSIGN(VideoRecorder);
}; };
// Simulated video capturer that periodically reads frames from a file. // Simulated video capturer that periodically reads frames from a file.
@ -153,7 +153,7 @@ class FileVideoCapturer : public VideoCapturer {
int64 last_frame_timestamp_ns_; // Timestamp of last read frame. int64 last_frame_timestamp_ns_; // Timestamp of last read frame.
bool ignore_framerate_; bool ignore_framerate_;
DISALLOW_COPY_AND_ASSIGN(FileVideoCapturer); RTC_DISALLOW_COPY_AND_ASSIGN(FileVideoCapturer);
}; };
} // namespace cricket } // namespace cricket

2
talk/media/devices/yuvframescapturer.cc
View File

@ -88,7 +88,7 @@ class YuvFramesCapturer::YuvFramesThread
mutable rtc::CriticalSection crit_; mutable rtc::CriticalSection crit_;
bool finished_; bool finished_;
DISALLOW_COPY_AND_ASSIGN(YuvFramesThread); RTC_DISALLOW_COPY_AND_ASSIGN(YuvFramesThread);
}; };
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////

2
talk/media/devices/yuvframescapturer.h
View File

@ -90,7 +90,7 @@ class YuvFramesCapturer : public VideoCapturer {
int32 barcode_interval_; int32 barcode_interval_;
int32 GetBarcodeValue(); int32 GetBarcodeValue();
DISALLOW_COPY_AND_ASSIGN(YuvFramesCapturer); RTC_DISALLOW_COPY_AND_ASSIGN(YuvFramesCapturer);
}; };
} // namespace cricket } // namespace cricket

4
talk/session/media/srtpfilter.h
View File

@ -245,7 +245,7 @@ class SrtpSession {
static bool inited_; static bool inited_;
static rtc::GlobalLockPod lock_; static rtc::GlobalLockPod lock_;
int last_send_seq_num_; int last_send_seq_num_;
DISALLOW_COPY_AND_ASSIGN(SrtpSession); RTC_DISALLOW_COPY_AND_ASSIGN(SrtpSession);
}; };
// Class that collects failures of SRTP. // Class that collects failures of SRTP.
@ -320,7 +320,7 @@ class SrtpStat {
// Threshold in ms to silent the signaling errors. // Threshold in ms to silent the signaling errors.
uint32 signal_silent_time_; uint32 signal_silent_time_;
DISALLOW_COPY_AND_ASSIGN(SrtpStat); RTC_DISALLOW_COPY_AND_ASSIGN(SrtpStat);
}; };
} // namespace cricket } // namespace cricket

2
talk/session/media/srtpfilter_unittest.cc
View File

@ -797,7 +797,7 @@ class SrtpStatTest
cricket::SrtpFilter::Error error_; cricket::SrtpFilter::Error error_;
private: private:
DISALLOW_COPY_AND_ASSIGN(SrtpStatTest); RTC_DISALLOW_COPY_AND_ASSIGN(SrtpStatTest);
}; };
TEST_F(SrtpStatTest, TestProtectRtpError) { TEST_F(SrtpStatTest, TestProtectRtpError) {

2
webrtc/base/asyncinvoker.h
View File

@ -141,7 +141,7 @@ class AsyncInvoker : public MessageHandler {
uint32 id); uint32 id);
bool destroying_; bool destroying_;
DISALLOW_COPY_AND_ASSIGN(AsyncInvoker); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncInvoker);
}; };
// Similar to AsyncInvoker, but guards against the Thread being destroyed while // Similar to AsyncInvoker, but guards against the Thread being destroyed while

2
webrtc/base/asyncpacketsocket.h
View File

@ -130,7 +130,7 @@ class AsyncPacketSocket : public sigslot::has_slots<> {
sigslot::signal2<AsyncPacketSocket*, AsyncPacketSocket*> SignalNewConnection; sigslot::signal2<AsyncPacketSocket*, AsyncPacketSocket*> SignalNewConnection;
private: private:
DISALLOW_COPY_AND_ASSIGN(AsyncPacketSocket); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncPacketSocket);
}; };
} // namespace rtc } // namespace rtc

4
webrtc/base/asynctcpsocket.h
View File

@ -74,7 +74,7 @@ class AsyncTCPSocketBase : public AsyncPacketSocket {
char* inbuf_, * outbuf_; char* inbuf_, * outbuf_;
size_t insize_, inpos_, outsize_, outpos_; size_t insize_, inpos_, outsize_, outpos_;
DISALLOW_COPY_AND_ASSIGN(AsyncTCPSocketBase); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncTCPSocketBase);
}; };
class AsyncTCPSocket : public AsyncTCPSocketBase { class AsyncTCPSocket : public AsyncTCPSocketBase {
@ -95,7 +95,7 @@ class AsyncTCPSocket : public AsyncTCPSocketBase {
void HandleIncomingConnection(AsyncSocket* socket) override; void HandleIncomingConnection(AsyncSocket* socket) override;
private: private:
DISALLOW_COPY_AND_ASSIGN(AsyncTCPSocket); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncTCPSocket);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/autodetectproxy.h
View File

@ -81,7 +81,7 @@ class AutoDetectProxy : public SignalThread {
AsyncSocket* socket_; AsyncSocket* socket_;
int next_; int next_;
DISALLOW_IMPLICIT_CONSTRUCTORS(AutoDetectProxy); RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(AutoDetectProxy);
}; };
} // namespace rtc } // namespace rtc

4
webrtc/base/bitbuffer.h
View File

@ -81,7 +81,7 @@ class BitBuffer {
// The current offset, in bits, into the current byte. // The current offset, in bits, into the current byte.
size_t bit_offset_; size_t bit_offset_;
DISALLOW_COPY_AND_ASSIGN(BitBuffer); RTC_DISALLOW_COPY_AND_ASSIGN(BitBuffer);
}; };
// A BitBuffer API for write operations. Supports symmetric write APIs to the // A BitBuffer API for write operations. Supports symmetric write APIs to the
@ -110,7 +110,7 @@ class BitBufferWriter : public BitBuffer {
// The buffer, as a writable array. // The buffer, as a writable array.
uint8_t* const writable_bytes_; uint8_t* const writable_bytes_;
DISALLOW_COPY_AND_ASSIGN(BitBufferWriter); RTC_DISALLOW_COPY_AND_ASSIGN(BitBufferWriter);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/bufferqueue.h
View File

@ -42,7 +42,7 @@ class BufferQueue {
std::vector<Buffer*> free_list_; std::vector<Buffer*> free_list_;
mutable CriticalSection crit_; // object lock mutable CriticalSection crit_; // object lock
DISALLOW_COPY_AND_ASSIGN(BufferQueue); RTC_DISALLOW_COPY_AND_ASSIGN(BufferQueue);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/bytebuffer.h
View File

@ -114,7 +114,7 @@ class ByteBuffer {
// There are sensible ways to define these, but they aren't needed in our code // There are sensible ways to define these, but they aren't needed in our code
// base. // base.
DISALLOW_COPY_AND_ASSIGN(ByteBuffer); RTC_DISALLOW_COPY_AND_ASSIGN(ByteBuffer);
}; };
} // namespace rtc } // namespace rtc

21
webrtc/base/constructormagic.h
View File

@ -11,19 +11,14 @@
#ifndef WEBRTC_BASE_CONSTRUCTORMAGIC_H_ #ifndef WEBRTC_BASE_CONSTRUCTORMAGIC_H_
#define WEBRTC_BASE_CONSTRUCTORMAGIC_H_ #define WEBRTC_BASE_CONSTRUCTORMAGIC_H_
// Undefine macros first, just in case. Some third-party includes have their own #define RTC_DISALLOW_ASSIGN(TypeName) \
// version.
#undef DISALLOW_ASSIGN
#define DISALLOW_ASSIGN(TypeName) \
void operator=(const TypeName&) void operator=(const TypeName&)
// A macro to disallow the evil copy constructor and operator= functions // A macro to disallow the evil copy constructor and operator= functions
// This should be used in the private: declarations for a class. // This should be used in the private: declarations for a class.
#undef DISALLOW_COPY_AND_ASSIGN #define RTC_DISALLOW_COPY_AND_ASSIGN(TypeName) \
#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ TypeName(const TypeName&); \
TypeName(const TypeName&); \ RTC_DISALLOW_ASSIGN(TypeName)
DISALLOW_ASSIGN(TypeName)
// A macro to disallow all the implicit constructors, namely the // A macro to disallow all the implicit constructors, namely the
// default constructor, copy constructor and operator= functions. // default constructor, copy constructor and operator= functions.
@ -31,10 +26,8 @@
// This should be used in the private: declarations for a class // This should be used in the private: declarations for a class
// that wants to prevent anyone from instantiating it. This is // that wants to prevent anyone from instantiating it. This is
// especially useful for classes containing only static methods. // especially useful for classes containing only static methods.
#undef DISALLOW_IMPLICIT_CONSTRUCTORS #define RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ TypeName(); \
TypeName(); \ RTC_DISALLOW_COPY_AND_ASSIGN(TypeName)
DISALLOW_COPY_AND_ASSIGN(TypeName)
#endif // WEBRTC_BASE_CONSTRUCTORMAGIC_H_ #endif // WEBRTC_BASE_CONSTRUCTORMAGIC_H_

6
webrtc/base/criticalsection.h
View File

@ -72,7 +72,7 @@ class SCOPED_LOCKABLE CritScope {
~CritScope() UNLOCK_FUNCTION(); ~CritScope() UNLOCK_FUNCTION();
private: private:
CriticalSection* const cs_; CriticalSection* const cs_;
DISALLOW_COPY_AND_ASSIGN(CritScope); RTC_DISALLOW_COPY_AND_ASSIGN(CritScope);
}; };
// Tries to lock a critical section on construction via // Tries to lock a critical section on construction via
@ -95,7 +95,7 @@ class TryCritScope {
CriticalSection* const cs_; CriticalSection* const cs_;
const bool locked_; const bool locked_;
CS_DEBUG_CODE(mutable bool lock_was_called_); CS_DEBUG_CODE(mutable bool lock_was_called_);
DISALLOW_COPY_AND_ASSIGN(TryCritScope); RTC_DISALLOW_COPY_AND_ASSIGN(TryCritScope);
}; };
// A POD lock used to protect global variables. Do NOT use for other purposes. // A POD lock used to protect global variables. Do NOT use for other purposes.
@ -121,7 +121,7 @@ class SCOPED_LOCKABLE GlobalLockScope {
~GlobalLockScope() UNLOCK_FUNCTION(); ~GlobalLockScope() UNLOCK_FUNCTION();
private: private:
GlobalLockPod* const lock_; GlobalLockPod* const lock_;
DISALLOW_COPY_AND_ASSIGN(GlobalLockScope); RTC_DISALLOW_COPY_AND_ASSIGN(GlobalLockScope);
}; };
} // namespace rtc } // namespace rtc

4
webrtc/base/filerotatingstream.h
View File

@ -123,7 +123,7 @@ class FileRotatingStream : public StreamInterface {
size_t current_bytes_written_; size_t current_bytes_written_;
bool disable_buffering_; bool disable_buffering_;
DISALLOW_COPY_AND_ASSIGN(FileRotatingStream); RTC_DISALLOW_COPY_AND_ASSIGN(FileRotatingStream);
}; };
// CallSessionFileRotatingStream is meant to be used in situations where we will // CallSessionFileRotatingStream is meant to be used in situations where we will
@ -164,7 +164,7 @@ class CallSessionFileRotatingStream : public FileRotatingStream {
const size_t max_total_log_size_; const size_t max_total_log_size_;
size_t num_rotations_; size_t num_rotations_;
DISALLOW_COPY_AND_ASSIGN(CallSessionFileRotatingStream); RTC_DISALLOW_COPY_AND_ASSIGN(CallSessionFileRotatingStream);
}; };
} // namespace rtc } // namespace rtc

4
webrtc/base/fileutils.h
View File

@ -407,7 +407,7 @@ class Filesystem {
static FilesystemInterface* default_filesystem_; static FilesystemInterface* default_filesystem_;
static FilesystemInterface *EnsureDefaultFilesystem(); static FilesystemInterface *EnsureDefaultFilesystem();
DISALLOW_IMPLICIT_CONSTRUCTORS(Filesystem); RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Filesystem);
}; };
class FilesystemScope{ class FilesystemScope{
@ -420,7 +420,7 @@ class FilesystemScope{
} }
private: private:
FilesystemInterface* old_fs_; FilesystemInterface* old_fs_;
DISALLOW_IMPLICIT_CONSTRUCTORS(FilesystemScope); RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(FilesystemScope);
}; };
// Generates a unique filename based on the input path. If no path component // Generates a unique filename based on the input path. If no path component

16
webrtc/base/flags.h
View File

@ -90,17 +90,17 @@ class Flag {
assert(type_ == BOOL); assert(type_ == BOOL);
return &variable_->b; return &variable_->b;
} }
int* int_variable() const { int* int_variable() const {
assert(type_ == INT); assert(type_ == INT);
return &variable_->i; return &variable_->i;
} }
double* float_variable() const { double* float_variable() const {
assert(type_ == FLOAT); assert(type_ == FLOAT);
return &variable_->f; return &variable_->f;
} }
const char** string_variable() const { const char** string_variable() const {
assert(type_ == STRING); assert(type_ == STRING);
return &variable_->s; return &variable_->s;
@ -111,17 +111,17 @@ class Flag {
assert(type_ == BOOL); assert(type_ == BOOL);
return default_.b; return default_.b;
} }
int int_default() const { int int_default() const {
assert(type_ == INT); assert(type_ == INT);
return default_.i; return default_.i;
} }
double float_default() const { double float_default() const {
assert(type_ == FLOAT); assert(type_ == FLOAT);
return default_.f; return default_.f;
} }
const char* string_default() const { const char* string_default() const {
assert(type_ == STRING); assert(type_ == STRING);
return default_.s; return default_.s;
@ -261,9 +261,9 @@ class WindowsCommandLineArguments {
char **argv_; char **argv_;
private: private:
DISALLOW_COPY_AND_ASSIGN(WindowsCommandLineArguments); RTC_DISALLOW_COPY_AND_ASSIGN(WindowsCommandLineArguments);
}; };
#endif // WEBRTC_WIN #endif // WEBRTC_WIN
} // namespace rtc } // namespace rtc

2
webrtc/base/latebindingsymboltable.h
View File

@ -61,7 +61,7 @@ class LateBindingSymbolTable {
DllHandle handle_; DllHandle handle_;
bool undefined_symbols_; bool undefined_symbols_;
DISALLOW_COPY_AND_ASSIGN(LateBindingSymbolTable); RTC_DISALLOW_COPY_AND_ASSIGN(LateBindingSymbolTable);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/latebindingsymboltable.h.def
View File

@ -76,7 +76,7 @@ LATE_BINDING_SYMBOL_TABLE_SYMBOLS_LIST
void *table_[SYMBOL_TABLE_SIZE]; void *table_[SYMBOL_TABLE_SIZE];
DISALLOW_COPY_AND_ASSIGN(LATE_BINDING_SYMBOL_TABLE_CLASS_NAME); RTC_DISALLOW_COPY_AND_ASSIGN(LATE_BINDING_SYMBOL_TABLE_CLASS_NAME);
}; };
#undef LATE_BINDING_SYMBOL_TABLE_CLASS_NAME #undef LATE_BINDING_SYMBOL_TABLE_CLASS_NAME

2
webrtc/base/logging.h
View File

@ -239,7 +239,7 @@ class LogMessage {
// Determines if logs will be directed to stderr in debug mode. // Determines if logs will be directed to stderr in debug mode.
static bool log_to_stderr_; static bool log_to_stderr_;
DISALLOW_COPY_AND_ASSIGN(LogMessage); RTC_DISALLOW_COPY_AND_ASSIGN(LogMessage);
}; };
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////

4
webrtc/base/logsinks.h
View File

@ -48,7 +48,7 @@ class FileRotatingLogSink : public LogSink {
private: private:
scoped_ptr<FileRotatingStream> stream_; scoped_ptr<FileRotatingStream> stream_;
DISALLOW_COPY_AND_ASSIGN(FileRotatingLogSink); RTC_DISALLOW_COPY_AND_ASSIGN(FileRotatingLogSink);
}; };
// Log sink that uses a CallSessionFileRotatingStream to write to disk. // Log sink that uses a CallSessionFileRotatingStream to write to disk.
@ -60,7 +60,7 @@ class CallSessionFileRotatingLogSink : public FileRotatingLogSink {
~CallSessionFileRotatingLogSink() override; ~CallSessionFileRotatingLogSink() override;
private: private:
DISALLOW_COPY_AND_ASSIGN(CallSessionFileRotatingLogSink); RTC_DISALLOW_COPY_AND_ASSIGN(CallSessionFileRotatingLogSink);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/macasyncsocket.h
View File

@ -90,7 +90,7 @@ class MacAsyncSocket : public AsyncSocket, public sigslot::has_slots<> {
ConnState state_; ConnState state_;
AsyncResolver* resolver_; AsyncResolver* resolver_;
DISALLOW_COPY_AND_ASSIGN(MacAsyncSocket); RTC_DISALLOW_COPY_AND_ASSIGN(MacAsyncSocket);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/maccocoasocketserver.h
View File

@ -40,7 +40,7 @@ class MacCocoaSocketServer : public MacBaseSocketServer {
// The count of how many times we're inside the NSApplication main loop. // The count of how many times we're inside the NSApplication main loop.
int run_count_; int run_count_;
DISALLOW_COPY_AND_ASSIGN(MacCocoaSocketServer); RTC_DISALLOW_COPY_AND_ASSIGN(MacCocoaSocketServer);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/messagehandler.h
View File

@ -29,7 +29,7 @@ class MessageHandler {
MessageHandler() {} MessageHandler() {}
private: private:
DISALLOW_COPY_AND_ASSIGN(MessageHandler); RTC_DISALLOW_COPY_AND_ASSIGN(MessageHandler);
}; };
// Helper class to facilitate executing a functor on a thread. // Helper class to facilitate executing a functor on a thread.

2
webrtc/base/messagequeue.h
View File

@ -248,7 +248,7 @@ class MessageQueue {
mutable CriticalSection crit_; mutable CriticalSection crit_;
private: private:
DISALLOW_COPY_AND_ASSIGN(MessageQueue); RTC_DISALLOW_COPY_AND_ASSIGN(MessageQueue);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/multipart.h
View File

@ -75,7 +75,7 @@ class MultipartStream : public StreamInterface, public sigslot::has_slots<> {
size_t current_; // The index into parts_ of the current read position. size_t current_; // The index into parts_ of the current read position.
size_t position_; // The current read position in bytes. size_t position_; // The current read position in bytes.
DISALLOW_COPY_AND_ASSIGN(MultipartStream); RTC_DISALLOW_COPY_AND_ASSIGN(MultipartStream);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/natserver.h
View File

@ -116,7 +116,7 @@ class NATServer : public sigslot::has_slots<> {
ProxyServer* tcp_proxy_server_; ProxyServer* tcp_proxy_server_;
InternalMap* int_map_; InternalMap* int_map_;
ExternalMap* ext_map_; ExternalMap* ext_map_;
DISALLOW_COPY_AND_ASSIGN(NATServer); RTC_DISALLOW_COPY_AND_ASSIGN(NATServer);
}; };
} // namespace rtc } // namespace rtc

4
webrtc/base/natsocketfactory.h
View File

@ -56,7 +56,7 @@ class NATSocketFactory : public SocketFactory, public NATInternalSocketFactory {
SocketFactory* factory_; SocketFactory* factory_;
SocketAddress nat_udp_addr_; SocketAddress nat_udp_addr_;
SocketAddress nat_tcp_addr_; SocketAddress nat_tcp_addr_;
DISALLOW_COPY_AND_ASSIGN(NATSocketFactory); RTC_DISALLOW_COPY_AND_ASSIGN(NATSocketFactory);
}; };
// Creates sockets that will send traffic through a NAT depending on what // Creates sockets that will send traffic through a NAT depending on what
@ -153,7 +153,7 @@ class NATSocketServer : public SocketServer, public NATInternalSocketFactory {
SocketServer* server_; SocketServer* server_;
MessageQueue* msg_queue_; MessageQueue* msg_queue_;
TranslatorMap nats_; TranslatorMap nats_;
DISALLOW_COPY_AND_ASSIGN(NATSocketServer); RTC_DISALLOW_COPY_AND_ASSIGN(NATSocketServer);
}; };
// Free-standing NAT helper functions. // Free-standing NAT helper functions.

6
webrtc/base/nssidentity.h
View File

@ -60,7 +60,7 @@ class NSSKeyPair {
SECKEYPublicKey* pubkey_; SECKEYPublicKey* pubkey_;
SSLKEAType ssl_kea_type_; SSLKEAType ssl_kea_type_;
DISALLOW_COPY_AND_ASSIGN(NSSKeyPair); RTC_DISALLOW_COPY_AND_ASSIGN(NSSKeyPair);
}; };
@ -109,7 +109,7 @@ class NSSCertificate : public SSLCertificate {
CERTCertificate* certificate_; CERTCertificate* certificate_;
scoped_ptr<SSLCertChain> chain_; scoped_ptr<SSLCertChain> chain_;
DISALLOW_COPY_AND_ASSIGN(NSSCertificate); RTC_DISALLOW_COPY_AND_ASSIGN(NSSCertificate);
}; };
// Represents a SSL key pair and certificate for NSS. // Represents a SSL key pair and certificate for NSS.
@ -135,7 +135,7 @@ class NSSIdentity : public SSLIdentity {
rtc::scoped_ptr<NSSKeyPair> keypair_; rtc::scoped_ptr<NSSKeyPair> keypair_;
rtc::scoped_ptr<NSSCertificate> certificate_; rtc::scoped_ptr<NSSCertificate> certificate_;
DISALLOW_COPY_AND_ASSIGN(NSSIdentity); RTC_DISALLOW_COPY_AND_ASSIGN(NSSIdentity);
}; };
} // namespace rtc } // namespace rtc

6
webrtc/base/opensslidentity.h
View File

@ -45,7 +45,7 @@ class OpenSSLKeyPair {
EVP_PKEY* pkey_; EVP_PKEY* pkey_;
DISALLOW_COPY_AND_ASSIGN(OpenSSLKeyPair); RTC_DISALLOW_COPY_AND_ASSIGN(OpenSSLKeyPair);
}; };
// OpenSSLCertificate encapsulates an OpenSSL X509* certificate object, // OpenSSLCertificate encapsulates an OpenSSL X509* certificate object,
@ -92,7 +92,7 @@ class OpenSSLCertificate : public SSLCertificate {
X509* x509_; X509* x509_;
DISALLOW_COPY_AND_ASSIGN(OpenSSLCertificate); RTC_DISALLOW_COPY_AND_ASSIGN(OpenSSLCertificate);
}; };
// Holds a keypair and certificate together, and a method to generate // Holds a keypair and certificate together, and a method to generate
@ -120,7 +120,7 @@ class OpenSSLIdentity : public SSLIdentity {
scoped_ptr<OpenSSLKeyPair> key_pair_; scoped_ptr<OpenSSLKeyPair> key_pair_;
scoped_ptr<OpenSSLCertificate> certificate_; scoped_ptr<OpenSSLCertificate> certificate_;
DISALLOW_COPY_AND_ASSIGN(OpenSSLIdentity); RTC_DISALLOW_COPY_AND_ASSIGN(OpenSSLIdentity);
}; };

4
webrtc/base/profiler.h
View File

@ -134,7 +134,7 @@ class Profiler {
EventMap events_; EventMap events_;
mutable SharedExclusiveLock lock_; mutable SharedExclusiveLock lock_;
DISALLOW_COPY_AND_ASSIGN(Profiler); RTC_DISALLOW_COPY_AND_ASSIGN(Profiler);
}; };
// Starts an event on construction and stops it on destruction. // Starts an event on construction and stops it on destruction.
@ -151,7 +151,7 @@ class ProfilerScope {
private: private:
std::string event_name_; std::string event_name_;
DISALLOW_COPY_AND_ASSIGN(ProfilerScope); RTC_DISALLOW_COPY_AND_ASSIGN(ProfilerScope);
}; };
std::ostream& operator<<(std::ostream& stream, std::ostream& operator<<(std::ostream& stream,

6
webrtc/base/proxyserver.h
View File

@ -55,7 +55,7 @@ class ProxyBinding : public sigslot::has_slots<> {
bool connected_; bool connected_;
FifoBuffer out_buffer_; FifoBuffer out_buffer_;
FifoBuffer in_buffer_; FifoBuffer in_buffer_;
DISALLOW_COPY_AND_ASSIGN(ProxyBinding); RTC_DISALLOW_COPY_AND_ASSIGN(ProxyBinding);
}; };
class ProxyServer : public sigslot::has_slots<> { class ProxyServer : public sigslot::has_slots<> {
@ -78,7 +78,7 @@ class ProxyServer : public sigslot::has_slots<> {
SocketAddress ext_ip_; SocketAddress ext_ip_;
scoped_ptr<AsyncSocket> server_socket_; scoped_ptr<AsyncSocket> server_socket_;
BindingList bindings_; BindingList bindings_;
DISALLOW_COPY_AND_ASSIGN(ProxyServer); RTC_DISALLOW_COPY_AND_ASSIGN(ProxyServer);
}; };
// SocksProxyServer is a simple extension of ProxyServer to implement SOCKS. // SocksProxyServer is a simple extension of ProxyServer to implement SOCKS.
@ -90,7 +90,7 @@ class SocksProxyServer : public ProxyServer {
} }
protected: protected:
AsyncProxyServerSocket* WrapSocket(AsyncSocket* socket) override; AsyncProxyServerSocket* WrapSocket(AsyncSocket* socket) override;
DISALLOW_COPY_AND_ASSIGN(SocksProxyServer); RTC_DISALLOW_COPY_AND_ASSIGN(SocksProxyServer);
}; };
} // namespace rtc } // namespace rtc

4
webrtc/base/referencecountedsingletonfactory.h
View File

@ -77,7 +77,7 @@ class ReferenceCountedSingletonFactory {
CriticalSection crit_; CriticalSection crit_;
int ref_count_; int ref_count_;
DISALLOW_COPY_AND_ASSIGN(ReferenceCountedSingletonFactory); RTC_DISALLOW_COPY_AND_ASSIGN(ReferenceCountedSingletonFactory);
}; };
template <typename Interface> template <typename Interface>
@ -149,7 +149,7 @@ class rcsf_ptr {
Interface* instance_; Interface* instance_;
ReferenceCountedSingletonFactory<Interface>* factory_; ReferenceCountedSingletonFactory<Interface>* factory_;
DISALLOW_IMPLICIT_CONSTRUCTORS(rcsf_ptr); RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(rcsf_ptr);
}; };
}; // namespace rtc }; // namespace rtc

2
webrtc/base/rollingaccumulator.h
View File

@ -165,7 +165,7 @@ class RollingAccumulator {
mutable bool min_stale_; mutable bool min_stale_;
std::vector<T> samples_; std::vector<T> samples_;
DISALLOW_COPY_AND_ASSIGN(RollingAccumulator); RTC_DISALLOW_COPY_AND_ASSIGN(RollingAccumulator);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/scoped_autorelease_pool.h
View File

@ -50,7 +50,7 @@ class ScopedAutoreleasePool {
NSAutoreleasePool* pool_; NSAutoreleasePool* pool_;
DISALLOW_COPY_AND_ASSIGN(ScopedAutoreleasePool); RTC_DISALLOW_COPY_AND_ASSIGN(ScopedAutoreleasePool);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/scoped_ptr.h
View File

@ -298,7 +298,7 @@ class scoped_ptr_impl {
Data data_; Data data_;
DISALLOW_COPY_AND_ASSIGN(scoped_ptr_impl); RTC_DISALLOW_COPY_AND_ASSIGN(scoped_ptr_impl);
}; };
} // namespace internal } // namespace internal

2
webrtc/base/scopedptrcollection.h
View File

@ -52,7 +52,7 @@ class ScopedPtrCollection {
private: private:
VectorT collection_; VectorT collection_;
DISALLOW_COPY_AND_ASSIGN(ScopedPtrCollection); RTC_DISALLOW_COPY_AND_ASSIGN(ScopedPtrCollection);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/scopedptrcollection_unittest.cc
View File

@ -28,7 +28,7 @@ class InstanceCounter {
private: private:
int* num_instances_; int* num_instances_;
DISALLOW_COPY_AND_ASSIGN(InstanceCounter); RTC_DISALLOW_COPY_AND_ASSIGN(InstanceCounter);
}; };
} // namespace } // namespace

6
webrtc/base/sharedexclusivelock.h
View File

@ -36,7 +36,7 @@ class LOCKABLE SharedExclusiveLock {
rtc::Event shared_count_is_zero_; rtc::Event shared_count_is_zero_;
int shared_count_; int shared_count_;
DISALLOW_COPY_AND_ASSIGN(SharedExclusiveLock); RTC_DISALLOW_COPY_AND_ASSIGN(SharedExclusiveLock);
}; };
class SCOPED_LOCKABLE SharedScope { class SCOPED_LOCKABLE SharedScope {
@ -51,7 +51,7 @@ class SCOPED_LOCKABLE SharedScope {
private: private:
SharedExclusiveLock* lock_; SharedExclusiveLock* lock_;
DISALLOW_COPY_AND_ASSIGN(SharedScope); RTC_DISALLOW_COPY_AND_ASSIGN(SharedScope);
}; };
class SCOPED_LOCKABLE ExclusiveScope { class SCOPED_LOCKABLE ExclusiveScope {
@ -67,7 +67,7 @@ class SCOPED_LOCKABLE ExclusiveScope {
private: private:
SharedExclusiveLock* lock_; SharedExclusiveLock* lock_;
DISALLOW_COPY_AND_ASSIGN(ExclusiveScope); RTC_DISALLOW_COPY_AND_ASSIGN(ExclusiveScope);
}; };
} // namespace rtc } // namespace rtc

6
webrtc/base/signalthread.h
View File

@ -112,7 +112,7 @@ class SignalThread
private: private:
SignalThread* parent_; SignalThread* parent_;
DISALLOW_IMPLICIT_CONSTRUCTORS(Worker); RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Worker);
}; };
class SCOPED_LOCKABLE EnterExit { class SCOPED_LOCKABLE EnterExit {
@ -135,7 +135,7 @@ class SignalThread
private: private:
SignalThread* t_; SignalThread* t_;
DISALLOW_IMPLICIT_CONSTRUCTORS(EnterExit); RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(EnterExit);
}; };
void Run(); void Run();
@ -147,7 +147,7 @@ class SignalThread
State state_; State state_;
int refcount_; int refcount_;
DISALLOW_COPY_AND_ASSIGN(SignalThread); RTC_DISALLOW_COPY_AND_ASSIGN(SignalThread);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////

4
webrtc/base/signalthread_unittest.cc
View File

@ -57,7 +57,7 @@ class SignalThreadTest : public testing::Test, public sigslot::has_slots<> {
private: private:
SignalThreadTest* harness_; SignalThreadTest* harness_;
DISALLOW_COPY_AND_ASSIGN(SlowSignalThread); RTC_DISALLOW_COPY_AND_ASSIGN(SlowSignalThread);
}; };
void OnWorkComplete(rtc::SignalThread* thread) { void OnWorkComplete(rtc::SignalThread* thread) {
@ -128,7 +128,7 @@ class OwnerThread : public Thread, public sigslot::has_slots<> {
private: private:
SignalThreadTest* harness_; SignalThreadTest* harness_;
bool has_run_; bool has_run_;
DISALLOW_COPY_AND_ASSIGN(OwnerThread); RTC_DISALLOW_COPY_AND_ASSIGN(OwnerThread);
}; };
// Test for when the main thread goes away while the // Test for when the main thread goes away while the

10
webrtc/base/sigslottester.h
View File

@ -71,7 +71,7 @@ class SigslotTester1 : public sigslot::has_slots<> {
int callback_count_; int callback_count_;
C1* capture1_; C1* capture1_;
DISALLOW_COPY_AND_ASSIGN(SigslotTester1); RTC_DISALLOW_COPY_AND_ASSIGN(SigslotTester1);
}; };
template <class A1, class A2, class C1, class C2> template <class A1, class A2, class C1, class C2>
@ -97,7 +97,7 @@ class SigslotTester2 : public sigslot::has_slots<> {
C1* capture1_; C1* capture1_;
C2* capture2_; C2* capture2_;
DISALLOW_COPY_AND_ASSIGN(SigslotTester2); RTC_DISALLOW_COPY_AND_ASSIGN(SigslotTester2);
}; };
template <class A1, class A2, class A3, class C1, class C2, class C3> template <class A1, class A2, class A3, class C1, class C2, class C3>
@ -125,7 +125,7 @@ class SigslotTester3 : public sigslot::has_slots<> {
C2* capture2_; C2* capture2_;
C3* capture3_; C3* capture3_;
DISALLOW_COPY_AND_ASSIGN(SigslotTester3); RTC_DISALLOW_COPY_AND_ASSIGN(SigslotTester3);
}; };
template <class A1, class A2, class A3, class A4, class C1, class C2, class C3, template <class A1, class A2, class A3, class A4, class C1, class C2, class C3,
@ -157,7 +157,7 @@ class SigslotTester4 : public sigslot::has_slots<> {
C3* capture3_; C3* capture3_;
C4* capture4_; C4* capture4_;
DISALLOW_COPY_AND_ASSIGN(SigslotTester4); RTC_DISALLOW_COPY_AND_ASSIGN(SigslotTester4);
}; };
template <class A1, class A2, class A3, class A4, class A5, class C1, class C2, template <class A1, class A2, class A3, class A4, class A5, class C1, class C2,
@ -192,7 +192,7 @@ class SigslotTester5 : public sigslot::has_slots<> {
C4* capture4_; C4* capture4_;
C5* capture5_; C5* capture5_;
DISALLOW_COPY_AND_ASSIGN(SigslotTester5); RTC_DISALLOW_COPY_AND_ASSIGN(SigslotTester5);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/sigslottester.h.pump
View File

@ -76,7 +76,7 @@ class SigslotTester$i : public sigslot::has_slots<> {
C$j* capture$j[[]]_;]] C$j* capture$j[[]]_;]]
DISALLOW_COPY_AND_ASSIGN(SigslotTester$i); RTC_DISALLOW_COPY_AND_ASSIGN(SigslotTester$i);
}; };
]] ]]

4
webrtc/base/socket.h
View File

@ -109,7 +109,7 @@
#define EREMOTE WSAEREMOTE #define EREMOTE WSAEREMOTE
#undef EACCES #undef EACCES
#define SOCKET_EACCES WSAEACCES #define SOCKET_EACCES WSAEACCES
#endif // WEBRTC_WIN #endif // WEBRTC_WIN
#if defined(WEBRTC_POSIX) #if defined(WEBRTC_POSIX)
#define INVALID_SOCKET (-1) #define INVALID_SOCKET (-1)
@ -180,7 +180,7 @@ class Socket {
Socket() {} Socket() {}
private: private:
DISALLOW_COPY_AND_ASSIGN(Socket); RTC_DISALLOW_COPY_AND_ASSIGN(Socket);
}; };
} // namespace rtc } // namespace rtc

16
webrtc/base/socketadapters.h
View File

@ -50,7 +50,7 @@ class BufferedReadAdapter : public AsyncSocketAdapter {
char * buffer_; char * buffer_;
size_t buffer_size_, data_len_; size_t buffer_size_, data_len_;
bool buffering_; bool buffering_;
DISALLOW_COPY_AND_ASSIGN(BufferedReadAdapter); RTC_DISALLOW_COPY_AND_ASSIGN(BufferedReadAdapter);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -78,7 +78,7 @@ class AsyncSSLSocket : public BufferedReadAdapter {
protected: protected:
void OnConnectEvent(AsyncSocket* socket) override; void OnConnectEvent(AsyncSocket* socket) override;
void ProcessInput(char* data, size_t* len) override; void ProcessInput(char* data, size_t* len) override;
DISALLOW_COPY_AND_ASSIGN(AsyncSSLSocket); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncSSLSocket);
}; };
// Implements a socket adapter that performs the server side of a // Implements a socket adapter that performs the server side of a
@ -89,7 +89,7 @@ class AsyncSSLServerSocket : public BufferedReadAdapter {
protected: protected:
void ProcessInput(char* data, size_t* len) override; void ProcessInput(char* data, size_t* len) override;
DISALLOW_COPY_AND_ASSIGN(AsyncSSLServerSocket); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncSSLServerSocket);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -137,7 +137,7 @@ class AsyncHttpsProxySocket : public BufferedReadAdapter {
} state_; } state_;
HttpAuthContext * context_; HttpAuthContext * context_;
std::string unknown_mechanisms_; std::string unknown_mechanisms_;
DISALLOW_COPY_AND_ASSIGN(AsyncHttpsProxySocket); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncHttpsProxySocket);
}; };
/* TODO: Implement this. /* TODO: Implement this.
@ -148,7 +148,7 @@ class AsyncHttpsProxyServerSocket : public AsyncProxyServerSocket {
private: private:
virtual void ProcessInput(char * data, size_t& len); virtual void ProcessInput(char * data, size_t& len);
void Error(int error); void Error(int error);
DISALLOW_COPY_AND_ASSIGN(AsyncHttpsProxyServerSocket); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncHttpsProxyServerSocket);
}; };
*/ */
@ -183,7 +183,7 @@ class AsyncSocksProxySocket : public BufferedReadAdapter {
SocketAddress proxy_, dest_; SocketAddress proxy_, dest_;
std::string user_; std::string user_;
CryptString pass_; CryptString pass_;
DISALLOW_COPY_AND_ASSIGN(AsyncSocksProxySocket); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncSocksProxySocket);
}; };
// Implements a proxy server socket for the SOCKS protocol. // Implements a proxy server socket for the SOCKS protocol.
@ -209,7 +209,7 @@ class AsyncSocksProxyServerSocket : public AsyncProxyServerSocket {
SS_HELLO, SS_AUTH, SS_CONNECT, SS_CONNECT_PENDING, SS_TUNNEL, SS_ERROR SS_HELLO, SS_AUTH, SS_CONNECT, SS_CONNECT_PENDING, SS_TUNNEL, SS_ERROR
}; };
State state_; State state_;
DISALLOW_COPY_AND_ASSIGN(AsyncSocksProxyServerSocket); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncSocksProxyServerSocket);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -235,7 +235,7 @@ class LoggingSocketAdapter : public AsyncSocketAdapter {
std::string label_; std::string label_;
bool hex_mode_; bool hex_mode_;
LogMultilineState lms_; LogMultilineState lms_;
DISALLOW_COPY_AND_ASSIGN(LoggingSocketAdapter); RTC_DISALLOW_COPY_AND_ASSIGN(LoggingSocketAdapter);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////

2
webrtc/base/socketstream.h
View File

@ -51,7 +51,7 @@ class SocketStream : public StreamInterface, public sigslot::has_slots<> {
AsyncSocket* socket_; AsyncSocket* socket_;
DISALLOW_COPY_AND_ASSIGN(SocketStream); RTC_DISALLOW_COPY_AND_ASSIGN(SocketStream);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////

2
webrtc/base/sslidentity.h
View File

@ -104,7 +104,7 @@ class SSLCertChain {
std::vector<SSLCertificate*> certs_; std::vector<SSLCertificate*> certs_;
DISALLOW_COPY_AND_ASSIGN(SSLCertChain); RTC_DISALLOW_COPY_AND_ASSIGN(SSLCertChain);
}; };
// TODO(hbos, torbjorng): Don't change KT_DEFAULT without first // TODO(hbos, torbjorng): Don't change KT_DEFAULT without first

18
webrtc/base/stream.h
View File

@ -228,7 +228,7 @@ class StreamInterface : public MessageHandler {
void OnMessage(Message* msg) override; void OnMessage(Message* msg) override;
private: private:
DISALLOW_COPY_AND_ASSIGN(StreamInterface); RTC_DISALLOW_COPY_AND_ASSIGN(StreamInterface);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -305,7 +305,7 @@ class StreamAdapterInterface : public StreamInterface,
private: private:
StreamInterface* stream_; StreamInterface* stream_;
bool owned_; bool owned_;
DISALLOW_COPY_AND_ASSIGN(StreamAdapterInterface); RTC_DISALLOW_COPY_AND_ASSIGN(StreamAdapterInterface);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -337,7 +337,7 @@ class StreamTap : public StreamAdapterInterface {
scoped_ptr<StreamInterface> tap_; scoped_ptr<StreamInterface> tap_;
StreamResult tap_result_; StreamResult tap_result_;
int tap_error_; int tap_error_;
DISALLOW_COPY_AND_ASSIGN(StreamTap); RTC_DISALLOW_COPY_AND_ASSIGN(StreamTap);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -415,7 +415,7 @@ class FileStream : public StreamInterface {
FILE* file_; FILE* file_;
private: private:
DISALLOW_COPY_AND_ASSIGN(FileStream); RTC_DISALLOW_COPY_AND_ASSIGN(FileStream);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -458,7 +458,7 @@ class MemoryStreamBase : public StreamInterface {
size_t seek_position_; size_t seek_position_;
private: private:
DISALLOW_COPY_AND_ASSIGN(MemoryStreamBase); RTC_DISALLOW_COPY_AND_ASSIGN(MemoryStreamBase);
}; };
// MemoryStream dynamically resizes to accomodate written data. // MemoryStream dynamically resizes to accomodate written data.
@ -556,7 +556,7 @@ class FifoBuffer : public StreamInterface {
size_t read_position_; // offset to the readable data size_t read_position_; // offset to the readable data
Thread* owner_; // stream callbacks are dispatched on this thread Thread* owner_; // stream callbacks are dispatched on this thread
mutable CriticalSection crit_; // object lock mutable CriticalSection crit_; // object lock
DISALLOW_COPY_AND_ASSIGN(FifoBuffer); RTC_DISALLOW_COPY_AND_ASSIGN(FifoBuffer);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -587,7 +587,7 @@ class LoggingAdapter : public StreamAdapterInterface {
bool hex_mode_; bool hex_mode_;
LogMultilineState lms_; LogMultilineState lms_;
DISALLOW_COPY_AND_ASSIGN(LoggingAdapter); RTC_DISALLOW_COPY_AND_ASSIGN(LoggingAdapter);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -670,7 +670,7 @@ class StreamReference : public StreamAdapterInterface {
StreamInterface* stream_; StreamInterface* stream_;
int ref_count_; int ref_count_;
CriticalSection cs_; CriticalSection cs_;
DISALLOW_COPY_AND_ASSIGN(StreamRefCount); RTC_DISALLOW_COPY_AND_ASSIGN(StreamRefCount);
}; };
// Constructor for adding references // Constructor for adding references
@ -678,7 +678,7 @@ class StreamReference : public StreamAdapterInterface {
StreamInterface* stream); StreamInterface* stream);
StreamRefCount* stream_ref_count_; StreamRefCount* stream_ref_count_;
DISALLOW_COPY_AND_ASSIGN(StreamReference); RTC_DISALLOW_COPY_AND_ASSIGN(StreamReference);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////

16
webrtc/base/task_unittest.cc
View File

@ -18,7 +18,7 @@
#if defined(WEBRTC_WIN) #if defined(WEBRTC_WIN)
#include "webrtc/base/win32.h" #include "webrtc/base/win32.h"
#endif // WEBRTC_WIN #endif // WEBRTC_WIN
#include "webrtc/base/common.h" #include "webrtc/base/common.h"
#include "webrtc/base/gunit.h" #include "webrtc/base/gunit.h"
@ -270,7 +270,7 @@ class TaskTest : public sigslot::has_slots<> {
EXPECT_TRUE(stuck_[i].timed_out_); EXPECT_TRUE(stuck_[i].timed_out_);
if (!stuck_[i].timed_out_) { if (!stuck_[i].timed_out_) {
std::cout << "Stuck task #" << i << " timeout is at " std::cout << "Stuck task #" << i << " timeout is at "
<< stuck_[i].task_->timeout_time() << std::endl; << stuck_[i].task_->timeout_time() << std::endl;
} }
} }
@ -308,7 +308,7 @@ class AbortTask : public Task {
return STATE_NEXT; return STATE_NEXT;
} }
private: private:
DISALLOW_COPY_AND_ASSIGN(AbortTask); RTC_DISALLOW_COPY_AND_ASSIGN(AbortTask);
}; };
class TaskAbortTest : public sigslot::has_slots<> { class TaskAbortTest : public sigslot::has_slots<> {
@ -333,7 +333,7 @@ class TaskAbortTest : public sigslot::has_slots<> {
} }
MyTaskRunner task_runner_; MyTaskRunner task_runner_;
DISALLOW_COPY_AND_ASSIGN(TaskAbortTest); RTC_DISALLOW_COPY_AND_ASSIGN(TaskAbortTest);
}; };
TEST(start_task_test, Abort) { TEST(start_task_test, Abort) {
@ -363,7 +363,7 @@ class SetBoolOnDeleteTask : public Task {
private: private:
bool* set_when_deleted_; bool* set_when_deleted_;
DISALLOW_COPY_AND_ASSIGN(SetBoolOnDeleteTask); RTC_DISALLOW_COPY_AND_ASSIGN(SetBoolOnDeleteTask);
}; };
class AbortShouldWakeTest : public sigslot::has_slots<> { class AbortShouldWakeTest : public sigslot::has_slots<> {
@ -396,7 +396,7 @@ class AbortShouldWakeTest : public sigslot::has_slots<> {
} }
MyTaskRunner task_runner_; MyTaskRunner task_runner_;
DISALLOW_COPY_AND_ASSIGN(AbortShouldWakeTest); RTC_DISALLOW_COPY_AND_ASSIGN(AbortShouldWakeTest);
}; };
TEST(start_task_test, AbortShouldWake) { TEST(start_task_test, AbortShouldWake) {
@ -477,7 +477,7 @@ class TimeoutChangeTest : public sigslot::has_slots<> {
MyTaskRunner task_runner_; MyTaskRunner task_runner_;
StuckTask* (stuck_tasks_[3]); StuckTask* (stuck_tasks_[3]);
int task_count_; int task_count_;
DISALLOW_COPY_AND_ASSIGN(TimeoutChangeTest); RTC_DISALLOW_COPY_AND_ASSIGN(TimeoutChangeTest);
}; };
TEST(start_task_test, TimeoutChange) { TEST(start_task_test, TimeoutChange) {
@ -494,7 +494,7 @@ class DeleteTestTaskRunner : public TaskRunner {
return GetCurrentTime(); return GetCurrentTime();
} }
private: private:
DISALLOW_COPY_AND_ASSIGN(DeleteTestTaskRunner); RTC_DISALLOW_COPY_AND_ASSIGN(DeleteTestTaskRunner);
}; };
TEST(unstarted_task_test, DeleteTask) { TEST(unstarted_task_test, DeleteTask) {

2
webrtc/base/taskparent.h
View File

@ -53,7 +53,7 @@ class TaskParent {
bool child_error_; bool child_error_;
typedef std::set<Task *> ChildSet; typedef std::set<Task *> ChildSet;
scoped_ptr<ChildSet> children_; scoped_ptr<ChildSet> children_;
DISALLOW_COPY_AND_ASSIGN(TaskParent); RTC_DISALLOW_COPY_AND_ASSIGN(TaskParent);
}; };

2
webrtc/base/testclient.h
View File

@ -89,7 +89,7 @@ class TestClient : public sigslot::has_slots<> {
AsyncPacketSocket* socket_; AsyncPacketSocket* socket_;
std::vector<Packet*>* packets_; std::vector<Packet*>* packets_;
bool ready_to_send_; bool ready_to_send_;
DISALLOW_COPY_AND_ASSIGN(TestClient); RTC_DISALLOW_COPY_AND_ASSIGN(TestClient);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/testechoserver.h
View File

@ -65,7 +65,7 @@ class TestEchoServer : public sigslot::has_slots<> {
typedef std::list<AsyncTCPSocket*> ClientList; typedef std::list<AsyncTCPSocket*> ClientList;
scoped_ptr<AsyncSocket> server_socket_; scoped_ptr<AsyncSocket> server_socket_;
ClientList client_sockets_; ClientList client_sockets_;
DISALLOW_COPY_AND_ASSIGN(TestEchoServer); RTC_DISALLOW_COPY_AND_ASSIGN(TestEchoServer);
}; };
} // namespace rtc } // namespace rtc

12
webrtc/base/thread.h
View File

@ -68,7 +68,7 @@ class ThreadManager {
DWORD key_; DWORD key_;
#endif #endif
DISALLOW_COPY_AND_ASSIGN(ThreadManager); RTC_DISALLOW_COPY_AND_ASSIGN(ThreadManager);
}; };
struct _SendMessage { struct _SendMessage {
@ -94,7 +94,7 @@ class Runnable {
Runnable() {} Runnable() {}
private: private:
DISALLOW_COPY_AND_ASSIGN(Runnable); RTC_DISALLOW_COPY_AND_ASSIGN(Runnable);
}; };
// WARNING! SUBCLASSES MUST CALL Stop() IN THEIR DESTRUCTORS! See ~Thread(). // WARNING! SUBCLASSES MUST CALL Stop() IN THEIR DESTRUCTORS! See ~Thread().
@ -287,7 +287,7 @@ class Thread : public MessageQueue {
friend class ThreadManager; friend class ThreadManager;
DISALLOW_COPY_AND_ASSIGN(Thread); RTC_DISALLOW_COPY_AND_ASSIGN(Thread);
}; };
// AutoThread automatically installs itself at construction // AutoThread automatically installs itself at construction
@ -300,7 +300,7 @@ class AutoThread : public Thread {
~AutoThread() override; ~AutoThread() override;
private: private:
DISALLOW_COPY_AND_ASSIGN(AutoThread); RTC_DISALLOW_COPY_AND_ASSIGN(AutoThread);
}; };
// Win32 extension for threads that need to use COM // Win32 extension for threads that need to use COM
@ -314,7 +314,7 @@ class ComThread : public Thread {
virtual void Run(); virtual void Run();
private: private:
DISALLOW_COPY_AND_ASSIGN(ComThread); RTC_DISALLOW_COPY_AND_ASSIGN(ComThread);
}; };
#endif #endif
@ -332,7 +332,7 @@ class SocketServerScope {
private: private:
SocketServer* old_ss_; SocketServer* old_ss_;
DISALLOW_IMPLICIT_CONSTRUCTORS(SocketServerScope); RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(SocketServerScope);
}; };
} // namespace rtc } // namespace rtc

6
webrtc/base/thread_checker_unittest.cc
View File

@ -49,7 +49,7 @@ class ThreadCheckerClass : public ThreadChecker {
static void DetachThenCallFromDifferentThreadImpl(); static void DetachThenCallFromDifferentThreadImpl();
private: private:
DISALLOW_COPY_AND_ASSIGN(ThreadCheckerClass); RTC_DISALLOW_COPY_AND_ASSIGN(ThreadCheckerClass);
}; };
// Calls ThreadCheckerClass::DoStuff on another thread. // Calls ThreadCheckerClass::DoStuff on another thread.
@ -72,7 +72,7 @@ class CallDoStuffOnThread : public Thread {
private: private:
ThreadCheckerClass* thread_checker_class_; ThreadCheckerClass* thread_checker_class_;
DISALLOW_COPY_AND_ASSIGN(CallDoStuffOnThread); RTC_DISALLOW_COPY_AND_ASSIGN(CallDoStuffOnThread);
}; };
// Deletes ThreadCheckerClass on a different thread. // Deletes ThreadCheckerClass on a different thread.
@ -96,7 +96,7 @@ class DeleteThreadCheckerClassOnThread : public Thread {
private: private:
scoped_ptr<ThreadCheckerClass> thread_checker_class_; scoped_ptr<ThreadCheckerClass> thread_checker_class_;
DISALLOW_COPY_AND_ASSIGN(DeleteThreadCheckerClassOnThread); RTC_DISALLOW_COPY_AND_ASSIGN(DeleteThreadCheckerClassOnThread);
}; };
} // namespace } // namespace

2
webrtc/base/virtualsocketserver.h
View File

@ -243,7 +243,7 @@ class VirtualSocketServer : public SocketServer, public sigslot::has_slots<> {
CriticalSection delay_crit_; CriticalSection delay_crit_;
double drop_prob_; double drop_prob_;
DISALLOW_COPY_AND_ASSIGN(VirtualSocketServer); RTC_DISALLOW_COPY_AND_ASSIGN(VirtualSocketServer);
}; };
// Implements the socket interface using the virtual network. Packets are // Implements the socket interface using the virtual network. Packets are

2
webrtc/base/win32regkey.h
View File

@ -329,7 +329,7 @@ class RegKey {
// for unittest // for unittest
friend void RegKeyHelperFunctionsTest(); friend void RegKeyHelperFunctionsTest();
DISALLOW_COPY_AND_ASSIGN(RegKey); RTC_DISALLOW_COPY_AND_ASSIGN(RegKey);
}; };
} // namespace rtc } // namespace rtc

2
webrtc/base/worker.h
View File

@ -64,7 +64,7 @@ class Worker : private MessageHandler {
// The thread that is currently doing the work. // The thread that is currently doing the work.
Thread *worker_thread_; Thread *worker_thread_;
DISALLOW_COPY_AND_ASSIGN(Worker); RTC_DISALLOW_COPY_AND_ASSIGN(Worker);
}; };
} // namespace rtc } // namespace rtc

4
webrtc/base/x11windowpicker.cc
View File

@ -73,7 +73,7 @@ class XWindowProperty {
unsigned long size_; // NOLINT: type required by XGetWindowProperty unsigned long size_; // NOLINT: type required by XGetWindowProperty
unsigned char* data_; unsigned char* data_;
DISALLOW_COPY_AND_ASSIGN(XWindowProperty); RTC_DISALLOW_COPY_AND_ASSIGN(XWindowProperty);
}; };
// Stupid X11. It seems none of the synchronous returns codes from X11 calls // Stupid X11. It seems none of the synchronous returns codes from X11 calls
@ -118,7 +118,7 @@ class XErrorSuppressor {
Display* display_; Display* display_;
XErrorHandler original_error_handler_; XErrorHandler original_error_handler_;
DISALLOW_COPY_AND_ASSIGN(XErrorSuppressor); RTC_DISALLOW_COPY_AND_ASSIGN(XErrorSuppressor);
}; };
// Hiding all X11 specifics inside its own class. This to avoid // Hiding all X11 specifics inside its own class. This to avoid

2
webrtc/common.h
View File

@ -95,7 +95,7 @@ class Config {
typedef std::map<OptionIdentifier, BaseOption*> OptionMap; typedef std::map<OptionIdentifier, BaseOption*> OptionMap;
OptionMap options_; OptionMap options_;
// DISALLOW_COPY_AND_ASSIGN // RTC_DISALLOW_COPY_AND_ASSIGN
Config(const Config&); Config(const Config&);
void operator=(const Config&); void operator=(const Config&);
}; };

2
webrtc/common_audio/audio_converter.h
View File

@ -58,7 +58,7 @@ class AudioConverter {
const int dst_channels_; const int dst_channels_;
const size_t dst_frames_; const size_t dst_frames_;
DISALLOW_COPY_AND_ASSIGN(AudioConverter); RTC_DISALLOW_COPY_AND_ASSIGN(AudioConverter);
}; };
} // namespace webrtc } // namespace webrtc

2
webrtc/common_audio/resampler/push_sinc_resampler.h
View File

@ -68,7 +68,7 @@ class PushSincResampler : public SincResamplerCallback {
// Used to assert we are only requested for as much data as is available. // Used to assert we are only requested for as much data as is available.
size_t source_available_; size_t source_available_;
DISALLOW_COPY_AND_ASSIGN(PushSincResampler); RTC_DISALLOW_COPY_AND_ASSIGN(PushSincResampler);
}; };
} // namespace webrtc } // namespace webrtc

2
webrtc/common_audio/resampler/sinc_resampler.h
View File

@ -162,7 +162,7 @@ class SincResampler {
float* r3_; float* r3_;
float* r4_; float* r4_;
DISALLOW_COPY_AND_ASSIGN(SincResampler); RTC_DISALLOW_COPY_AND_ASSIGN(SincResampler);
}; };
} // namespace webrtc } // namespace webrtc

2
webrtc/common_audio/resampler/sinusoidal_linear_chirp_source.h
View File

@ -47,7 +47,7 @@ class SinusoidalLinearChirpSource : public SincResamplerCallback {
size_t current_index_; size_t current_index_;
double delay_samples_; double delay_samples_;
DISALLOW_COPY_AND_ASSIGN(SinusoidalLinearChirpSource); RTC_DISALLOW_COPY_AND_ASSIGN(SinusoidalLinearChirpSource);
}; };
} // namespace webrtc } // namespace webrtc

2
webrtc/common_audio/sparse_fir_filter.h
View File

@ -44,7 +44,7 @@ class SparseFIRFilter final {
const std::vector<float> nonzero_coeffs_; const std::vector<float> nonzero_coeffs_;
std::vector<float> state_; std::vector<float> state_;
DISALLOW_COPY_AND_ASSIGN(SparseFIRFilter); RTC_DISALLOW_COPY_AND_ASSIGN(SparseFIRFilter);
}; };
} // namespace webrtc } // namespace webrtc

4
webrtc/common_audio/wav_file.h
View File

@ -58,7 +58,7 @@ class WavWriter final : public WavFile {
uint32_t num_samples_; // Total number of samples written to file. uint32_t num_samples_; // Total number of samples written to file.
FILE* file_handle_; // Output file, owned by this class FILE* file_handle_; // Output file, owned by this class
DISALLOW_COPY_AND_ASSIGN(WavWriter); RTC_DISALLOW_COPY_AND_ASSIGN(WavWriter);
}; };
// Follows the conventions of WavWriter. // Follows the conventions of WavWriter.
@ -87,7 +87,7 @@ class WavReader final : public WavFile {
uint32_t num_samples_remaining_; uint32_t num_samples_remaining_;
FILE* file_handle_; // Input file, owned by this class. FILE* file_handle_; // Input file, owned by this class.
DISALLOW_COPY_AND_ASSIGN(WavReader); RTC_DISALLOW_COPY_AND_ASSIGN(WavReader);
}; };
} // namespace webrtc } // namespace webrtc

2
webrtc/common_audio/window_generator.h
View File

@ -24,7 +24,7 @@ class WindowGenerator {
static void KaiserBesselDerived(float alpha, size_t length, float* window); static void KaiserBesselDerived(float alpha, size_t length, float* window);
private: private:
DISALLOW_IMPLICIT_CONSTRUCTORS(WindowGenerator); RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WindowGenerator);
}; };
} // namespace webrtc } // namespace webrtc

2
webrtc/libjingle/xmpp/pubsubstateclient.h
View File

@ -263,7 +263,7 @@ class PubSubStateClient : public sigslot::has_slots<> {
// itemid => StateItemInfo // itemid => StateItemInfo
std::map<std::string, StateItemInfo> info_by_itemid_; std::map<std::string, StateItemInfo> info_by_itemid_;
DISALLOW_COPY_AND_ASSIGN(PubSubStateClient); RTC_DISALLOW_COPY_AND_ASSIGN(PubSubStateClient);
}; };
} // namespace buzz } // namespace buzz

6
webrtc/libjingle/xmpp/xmpptask.h
View File

@ -67,7 +67,7 @@ class XmppClientInterface {
virtual void RemoveXmppTask(XmppTask* task) = 0; virtual void RemoveXmppTask(XmppTask* task) = 0;
sigslot::signal0<> SignalDisconnected; sigslot::signal0<> SignalDisconnected;
DISALLOW_COPY_AND_ASSIGN(XmppClientInterface); RTC_DISALLOW_COPY_AND_ASSIGN(XmppClientInterface);
}; };
// XmppTaskParentInterface is the interface require for any parent of // XmppTaskParentInterface is the interface require for any parent of
@ -86,7 +86,7 @@ class XmppTaskParentInterface : public rtc::Task {
virtual XmppClientInterface* GetClient() = 0; virtual XmppClientInterface* GetClient() = 0;
DISALLOW_COPY_AND_ASSIGN(XmppTaskParentInterface); RTC_DISALLOW_COPY_AND_ASSIGN(XmppTaskParentInterface);
}; };
class XmppTaskBase : public XmppTaskParentInterface { class XmppTaskBase : public XmppTaskParentInterface {
@ -104,7 +104,7 @@ class XmppTaskBase : public XmppTaskParentInterface {
protected: protected:
XmppTaskParentInterface* parent_; XmppTaskParentInterface* parent_;
DISALLOW_COPY_AND_ASSIGN(XmppTaskBase); RTC_DISALLOW_COPY_AND_ASSIGN(XmppTaskBase);
}; };
class XmppTask : public XmppTaskBase, class XmppTask : public XmppTaskBase,

2
webrtc/modules/audio_coding/codecs/audio_decoder.h
View File

@ -115,7 +115,7 @@ class AudioDecoder {
SpeechType* speech_type); SpeechType* speech_type);
private: private:
DISALLOW_COPY_AND_ASSIGN(AudioDecoder); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoder);
}; };
} // namespace webrtc } // namespace webrtc

4
webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h
View File

@ -91,7 +91,7 @@ class AudioEncoderIsacT final : public AudioEncoder {
// Timestamp of the previously encoded packet. // Timestamp of the previously encoded packet.
uint32_t last_encoded_timestamp_; uint32_t last_encoded_timestamp_;
DISALLOW_COPY_AND_ASSIGN(AudioEncoderIsacT); RTC_DISALLOW_COPY_AND_ASSIGN(AudioEncoderIsacT);
}; };
template <typename T> template <typename T>
@ -122,7 +122,7 @@ class AudioDecoderIsacT final : public AudioDecoder {
LockedIsacBandwidthInfo* bwinfo_; LockedIsacBandwidthInfo* bwinfo_;
int decoder_sample_rate_hz_; int decoder_sample_rate_hz_;
DISALLOW_COPY_AND_ASSIGN(AudioDecoderIsacT); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderIsacT);
}; };
} // namespace webrtc } // namespace webrtc

2
webrtc/modules/audio_coding/codecs/opus/interface/audio_decoder_opus.h
View File

@ -43,7 +43,7 @@ class AudioDecoderOpus : public AudioDecoder {
private: private:
OpusDecInst* dec_state_; OpusDecInst* dec_state_;
const size_t channels_; const size_t channels_;
DISALLOW_COPY_AND_ASSIGN(AudioDecoderOpus); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderOpus);
}; };
} // namespace webrtc } // namespace webrtc

2
webrtc/modules/audio_coding/main/acm2/acm_receive_test.h
View File

@ -56,7 +56,7 @@ class AcmReceiveTest {
const int output_freq_hz_; const int output_freq_hz_;
NumOutputChannels expected_output_channels_; NumOutputChannels expected_output_channels_;
DISALLOW_COPY_AND_ASSIGN(AcmReceiveTest); RTC_DISALLOW_COPY_AND_ASSIGN(AcmReceiveTest);
}; };
} // namespace test } // namespace test

2
webrtc/modules/audio_coding/main/acm2/acm_receive_test_oldapi.h
View File

@ -64,7 +64,7 @@ class AcmReceiveTestOldApi {
int output_freq_hz_; int output_freq_hz_;
NumOutputChannels exptected_output_channels_; NumOutputChannels exptected_output_channels_;
DISALLOW_COPY_AND_ASSIGN(AcmReceiveTestOldApi); RTC_DISALLOW_COPY_AND_ASSIGN(AcmReceiveTestOldApi);
}; };
// This test toggles the output frequency every |toggle_period_ms|. The test // This test toggles the output frequency every |toggle_period_ms|. The test

2
webrtc/modules/audio_coding/main/acm2/acm_send_test.h
View File

@ -74,7 +74,7 @@ class AcmSendTest : public AudioPacketizationCallback, public PacketSource {
uint16_t sequence_number_; uint16_t sequence_number_;
std::vector<uint8_t> last_payload_vec_; std::vector<uint8_t> last_payload_vec_;
DISALLOW_COPY_AND_ASSIGN(AcmSendTest); RTC_DISALLOW_COPY_AND_ASSIGN(AcmSendTest);
}; };
} // namespace test } // namespace test

2
webrtc/modules/audio_coding/main/acm2/acm_send_test_oldapi.h
View File

@ -83,7 +83,7 @@ class AcmSendTestOldApi : public AudioPacketizationCallback,
std::vector<uint8_t> last_payload_vec_; std::vector<uint8_t> last_payload_vec_;
bool data_to_send_; bool data_to_send_;
DISALLOW_COPY_AND_ASSIGN(AcmSendTestOldApi); RTC_DISALLOW_COPY_AND_ASSIGN(AcmSendTestOldApi);
}; };
} // namespace test } // namespace test

2
webrtc/modules/audio_coding/main/acm2/codec_manager.h
View File

@ -82,7 +82,7 @@ class CodecManager final {
CodecOwner codec_owner_; CodecOwner codec_owner_;
bool encoder_is_opus_; bool encoder_is_opus_;
DISALLOW_COPY_AND_ASSIGN(CodecManager); RTC_DISALLOW_COPY_AND_ASSIGN(CodecManager);
}; };
} // namespace acm2 } // namespace acm2

2
webrtc/modules/audio_coding/main/acm2/codec_owner.h
View File

@ -70,7 +70,7 @@ class CodecOwner {
rtc::scoped_ptr<AudioEncoder> cng_encoder_; rtc::scoped_ptr<AudioEncoder> cng_encoder_;
rtc::scoped_ptr<AudioEncoder> red_encoder_; rtc::scoped_ptr<AudioEncoder> red_encoder_;
DISALLOW_COPY_AND_ASSIGN(CodecOwner); RTC_DISALLOW_COPY_AND_ASSIGN(CodecOwner);
}; };
} // namespace acm2 } // namespace acm2

2
webrtc/modules/audio_coding/neteq/accelerate.h
View File

@ -65,7 +65,7 @@ class Accelerate : public TimeStretch {
AudioMultiVector* output) const override; AudioMultiVector* output) const override;
private: private:
DISALLOW_COPY_AND_ASSIGN(Accelerate); RTC_DISALLOW_COPY_AND_ASSIGN(Accelerate);
}; };
struct AccelerateFactory { struct AccelerateFactory {

20
webrtc/modules/audio_coding/neteq/audio_decoder_impl.h
View File

@ -46,7 +46,7 @@ class AudioDecoderPcmU : public AudioDecoder {
SpeechType* speech_type) override; SpeechType* speech_type) override;
private: private:
DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmU); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmU);
}; };
class AudioDecoderPcmA : public AudioDecoder { class AudioDecoderPcmA : public AudioDecoder {
@ -64,7 +64,7 @@ class AudioDecoderPcmA : public AudioDecoder {
SpeechType* speech_type) override; SpeechType* speech_type) override;
private: private:
DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmA); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmA);
}; };
class AudioDecoderPcmUMultiCh : public AudioDecoderPcmU { class AudioDecoderPcmUMultiCh : public AudioDecoderPcmU {
@ -77,7 +77,7 @@ class AudioDecoderPcmUMultiCh : public AudioDecoderPcmU {
private: private:
const size_t channels_; const size_t channels_;
DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmUMultiCh); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmUMultiCh);
}; };
class AudioDecoderPcmAMultiCh : public AudioDecoderPcmA { class AudioDecoderPcmAMultiCh : public AudioDecoderPcmA {
@ -90,7 +90,7 @@ class AudioDecoderPcmAMultiCh : public AudioDecoderPcmA {
private: private:
const size_t channels_; const size_t channels_;
DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmAMultiCh); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmAMultiCh);
}; };
#ifdef WEBRTC_CODEC_PCM16 #ifdef WEBRTC_CODEC_PCM16
@ -111,7 +111,7 @@ class AudioDecoderPcm16B : public AudioDecoder {
SpeechType* speech_type) override; SpeechType* speech_type) override;
private: private:
DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcm16B); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcm16B);
}; };
// This class handles all four types (i.e., sample rates) of PCM16B codecs. // This class handles all four types (i.e., sample rates) of PCM16B codecs.
@ -124,7 +124,7 @@ class AudioDecoderPcm16BMultiCh : public AudioDecoderPcm16B {
private: private:
const size_t channels_; const size_t channels_;
DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcm16BMultiCh); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcm16BMultiCh);
}; };
#endif #endif
@ -147,7 +147,7 @@ class AudioDecoderIlbc : public AudioDecoder {
private: private:
IlbcDecoderInstance* dec_state_; IlbcDecoderInstance* dec_state_;
DISALLOW_COPY_AND_ASSIGN(AudioDecoderIlbc); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderIlbc);
}; };
#endif #endif
@ -170,7 +170,7 @@ class AudioDecoderG722 : public AudioDecoder {
private: private:
G722DecInst* dec_state_; G722DecInst* dec_state_;
DISALLOW_COPY_AND_ASSIGN(AudioDecoderG722); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderG722);
}; };
class AudioDecoderG722Stereo : public AudioDecoder { class AudioDecoderG722Stereo : public AudioDecoder {
@ -199,7 +199,7 @@ class AudioDecoderG722Stereo : public AudioDecoder {
G722DecInst* dec_state_left_; G722DecInst* dec_state_left_;
G722DecInst* dec_state_right_; G722DecInst* dec_state_right_;
DISALLOW_COPY_AND_ASSIGN(AudioDecoderG722Stereo); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderG722Stereo);
}; };
#endif #endif
@ -232,7 +232,7 @@ class AudioDecoderCng : public AudioDecoder {
private: private:
CNG_dec_inst* dec_state_; CNG_dec_inst* dec_state_;
DISALLOW_COPY_AND_ASSIGN(AudioDecoderCng); RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderCng);
}; };
enum NetEqDecoder { enum NetEqDecoder {

2
webrtc/modules/audio_coding/neteq/audio_multi_vector.h
View File

@ -132,7 +132,7 @@ class AudioMultiVector {
size_t num_channels_; size_t num_channels_;
private: private:
DISALLOW_COPY_AND_ASSIGN(AudioMultiVector); RTC_DISALLOW_COPY_AND_ASSIGN(AudioMultiVector);
}; };
} // namespace webrtc } // namespace webrtc

2
webrtc/modules/audio_coding/neteq/audio_vector.h
View File

@ -105,7 +105,7 @@ class AudioVector {
// Note that this index may point outside of array_. // Note that this index may point outside of array_.
size_t capacity_; // Allocated number of samples in the array. size_t capacity_; // Allocated number of samples in the array.
DISALLOW_COPY_AND_ASSIGN(AudioVector); RTC_DISALLOW_COPY_AND_ASSIGN(AudioVector);
}; };
} // namespace webrtc } // namespace webrtc

2
webrtc/modules/audio_coding/neteq/background_noise.h
View File

@ -130,7 +130,7 @@ class BackgroundNoise {
bool initialized_; bool initialized_;
NetEq::BackgroundNoiseMode mode_; NetEq::BackgroundNoiseMode mode_;
DISALLOW_COPY_AND_ASSIGN(BackgroundNoise); RTC_DISALLOW_COPY_AND_ASSIGN(BackgroundNoise);
}; };
} // namespace webrtc } // namespace webrtc

2
webrtc/modules/audio_coding/neteq/buffer_level_filter.h
View File

@ -42,7 +42,7 @@ class BufferLevelFilter {
int level_factor_; // Filter factor for the buffer level filter in Q8. int level_factor_; // Filter factor for the buffer level filter in Q8.
int filtered_current_level_; // Filtered current buffer level in Q8. int filtered_current_level_; // Filtered current buffer level in Q8.
DISALLOW_COPY_AND_ASSIGN(BufferLevelFilter); RTC_DISALLOW_COPY_AND_ASSIGN(BufferLevelFilter);
}; };
} // namespace webrtc } // namespace webrtc

Some files were not shown because too many files have changed in this diff Show More