admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace NULL with nullptr or null in webrtc/base/.

Browse Source 
BUG=webrtc:7147

Review-Url: https://codereview.webrtc.org/2718663005
Cr-Commit-Position: refs/heads/master@{#16878}
This commit is contained in:
deadbeef 2017-02-27 14:06:41 -08:00 committed by Commit bot
parent c5da4785f3
commit 37f5ecfd8f
117 changed files with 809 additions and 836 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/base/asyncinvoker-inl.h
View File

@ -68,7 +68,7 @@ class NotifyingAsyncClosureBase : public AsyncClosure,
CritScope cs(&crit_);
callback_ = callback;
}
bool CallbackCanceled() const { return calling_thread_ == NULL; }
bool CallbackCanceled() const { return calling_thread_ == nullptr; }
private:
Location callback_posted_from_;

4
webrtc/base/asyncinvoker.cc
View File

@ -147,8 +147,8 @@ void NotifyingAsyncClosureBase::CancelCallback() {
// destructor of the dying object here by waiting until the callback
// is done triggering.
CritScope cs(&crit_);
// calling_thread_ == NULL means do not trigger the callback.
calling_thread_ = NULL;
// calling_thread_ == nullptr means do not trigger the callback.
calling_thread_ = nullptr;
}
} // namespace rtc

2
webrtc/base/asyncpacketsocket.h
View File

@ -78,7 +78,7 @@ class AsyncPacketSocket : public sigslot::has_slots<> {
AsyncPacketSocket();
~AsyncPacketSocket() override;
// Returns current local address. Address may be set to NULL if the
// Returns current local address. Address may be set to null if the
// socket is not bound yet (GetState() returns STATE_BINDING).
virtual SocketAddress GetLocalAddress() const = 0;

2
webrtc/base/asyncsocket.cc
View File

@ -19,7 +19,7 @@ AsyncSocket::AsyncSocket() {
AsyncSocket::~AsyncSocket() {
}
AsyncSocketAdapter::AsyncSocketAdapter(AsyncSocket* socket) : socket_(NULL) {
AsyncSocketAdapter::AsyncSocketAdapter(AsyncSocket* socket) : socket_(nullptr) {
Attach(socket);
}

2
webrtc/base/asyncsocket.h
View File

@ -42,7 +42,7 @@ class AsyncSocket : public Socket {
class AsyncSocketAdapter : public AsyncSocket, public sigslot::has_slots<> {
public:
// The adapted socket may explicitly be NULL, and later assigned using Attach.
// The adapted socket may explicitly be null, and later assigned using Attach.
// However, subclasses which support detached mode must override any methods
// that will be called during the detached period (usually GetState()), to
// avoid dereferencing a null pointer.

8
webrtc/base/asynctcpsocket.cc
View File

@ -47,11 +47,11 @@ AsyncSocket* AsyncTCPSocketBase::ConnectSocket(
std::unique_ptr<rtc::AsyncSocket> owned_socket(socket);
if (socket->Bind(bind_address) < 0) {
LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
return NULL;
return nullptr;
}
if (socket->Connect(remote_address) < 0) {
LOG(LS_ERROR) << "Connect() failed with error " << socket->GetError();
return NULL;
return nullptr;
}
return owned_socket.release();
}
@ -67,7 +67,7 @@ AsyncTCPSocketBase::AsyncTCPSocketBase(AsyncSocket* socket, bool listen,
inbuf_.EnsureCapacity(kMinimumRecvSize);
}
RTC_DCHECK(socket_.get() != NULL);
RTC_DCHECK(socket_.get() != nullptr);
socket_->SignalConnectEvent.connect(
this, &AsyncTCPSocketBase::OnConnectEvent);
socket_->SignalReadEvent.connect(this, &AsyncTCPSocketBase::OnReadEvent);
@ -260,7 +260,7 @@ void AsyncTCPSocketBase::OnCloseEvent(AsyncSocket* socket, int error) {
// AsyncTCPSocket
// Binds and connects |socket| and creates AsyncTCPSocket for
// it. Takes ownership of |socket|. Returns NULL if bind() or
// it. Takes ownership of |socket|. Returns null if bind() or
// connect() fail (|socket| is destroyed in that case).
AsyncTCPSocket* AsyncTCPSocket::Create(
AsyncSocket* socket,

4
webrtc/base/asynctcpsocket.h
View File

@ -51,7 +51,7 @@ class AsyncTCPSocketBase : public AsyncPacketSocket {
protected:
// Binds and connects |socket| and creates AsyncTCPSocket for
// it. Takes ownership of |socket|. Returns NULL if bind() or
// it. Takes ownership of |socket|. Returns null if bind() or
// connect() fail (|socket| is destroyed in that case).
static AsyncSocket* ConnectSocket(AsyncSocket* socket,
const SocketAddress& bind_address,
@ -85,7 +85,7 @@ class AsyncTCPSocketBase : public AsyncPacketSocket {
class AsyncTCPSocket : public AsyncTCPSocketBase {
public:
// Binds and connects |socket| and creates AsyncTCPSocket for
// it. Takes ownership of |socket|. Returns NULL if bind() or
// it. Takes ownership of |socket|. Returns null if bind() or
// connect() fail (|socket| is destroyed in that case).
static AsyncTCPSocket* Create(AsyncSocket* socket,
const SocketAddress& bind_address,

4
webrtc/base/asyncudpsocket.cc
View File

@ -22,7 +22,7 @@ AsyncUDPSocket* AsyncUDPSocket::Create(
std::unique_ptr<AsyncSocket> owned_socket(socket);
if (socket->Bind(bind_address) < 0) {
LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
return NULL;
return nullptr;
}
return new AsyncUDPSocket(owned_socket.release());
}
@ -32,7 +32,7 @@ AsyncUDPSocket* AsyncUDPSocket::Create(SocketFactory* factory,
AsyncSocket* socket =
factory->CreateAsyncSocket(bind_address.family(), SOCK_DGRAM);
if (!socket)
return NULL;
return nullptr;
return Create(socket, bind_address);
}

2
webrtc/base/asyncudpsocket.h
View File

@ -23,7 +23,7 @@ namespace rtc {
class AsyncUDPSocket : public AsyncPacketSocket {
public:
// Binds |socket| and creates AsyncUDPSocket for it. Takes ownership
// of |socket|. Returns NULL if bind() fails (|socket| is destroyed
// of |socket|. Returns null if bind() fails (|socket| is destroyed
// in that case).
static AsyncUDPSocket* Create(AsyncSocket* socket,
const SocketAddress& bind_address);

6
webrtc/base/base64.cc
View File

@ -74,7 +74,7 @@ bool Base64::IsBase64Char(char ch) {
}
bool Base64::GetNextBase64Char(char ch, char* next_ch) {
if (next_ch == NULL) {
if (next_ch == nullptr) {
return false;
}
const char* p = strchr(Base64Table, ch);
@ -96,7 +96,7 @@ bool Base64::IsBase64Encoded(const std::string& str) {
void Base64::EncodeFromArray(const void* data,
size_t len,
std::string* result) {
RTC_DCHECK(NULL != result);
RTC_DCHECK(nullptr != result);
result->clear();
result->resize(((len + 2) / 3) * 4);
const unsigned char* byte_data = static_cast<const unsigned char*>(data);
@ -224,7 +224,7 @@ bool Base64::DecodeFromArrayTemplate(const char* data,
DecodeFlags flags,
T* result,
size_t* data_used) {
RTC_DCHECK(NULL != result);
RTC_DCHECK(nullptr != result);
RTC_DCHECK(flags <= (DO_PARSE_MASK | DO_PAD_MASK | DO_TERM_MASK));
const DecodeFlags parse_flags = flags & DO_PARSE_MASK;

2
webrtc/base/base64.h
View File

@ -83,7 +83,7 @@ class Base64 {
}
static inline std::string Decode(const std::string& data, DecodeFlags flags) {
std::string result;
DecodeFromArray(data.data(), data.size(), flags, &result, NULL);
DecodeFromArray(data.data(), data.size(), flags, &result, nullptr);
return result;
}
static inline bool Decode(const std::string& data,

8
webrtc/base/base64_unittest.cc
View File

@ -339,14 +339,14 @@ size_t Base64Escape(const unsigned char *src, size_t szsrc, char *dest,
size_t Base64Unescape(const char *src, size_t szsrc, char *dest,
size_t szdest) {
std::string unescaped;
EXPECT_TRUE(Base64::DecodeFromArray(src, szsrc, Base64::DO_LAX, &unescaped,
NULL));
EXPECT_TRUE(
Base64::DecodeFromArray(src, szsrc, Base64::DO_LAX, &unescaped, nullptr));
memcpy(dest, unescaped.data(), min(unescaped.size(), szdest));
return unescaped.size();
}
size_t Base64Unescape(const char *src, size_t szsrc, std::string *s) {
EXPECT_TRUE(Base64::DecodeFromArray(src, szsrc, Base64::DO_LAX, s, NULL));
EXPECT_TRUE(Base64::DecodeFromArray(src, szsrc, Base64::DO_LAX, s, nullptr));
return s->size();
}
@ -995,5 +995,5 @@ TEST(Base64, GetNextBase64Char) {
EXPECT_TRUE(Base64::GetNextBase64Char('/', &next_char));
EXPECT_EQ('A', next_char);
EXPECT_FALSE(Base64::GetNextBase64Char('&', &next_char));
EXPECT_FALSE(Base64::GetNextBase64Char('Z', NULL));
EXPECT_FALSE(Base64::GetNextBase64Char('Z', nullptr));
}

4
webrtc/base/bitbuffer.cc
View File

@ -202,8 +202,8 @@ bool BitBuffer::ReadSignedExponentialGolomb(int32_t* val) {
void BitBuffer::GetCurrentOffset(
size_t* out_byte_offset, size_t* out_bit_offset) {
RTC_CHECK(out_byte_offset != NULL);
RTC_CHECK(out_bit_offset != NULL);
RTC_CHECK(out_byte_offset != nullptr);
RTC_CHECK(out_bit_offset != nullptr);
*out_byte_offset = byte_offset_;
*out_bit_offset = bit_offset_;
}

4
webrtc/base/bitbuffer_unittest.cc
View File

@ -169,8 +169,8 @@ TEST(BitBufferTest, SetOffsetValues) {
// nicely.
#if GTEST_HAS_DEATH_TEST
#if !defined(WEBRTC_ANDROID)
// Passing a NULL out parameter is death.
EXPECT_DEATH(buffer.GetCurrentOffset(&byte_offset, NULL), "");
// Passing a null out parameter is death.
EXPECT_DEATH(buffer.GetCurrentOffset(&byte_offset, nullptr), "");
#endif
#endif
}

4
webrtc/base/bytebuffer.cc
View File

@ -23,12 +23,12 @@ static const int DEFAULT_SIZE = 4096;
ByteBufferWriter::ByteBufferWriter()
: ByteBuffer(ORDER_NETWORK) {
Construct(NULL, DEFAULT_SIZE);
Construct(nullptr, DEFAULT_SIZE);
}
ByteBufferWriter::ByteBufferWriter(ByteOrder byte_order)
: ByteBuffer(byte_order) {
Construct(NULL, DEFAULT_SIZE);
Construct(nullptr, DEFAULT_SIZE);
}
ByteBufferWriter::ByteBufferWriter(const char* bytes, size_t len)

7
webrtc/base/checks.cc
View File

@ -67,7 +67,7 @@ void DumpBacktrace() {
PrintError("\n==== C stack trace ===============================\n\n");
if (size == 0) {
PrintError("(empty)\n");
} else if (symbols == NULL) {
} else if (symbols == nullptr) {
PrintError("(no symbols)\n");
} else {
for (int i = 1; i < size; ++i) {
@ -76,8 +76,9 @@ void DumpBacktrace() {
PrintError("%2d: ", i);
int status;
size_t length;
char* demangled = abi::__cxa_demangle(mangled, NULL, &length, &status);
PrintError("%s\n", demangled != NULL ? demangled : mangled);
char* demangled =
abi::__cxa_demangle(mangled, nullptr, &length, &status);
PrintError("%s\n", demangled != nullptr ? demangled : mangled);
free(demangled);
} else {
// If parsing failed, at least print the unparsed symbol.

4
webrtc/base/checks.h
View File

@ -163,13 +163,13 @@ std::string* MakeCheckOpString<std::string, std::string>(
inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \
const char* names) { \
if (rtc::safe_cmp::name(v1, v2)) \
return NULL; \
return nullptr; \
else \
return rtc::MakeCheckOpString(v1, v2, names); \
} \
inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
if (rtc::safe_cmp::name(v1, v2)) \
return NULL; \
return nullptr; \
else \
return rtc::MakeCheckOpString(v1, v2, names); \
}

13
webrtc/base/event.cc
View File

@ -27,10 +27,9 @@ namespace rtc {
#if defined(WEBRTC_WIN)
Event::Event(bool manual_reset, bool initially_signaled) {
event_handle_ = ::CreateEvent(NULL, // Security attributes.
manual_reset,
initially_signaled,
NULL); // Name.
event_handle_ = ::CreateEvent(nullptr, // Security attributes.
manual_reset, initially_signaled,
nullptr); // Name.
RTC_CHECK(event_handle_);
}
@ -56,8 +55,8 @@ bool Event::Wait(int milliseconds) {
Event::Event(bool manual_reset, bool initially_signaled)
: is_manual_reset_(manual_reset),
event_status_(initially_signaled) {
RTC_CHECK(pthread_mutex_init(&event_mutex_, NULL) == 0);
RTC_CHECK(pthread_cond_init(&event_cond_, NULL) == 0);
RTC_CHECK(pthread_mutex_init(&event_mutex_, nullptr) == 0);
RTC_CHECK(pthread_cond_init(&event_cond_, nullptr) == 0);
}
Event::~Event() {
@ -93,7 +92,7 @@ bool Event::Wait(int milliseconds) {
ts.tv_nsec = (milliseconds % 1000) * 1000000;
#else
struct timeval tv;
gettimeofday(&tv, NULL);
gettimeofday(&tv, nullptr);
ts.tv_sec = tv.tv_sec + (milliseconds / 1000);
ts.tv_nsec = tv.tv_usec * 1000 + (milliseconds % 1000) * 1000000;

2
webrtc/base/event_tracer_unittest.cc
View File

@ -32,7 +32,7 @@ class TestStatistics {
int Count() const { return events_logged_; }
static TestStatistics* Get() {
static TestStatistics* test_stats = NULL;
static TestStatistics* test_stats = nullptr;
if (!test_stats)
test_stats = new TestStatistics();
return test_stats;

13
webrtc/base/fileutils.cc
View File

@ -40,7 +40,8 @@ DirectoryIterator::DirectoryIterator()
#ifdef WEBRTC_WIN
: handle_(INVALID_HANDLE_VALUE) {
#else
: dir_(NULL), dirent_(NULL) {
: dir_(nullptr),
dirent_(nullptr){
#endif
}
@ -68,13 +69,13 @@ bool DirectoryIterator::Iterate(const Pathname &dir) {
if (handle_ == INVALID_HANDLE_VALUE)
return false;
#else
if (dir_ != NULL)
if (dir_ != nullptr)
closedir(dir_);
dir_ = ::opendir(directory_.c_str());
if (dir_ == NULL)
if (dir_ == nullptr)
return false;
dirent_ = readdir(dir_);
if (dirent_ == NULL)
if (dirent_ == nullptr)
return false;
if (::stat(std::string(directory_ + Name()).c_str(), &stat_) != 0)
@ -90,7 +91,7 @@ bool DirectoryIterator::Next() {
return ::FindNextFile(handle_, &data_) == TRUE;
#else
dirent_ = ::readdir(dir_);
if (dirent_ == NULL)
if (dirent_ == nullptr)
return false;
return ::stat(std::string(directory_ + Name()).c_str(), &stat_) == 0;
@ -116,7 +117,7 @@ std::string DirectoryIterator::Name() const {
#endif
}
FilesystemInterface* Filesystem::default_filesystem_ = NULL;
FilesystemInterface* Filesystem::default_filesystem_ = nullptr;
FilesystemInterface *Filesystem::EnsureDefaultFilesystem() {
if (!default_filesystem_) {

2
webrtc/base/fileutils.h
View File

@ -85,7 +85,7 @@ class FilesystemInterface {
virtual DirectoryIterator* IterateDirectory();
// Opens a file. Returns an open StreamInterface if function succeeds.
// Otherwise, returns NULL.
// Otherwise, returns null.
// TODO: Add an error param to indicate failure reason, similar to
// FileStream::Open
virtual FileStream *OpenFile(const Pathname &filename,

16
webrtc/base/fileutils_unittest.cc
View File

@ -27,13 +27,13 @@ namespace rtc {
// Make sure we can get a temp folder for the later tests.
TEST(MAYBE_FilesystemTest, GetTemporaryFolder) {
Pathname path;
EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, NULL));
EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, nullptr));
}
// Test creating a temp file, reading it back in, and deleting it.
TEST(MAYBE_FilesystemTest, TestOpenFile) {
Pathname path;
EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, NULL));
EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, nullptr));
path.SetPathname(Filesystem::TempFilename(path, "ut"));
FileStream* fs;
@ -41,16 +41,16 @@ TEST(MAYBE_FilesystemTest, TestOpenFile) {
size_t bytes;
fs = Filesystem::OpenFile(path, "wb");
ASSERT_TRUE(fs != NULL);
EXPECT_EQ(SR_SUCCESS, fs->Write("test", 4, &bytes, NULL));
ASSERT_TRUE(fs != nullptr);
EXPECT_EQ(SR_SUCCESS, fs->Write("test", 4, &bytes, nullptr));
EXPECT_EQ(4U, bytes);
delete fs;
EXPECT_TRUE(Filesystem::IsFile(path));
fs = Filesystem::OpenFile(path, "rb");
ASSERT_TRUE(fs != NULL);
EXPECT_EQ(SR_SUCCESS, fs->Read(buf, sizeof(buf), &bytes, NULL));
ASSERT_TRUE(fs != nullptr);
EXPECT_EQ(SR_SUCCESS, fs->Read(buf, sizeof(buf), &bytes, nullptr));
EXPECT_EQ(4U, bytes);
delete fs;
@ -61,13 +61,13 @@ TEST(MAYBE_FilesystemTest, TestOpenFile) {
// Test opening a non-existent file.
TEST(MAYBE_FilesystemTest, TestOpenBadFile) {
Pathname path;
EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, NULL));
EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, nullptr));
path.SetFilename("not an actual file");
EXPECT_FALSE(Filesystem::IsFile(path));
FileStream* fs = Filesystem::OpenFile(path, "rb");
EXPECT_FALSE(fs != NULL);
EXPECT_FALSE(fs != nullptr);
}
} // namespace rtc

4
webrtc/base/firewallsocketserver.cc
View File

@ -121,7 +121,7 @@ FirewallSocketServer::~FirewallSocketServer() {
if (server_ && should_delete_server_) {
delete server_;
server_ = NULL;
server_ = nullptr;
}
}
@ -210,7 +210,7 @@ AsyncSocket* FirewallSocketServer::WrapSocket(AsyncSocket* sock, int type) {
(type == SOCK_DGRAM && !udp_sockets_enabled_)) {
LOG(LS_VERBOSE) << "FirewallSocketServer socket creation denied";
delete sock;
return NULL;
return nullptr;
}
return new FirewallSocket(this, sock, type);
}

6
webrtc/base/firewallsocketserver.h
View File

@ -26,8 +26,8 @@ enum FirewallDirection { FD_IN, FD_OUT, FD_ANY };
class FirewallSocketServer : public SocketServer {
public:
FirewallSocketServer(SocketServer * server,
FirewallManager * manager = NULL,
FirewallSocketServer(SocketServer* server,
FirewallManager* manager = nullptr,
bool should_delete_server = false);
~FirewallSocketServer() override;
@ -35,7 +35,7 @@ class FirewallSocketServer : public SocketServer {
void set_socketserver(SocketServer* server) {
if (server_ && should_delete_server_) {
delete server_;
server_ = NULL;
server_ = nullptr;
should_delete_server_ = false;
}
server_ = server;

32
webrtc/base/flags.cc
View File

@ -106,19 +106,18 @@ void Flag::Print(bool print_current_value) {
// -----------------------------------------------------------------------------
// Implementation of FlagList
Flag* FlagList::list_ = NULL;
Flag* FlagList::list_ = nullptr;
FlagList::FlagList() {
list_ = NULL;
list_ = nullptr;
}
void FlagList::Print(const char* file, bool print_current_value) {
// Since flag registration is likely by file (= C++ file),
// we don't need to sort by file and still get grouped output.
const char* current = NULL;
for (Flag* f = list_; f != NULL; f = f->next()) {
if (file == NULL || file == f->file()) {
const char* current = nullptr;
for (Flag* f = list_; f != nullptr; f = f->next()) {
if (file == nullptr || file == f->file()) {
if (current != f->file()) {
printf("Flags from %s:\n", f->file());
current = f->file();
@ -131,7 +130,7 @@ void FlagList::Print(const char* file, bool print_current_value) {
Flag* FlagList::Lookup(const char* name) {
Flag* f = list_;
while (f != NULL && strcmp(name, f->name()) != 0)
while (f != nullptr && strcmp(name, f->name()) != 0)
f = f->next();
return f;
}
@ -141,8 +140,8 @@ void FlagList::SplitArgument(const char* arg,
char* buffer, int buffer_size,
const char** name, const char** value,
bool* is_bool) {
*name = NULL;
*value = NULL;
*name = nullptr;
*value = nullptr;
*is_bool = false;
if (*arg == '-') {
@ -189,16 +188,16 @@ int FlagList::SetFlagsFromCommandLine(int* argc, const char** argv,
bool is_bool;
SplitArgument(arg, buffer, sizeof buffer, &name, &value, &is_bool);
if (name != NULL) {
if (name != nullptr) {
// lookup the flag
Flag* flag = Lookup(name);
if (flag == NULL) {
if (flag == nullptr) {
fprintf(stderr, "Error: unrecognized flag %s\n", arg);
return j;
}
// if we still need a flag value, use the next argument if available
if (flag->type() != Flag::BOOL && value == NULL) {
if (flag->type() != Flag::BOOL && value == nullptr) {
if (i < *argc) {
value = argv[i++];
} else {
@ -227,9 +226,8 @@ int FlagList::SetFlagsFromCommandLine(int* argc, const char** argv,
}
// handle errors
if ((flag->type() == Flag::BOOL && value != NULL) ||
(flag->type() != Flag::BOOL && is_bool) ||
*endp != '\0') {
if ((flag->type() == Flag::BOOL && value != nullptr) ||
(flag->type() != Flag::BOOL && is_bool) || *endp != '\0') {
fprintf(stderr, "Error: illegal value for flag %s of type %s\n",
arg, Type2String(flag->type()));
return j;
@ -238,7 +236,7 @@ int FlagList::SetFlagsFromCommandLine(int* argc, const char** argv,
// remove the flag & value from the command
if (remove_flags)
while (j < i)
argv[j++] = NULL;
argv[j++] = nullptr;
}
}
@ -246,7 +244,7 @@ int FlagList::SetFlagsFromCommandLine(int* argc, const char** argv,
if (remove_flags) {
int j = 1;
for (int i = 1; i < *argc; i++) {
if (argv[i] != NULL)
if (argv[i] != nullptr)
argv[j++] = argv[i];
}
*argc = j;

12
webrtc/base/flags.h
View File

@ -189,19 +189,19 @@ class FlagList {
public:
FlagList();
// The NULL-terminated list of all flags. Traverse with Flag::next().
// The null-terminated list of all flags. Traverse with Flag::next().
static Flag* list() { return list_; }
// If file != NULL, prints information for all flags defined in file;
// otherwise prints information for all flags in all files. The current
// flag value is only printed if print_current_value is set.
// If file != nullptr, prints information for all flags defined in file;
// otherwise prints information for all flags in all files. The current flag
// value is only printed if print_current_value is set.
static void Print(const char* file, bool print_current_value);
// Lookup a flag by name. Returns the matching flag or NULL.
// Lookup a flag by name. Returns the matching flag or null.
static Flag* Lookup(const char* name);
// Helper function to parse flags: Takes an argument arg and splits it into
// a flag name and flag value (or NULL if they are missing). is_bool is set
// a flag name and flag value (or null if they are missing). is_bool is set
// if the arg started with "-no" or "--no". The buffer may be used to NUL-
// terminate the name, it must be large enough to hold any possible name.
static void SplitArgument(const char* arg,

41
webrtc/base/httpbase.cc
View File

@ -176,7 +176,7 @@ HttpParser::ProcessLine(const char* line, size_t len, HttpError* error) {
case ST_CHUNKSIZE:
if (len > 0) {
char* ptr = NULL;
char* ptr = nullptr;
data_size_ = strtoul(line, &ptr, 16);
if (ptr != line + len) {
*error = HE_PROTOCOL;
@ -245,7 +245,7 @@ public:
DocumentStream(HttpBase* base) : base_(base), error_(HE_DEFAULT) { }
StreamState GetState() const override {
if (NULL == base_)
if (nullptr == base_)
return SS_CLOSED;
if (HM_RECV == base_->mode_)
return SS_OPEN;
@ -342,11 +342,11 @@ public:
}
HttpBase* Disconnect(HttpError error) {
RTC_DCHECK(NULL != base_);
RTC_DCHECK(NULL != base_->doc_stream_);
RTC_DCHECK(nullptr != base_);
RTC_DCHECK(nullptr != base_->doc_stream_);
HttpBase* base = base_;
base_->doc_stream_ = NULL;
base_ = NULL;
base_->doc_stream_ = nullptr;
base_ = nullptr;
error_ = error;
return base;
}
@ -360,9 +360,12 @@ private:
// HttpBase
//////////////////////////////////////////////////////////////////////
HttpBase::HttpBase() : mode_(HM_NONE), data_(NULL), notify_(NULL),
http_stream_(NULL), doc_stream_(NULL) {
}
HttpBase::HttpBase()
: mode_(HM_NONE),
data_(nullptr),
notify_(nullptr),
http_stream_(nullptr),
doc_stream_(nullptr) {}
HttpBase::~HttpBase() {
RTC_DCHECK(HM_NONE == mode_);
@ -370,12 +373,12 @@ HttpBase::~HttpBase() {
bool
HttpBase::isConnected() const {
return (http_stream_ != NULL) && (http_stream_->GetState() == SS_OPEN);
return (http_stream_ != nullptr) && (http_stream_->GetState() == SS_OPEN);
}
bool
HttpBase::attach(StreamInterface* stream) {
if ((mode_ != HM_NONE) || (http_stream_ != NULL) || (stream == NULL)) {
if ((mode_ != HM_NONE) || (http_stream_ != nullptr) || (stream == nullptr)) {
RTC_NOTREACHED();
return false;
}
@ -389,10 +392,10 @@ StreamInterface*
HttpBase::detach() {
RTC_DCHECK(HM_NONE == mode_);
if (mode_ != HM_NONE) {
return NULL;
return nullptr;
}
StreamInterface* stream = http_stream_;
http_stream_ = NULL;
http_stream_ = nullptr;
if (stream) {
stream->SignalEvent.disconnect(this);
}
@ -462,7 +465,7 @@ HttpBase::recv(HttpData* data) {
void
HttpBase::abort(HttpError err) {
if (mode_ != HM_NONE) {
if (http_stream_ != NULL) {
if (http_stream_ != nullptr) {
http_stream_->Close();
}
do_complete(err);
@ -471,13 +474,13 @@ HttpBase::abort(HttpError err) {
StreamInterface* HttpBase::GetDocumentStream() {
if (doc_stream_)
return NULL;
return nullptr;
doc_stream_ = new DocumentStream(this);
return doc_stream_;
}
HttpError HttpBase::HandleStreamClose(int error) {
if (http_stream_ != NULL) {
if (http_stream_ != nullptr) {
http_stream_->Close();
}
if (error == 0) {
@ -497,7 +500,7 @@ HttpError HttpBase::HandleStreamClose(int error) {
bool HttpBase::DoReceiveLoop(HttpError* error) {
RTC_DCHECK(HM_RECV == mode_);
RTC_DCHECK(NULL != error);
RTC_DCHECK(nullptr != error);
// Do to the latency between receiving read notifications from
// pseudotcpchannel, we rely on repeated calls to read in order to acheive
@ -737,7 +740,7 @@ HttpBase::do_complete(HttpError err) {
if (data_ && data_->document) {
data_->document->SignalEvent.disconnect(this);
}
data_ = NULL;
data_ = nullptr;
if ((HM_RECV == mode) && doc_stream_) {
RTC_DCHECK(HE_NONE !=
err); // We should have Disconnected doc_stream_ already.
@ -834,7 +837,7 @@ HttpBase::ProcessHeaderComplete(bool chunked, size_t& data_size,
if (notify_) {
*error = notify_->onHttpHeaderComplete(chunked, data_size);
// The request must not be aborted as a result of this callback.
RTC_DCHECK(NULL != data_);
RTC_DCHECK(nullptr != data_);
}
if ((HE_NONE == *error) && data_->document) {
data_->document->SignalEvent.connect(this, &HttpBase::OnDocumentEvent);

2
webrtc/base/httpbase.h
View File

@ -113,7 +113,7 @@ public:
// Obtaining this stream puts HttpBase into stream mode until the stream
// is closed. HttpBase can only expose one open stream interface at a time.
// Further calls will return NULL.
// Further calls will return null.
StreamInterface* GetDocumentStream();
protected:

27
webrtc/base/httpbase_unittest.cc
View File

@ -54,7 +54,7 @@ public:
HttpMode mode;
HttpError err;
};
HttpBaseTest() : mem(NULL), obtain_stream(false), http_stream(NULL) { }
HttpBaseTest() : mem(nullptr), obtain_stream(false), http_stream(nullptr) {}
virtual void SetUp() { }
virtual void TearDown() {
@ -189,27 +189,28 @@ void HttpBaseTest::ObtainDocumentStream() {
LOG_F(LS_VERBOSE) << "Enter";
EXPECT_FALSE(http_stream);
http_stream = base.GetDocumentStream();
ASSERT_TRUE(NULL != http_stream);
ASSERT_TRUE(nullptr != http_stream);
sink.Monitor(http_stream);
LOG_F(LS_VERBOSE) << "Exit";
}
void HttpBaseTest::VerifyDocumentStreamIsOpening() {
LOG_F(LS_VERBOSE) << "Enter";
ASSERT_TRUE(NULL != http_stream);
ASSERT_TRUE(nullptr != http_stream);
EXPECT_EQ(0, sink.Events(http_stream));
EXPECT_EQ(SS_OPENING, http_stream->GetState());
size_t read = 0;
char buffer[5] = { 0 };
EXPECT_EQ(SR_BLOCK, http_stream->Read(buffer, sizeof(buffer), &read, NULL));
EXPECT_EQ(SR_BLOCK,
http_stream->Read(buffer, sizeof(buffer), &read, nullptr));
LOG_F(LS_VERBOSE) << "Exit";
}
void HttpBaseTest::VerifyDocumentStreamOpenEvent() {
LOG_F(LS_VERBOSE) << "Enter";
ASSERT_TRUE(NULL != http_stream);
ASSERT_TRUE(nullptr != http_stream);
EXPECT_EQ(SE_OPEN | SE_READ, sink.Events(http_stream));
EXPECT_EQ(SS_OPEN, http_stream->GetState());
@ -222,7 +223,7 @@ void HttpBaseTest::VerifyDocumentStreamOpenEvent() {
void HttpBaseTest::ReadDocumentStreamData(const char* expected_data) {
LOG_F(LS_VERBOSE) << "Enter";
ASSERT_TRUE(NULL != http_stream);
ASSERT_TRUE(nullptr != http_stream);
EXPECT_EQ(SS_OPEN, http_stream->GetState());
// Pump the HTTP I/O using Read, and verify the results.
@ -233,7 +234,8 @@ void HttpBaseTest::ReadDocumentStreamData(const char* expected_data) {
char buffer[5] = { 0 };
size_t amt_to_read =
std::min(expected_length - verified_length, sizeof(buffer));
EXPECT_EQ(SR_SUCCESS, http_stream->Read(buffer, amt_to_read, &read, NULL));
EXPECT_EQ(SR_SUCCESS,
http_stream->Read(buffer, amt_to_read, &read, nullptr));
EXPECT_EQ(amt_to_read, read);
EXPECT_TRUE(0 == memcmp(expected_data + verified_length, buffer, read));
verified_length += read;
@ -244,10 +246,10 @@ void HttpBaseTest::ReadDocumentStreamData(const char* expected_data) {
void HttpBaseTest::VerifyDocumentStreamIsEOS() {
LOG_F(LS_VERBOSE) << "Enter";
ASSERT_TRUE(NULL != http_stream);
ASSERT_TRUE(nullptr != http_stream);
size_t read = 0;
char buffer[5] = { 0 };
EXPECT_EQ(SR_EOS, http_stream->Read(buffer, sizeof(buffer), &read, NULL));
EXPECT_EQ(SR_EOS, http_stream->Read(buffer, sizeof(buffer), &read, nullptr));
EXPECT_EQ(SS_CLOSED, http_stream->GetState());
// When EOS is caused by Read, we don't expect SE_CLOSE
@ -320,7 +322,7 @@ TEST_F(HttpBaseTest, SupportsSend) {
TEST_F(HttpBaseTest, SupportsSendNoDocument) {
// Queue response document
SetupDocument(NULL);
SetupDocument(nullptr);
// Begin send
base.send(&data);
@ -475,7 +477,7 @@ TEST_F(HttpBaseTest, AllowsGetDocumentStreamWithEmptyDocumentBody) {
VerifyDocumentContents("");
// The document is still open, until we attempt to read
ASSERT_TRUE(NULL != http_stream);
ASSERT_TRUE(nullptr != http_stream);
EXPECT_EQ(SS_OPEN, http_stream->GetState());
// Attempt to read data, and discover EOS
@ -511,7 +513,8 @@ TEST_F(HttpBaseTest, SignalsDocumentStreamCloseOnUnexpectedClose) {
// Future reads give an error
int error = 0;
char buffer[5] = { 0 };
EXPECT_EQ(SR_ERROR, http_stream->Read(buffer, sizeof(buffer), NULL, &error));
EXPECT_EQ(SR_ERROR,
http_stream->Read(buffer, sizeof(buffer), nullptr, &error));
EXPECT_EQ(HE_DISCONNECTED, error);
// Document completed with error

2
webrtc/base/httpcommon-inl.h
View File

@ -53,7 +53,7 @@ void Url<CTYPE>::do_set_address(const CTYPE* val, size_t len) {
host_.assign(val, colon - val);
// Note: In every case, we're guaranteed that colon is followed by a null,
// or non-numeric character.
port_ = static_cast<uint16_t>(::strtoul(colon + 1, NULL, 10));
port_ = static_cast<uint16_t>(::strtoul(colon + 1, nullptr, 10));
// TODO: Consider checking for invalid data following port number.
} else {
host_.assign(val, len);

18
webrtc/base/httpcommon.cc
View File

@ -341,7 +341,7 @@ bool HttpDateToSeconds(const std::string& date, time_t* seconds) {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
};
RTC_DCHECK(NULL != seconds);
RTC_DCHECK(nullptr != seconds);
struct tm tval;
memset(&tval, 0, sizeof(tval));
char month[4], zone[6];
@ -481,9 +481,9 @@ void HttpData::setContent(const std::string& content_type,
void HttpData::setDocumentAndLength(StreamInterface* document) {
// TODO: Consider calling Rewind() here?
RTC_DCHECK(!hasHeader(HH_CONTENT_LENGTH, NULL));
RTC_DCHECK(!hasHeader(HH_TRANSFER_ENCODING, NULL));
RTC_DCHECK(document != NULL);
RTC_DCHECK(!hasHeader(HH_CONTENT_LENGTH, nullptr));
RTC_DCHECK(!hasHeader(HH_TRANSFER_ENCODING, nullptr));
RTC_DCHECK(document != nullptr);
this->document.reset(document);
size_t content_length = 0;
if (this->document->GetAvailable(&content_length)) {
@ -719,7 +719,7 @@ HttpAuthResult HttpAuthenticate(
{
HttpAttributeList args;
HttpParseAttributes(challenge, len, args);
HttpHasNthAttribute(args, 0, &auth_method, NULL);
HttpHasNthAttribute(args, 0, &auth_method, nullptr);
if (context && (context->auth_method != auth_method))
return HAR_IGNORE;
@ -825,7 +825,7 @@ HttpAuthResult HttpAuthenticate(
#if 0 // Requires funky windows versions
DWORD len = MAX_SPN;
if (DsMakeSpn("HTTP", server.HostAsURIString().c_str(), NULL,
if (DsMakeSpn("HTTP", server.HostAsURIString().c_str(), nullptr,
server.port(),
0, &len, spn) != ERROR_SUCCESS) {
LOG_F(WARNING) << "(Negotiate) - DsMakeSpn failed";
@ -875,9 +875,9 @@ HttpAuthResult HttpAuthenticate(
steps = neg->steps;
std::string challenge, decoded_challenge;
if (HttpHasNthAttribute(args, 1, &challenge, NULL)
&& Base64::Decode(challenge, Base64::DO_STRICT,
&decoded_challenge, NULL)) {
if (HttpHasNthAttribute(args, 1, &challenge, nullptr) &&
Base64::Decode(challenge, Base64::DO_STRICT, &decoded_challenge,
nullptr)) {
SecBuffer in_sec;
in_sec.pvBuffer = const_cast<char *>(decoded_challenge.data());
in_sec.cbBuffer = static_cast<unsigned long>(decoded_challenge.size());

26
webrtc/base/httpserver.cc
View File

@ -92,7 +92,7 @@ HttpServer::Connection*
HttpServer::Find(int connection_id) {
ConnectionMap::iterator it = connections_.find(connection_id);
if (it == connections_.end())
return NULL;
return nullptr;
return it->second;
}
@ -118,9 +118,11 @@ HttpServer::Remove(int connection_id) {
///////////////////////////////////////////////////////////////////////////////
HttpServer::Connection::Connection(int connection_id, HttpServer* server)
: connection_id_(connection_id), server_(server),
current_(NULL), signalling_(false), close_(false) {
}
: connection_id_(connection_id),
server_(server),
current_(nullptr),
signalling_(false),
close_(false) {}
HttpServer::Connection::~Connection() {
// It's possible that an object hosted inside this transaction signalled
@ -139,14 +141,14 @@ HttpServer::Connection::BeginProcess(StreamInterface* stream) {
StreamInterface*
HttpServer::Connection::EndProcess() {
base_.notify(NULL);
base_.notify(nullptr);
base_.abort(HE_DISCONNECTED);
return base_.detach();
}
void
HttpServer::Connection::Respond(HttpServerTransaction* transaction) {
RTC_DCHECK(current_ == NULL);
RTC_DCHECK(current_ == nullptr);
current_ = transaction;
if (current_->response.begin() == current_->response.end()) {
current_->response.set_error(HC_INTERNAL_SERVER_ERROR);
@ -161,7 +163,7 @@ HttpServer::Connection::Respond(HttpServerTransaction* transaction) {
void
HttpServer::Connection::InitiateClose(bool force) {
bool request_in_progress = (HM_SEND == base_.mode()) || (NULL == current_);
bool request_in_progress = (HM_SEND == base_.mode()) || (nullptr == current_);
if (!signalling_ && (force || !request_in_progress)) {
server_->Remove(connection_id_);
} else {
@ -178,7 +180,7 @@ HttpServer::Connection::onHttpHeaderComplete(bool chunked, size_t& data_size) {
if (data_size == SIZE_UNKNOWN) {
data_size = 0;
}
RTC_DCHECK(current_ != NULL);
RTC_DCHECK(current_ != nullptr);
bool custom_document = false;
server_->SignalHttpRequestHeader(server_, current_, &custom_document);
if (!custom_document) {
@ -190,7 +192,7 @@ HttpServer::Connection::onHttpHeaderComplete(bool chunked, size_t& data_size) {
void
HttpServer::Connection::onHttpComplete(HttpMode mode, HttpError err) {
if (mode == HM_SEND) {
RTC_DCHECK(current_ != NULL);
RTC_DCHECK(current_ != nullptr);
signalling_ = true;
server_->SignalHttpRequestComplete(server_, current_, err);
signalling_ = false;
@ -204,11 +206,11 @@ HttpServer::Connection::onHttpComplete(HttpMode mode, HttpError err) {
} else if (mode == HM_CONNECT) {
base_.recv(&current_->request);
} else if (mode == HM_RECV) {
RTC_DCHECK(current_ != NULL);
RTC_DCHECK(current_ != nullptr);
// TODO: do we need this?
//request_.document_->rewind();
HttpServerTransaction* transaction = current_;
current_ = NULL;
current_ = nullptr;
server_->SignalHttpRequest(server_, transaction);
} else if (mode == HM_SEND) {
Thread::Current()->Dispose(current_->response.document.release());
@ -267,7 +269,7 @@ void HttpListenServer::StopListening() {
void HttpListenServer::OnReadEvent(AsyncSocket* socket) {
RTC_DCHECK(socket == listener_.get());
AsyncSocket* incoming = listener_->Accept(NULL);
AsyncSocket* incoming = listener_->Accept(nullptr);
if (incoming) {
StreamInterface* stream = new SocketStream(incoming);
//stream = new LoggingAdapter(stream, LS_VERBOSE, "HttpServer", false);

4
webrtc/base/httpserver.h
View File

@ -51,8 +51,8 @@ public:
// the request document is a MemoryStream. By handling this signal, the
// document can be overridden, in which case the third signal argument should
// be set to true. In the case where the request body should be ignored,
// the document can be set to NULL. Note that the transaction object is still
// owened by the HttpServer at this point.
// the document can be set to null. Note that the transaction object is still
// owened by the HttpServer at this point.
sigslot::signal3<HttpServer*, HttpServerTransaction*, bool*>
SignalHttpRequestHeader;

8
webrtc/base/httpserver_unittest.cc
View File

@ -27,7 +27,7 @@ namespace {
bool server_closed, connection_closed;
HttpServerMonitor(HttpServer* server)
: transaction(NULL), server_closed(false), connection_closed(false) {
: transaction(nullptr), server_closed(false), connection_closed(false) {
server->SignalCloseAllComplete.connect(this,
&HttpServerMonitor::OnClosed);
server->SignalHttpRequest.connect(this, &HttpServerMonitor::OnRequest);
@ -44,7 +44,7 @@ namespace {
}
void OnRequestComplete(HttpServer*, HttpServerTransaction* t, int) {
ASSERT_EQ(transaction, t);
transaction = NULL;
transaction = nullptr;
}
void OnClosed(HttpServer*) {
server_closed = true;
@ -78,7 +78,7 @@ TEST(HttpServer, DoesNotSignalCloseUnlessCloseAllIsCalled) {
// Add an active client connection
CreateClientConnection(server, monitor, true);
// Simulate a response
ASSERT_TRUE(NULL != monitor.transaction);
ASSERT_TRUE(nullptr != monitor.transaction);
server.Respond(monitor.transaction);
EXPECT_FALSE(monitor.transaction);
// Connection has closed, but no server close signal
@ -107,7 +107,7 @@ TEST(HttpServer, SignalsCloseAfterGracefulCloseAll) {
server.CloseAll(false);
EXPECT_FALSE(monitor.server_closed);
// Simulate a response
ASSERT_TRUE(NULL != monitor.transaction);
ASSERT_TRUE(nullptr != monitor.transaction);
server.Respond(monitor.transaction);
EXPECT_FALSE(monitor.transaction);
// Connections have all closed

12
webrtc/base/ifaddrs-android.cc
View File

@ -39,7 +39,7 @@ namespace rtc {
int set_ifname(struct ifaddrs* ifaddr, int interface) {
char buf[IFNAMSIZ] = {0};
char* name = if_indextoname(interface, buf);
if (name == NULL) {
if (name == nullptr) {
return -1;
}
ifaddr->ifa_name = new char[strlen(name) + 1];
@ -84,7 +84,7 @@ int set_addresses(struct ifaddrs* ifaddr, ifaddrmsg* msg, void* data,
}
int make_prefixes(struct ifaddrs* ifaddr, int family, int prefixlen) {
char* prefix = NULL;
char* prefix = nullptr;
if (family == AF_INET) {
sockaddr_in* mask = new sockaddr_in;
mask->sin_family = AF_INET;
@ -149,8 +149,8 @@ int getifaddrs(struct ifaddrs** result) {
close(fd);
return -1;
}
struct ifaddrs* start = NULL;
struct ifaddrs* current = NULL;
struct ifaddrs* start = nullptr;
struct ifaddrs* current = nullptr;
char buf[kMaxReadSize];
ssize_t amount_read = recv(fd, &buf, kMaxReadSize, 0);
while (amount_read > 0) {
@ -187,7 +187,7 @@ int getifaddrs(struct ifaddrs** result) {
if (populate_ifaddrs(newest, address_msg, RTA_DATA(rta),
RTA_PAYLOAD(rta)) != 0) {
freeifaddrs(start);
*result = NULL;
*result = nullptr;
return -1;
}
current = newest;
@ -207,7 +207,7 @@ int getifaddrs(struct ifaddrs** result) {
}
void freeifaddrs(struct ifaddrs* addrs) {
struct ifaddrs* last = NULL;
struct ifaddrs* last = nullptr;
struct ifaddrs* cursor = addrs;
while (cursor) {
delete[] cursor->ifa_name;

24
webrtc/base/logging.cc
View File

@ -110,7 +110,7 @@ CriticalSection g_log_crit;
// The list of logging streams currently configured.
// Note: we explicitly do not clean this up, because of the uncertain ordering
// of destructors at program exit. Let the person who sets the stream trigger
// cleanup by setting to NULL, or let it leak (safe at program exit).
// cleanup by setting to null, or let it leak (safe at program exit).
LogMessage::StreamList LogMessage::streams_ GUARDED_BY(g_log_crit);
// Boolean options default to false (0)
@ -140,7 +140,7 @@ LogMessage::LogMessage(const char* file,
print_stream_ << "[" << std::dec << id << "] ";
}
if (file != NULL)
if (file != nullptr)
print_stream_ << "(" << FilenameFromPath(file) << ":" << line << "): ";
if (err_ctx != ERRCTX_NONE) {
@ -158,9 +158,8 @@ LogMessage::LogMessage(const char* file,
if (hmod)
flags |= FORMAT_MESSAGE_FROM_HMODULE;
if (DWORD len = FormatMessageA(
flags, hmod, err,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
msgbuf, sizeof(msgbuf) / sizeof(msgbuf[0]), NULL)) {
flags, hmod, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
msgbuf, sizeof(msgbuf) / sizeof(msgbuf[0]), nullptr)) {
while ((len > 0) &&
isspace(static_cast<unsigned char>(msgbuf[len-1]))) {
msgbuf[--len] = 0;
@ -188,7 +187,12 @@ LogMessage::LogMessage(const char* file,
int line,
LoggingSeverity sev,
const std::string& tag)
: LogMessage(file, line, sev, ERRCTX_NONE, 0 /* err */, NULL /* module */) {
: LogMessage(file,
line,
sev,
ERRCTX_NONE,
0 /* err */,
nullptr /* module */) {
tag_ = tag;
print_stream_ << tag << ": ";
}
@ -217,7 +221,7 @@ int64_t LogMessage::LogStartTime() {
}
uint32_t LogMessage::WallClockStartTime() {
static const uint32_t g_start_wallclock = time(NULL);
static const uint32_t g_start_wallclock = time(nullptr);
return g_start_wallclock;
}
@ -349,7 +353,7 @@ void LogMessage::OutputToDebug(const std::string& str,
"logToStdErr",
kCFStringEncodingUTF8);
CFStringRef domain = CFBundleGetIdentifier(CFBundleGetMainBundle());
if (key != NULL && domain != NULL) {
if (key != nullptr && domain != nullptr) {
Boolean exists_and_is_valid;
Boolean should_log =
CFPreferencesGetAppBooleanValue(key, domain, &exists_and_is_valid);
@ -357,7 +361,7 @@ void LogMessage::OutputToDebug(const std::string& str,
// stderr.
log_to_stderr = exists_and_is_valid && should_log;
}
if (key != NULL) {
if (key != nullptr) {
CFRelease(key);
}
#endif
@ -443,7 +447,7 @@ void LogMultiline(LoggingSeverity level, const char* label, bool input,
const char * direction = (input ? " << " : " >> ");
// NULL data means to flush our count of unprintable characters.
// null data means to flush our count of unprintable characters.
if (!data) {
if (state && state->unprintable_count_[input]) {
LOG_V(level) << label << direction << "## "

17
webrtc/base/logging.h
View File

@ -139,9 +139,12 @@ class LogSink {
class LogMessage {
public:
LogMessage(const char* file, int line, LoggingSeverity sev,
LogErrorContext err_ctx = ERRCTX_NONE, int err = 0,
const char* module = NULL);
LogMessage(const char* file,
int line,
LoggingSeverity sev,
LogErrorContext err_ctx = ERRCTX_NONE,
int err = 0,
const char* module = nullptr);
LogMessage(const char* file,
int line,
@ -185,7 +188,7 @@ class LogMessage {
// GetLogToStream gets the severity for the specified stream, of if none
// is specified, the minimum stream severity.
// RemoveLogToStream removes the specified stream, without destroying it.
static int GetLogToStream(LogSink* stream = NULL);
static int GetLogToStream(LogSink* stream = nullptr);
static void AddLogToStream(LogSink* stream, LoggingSeverity min_sev);
static void RemoveLogToStream(LogSink* stream);
@ -254,7 +257,7 @@ class LogMultilineState {
};
// When possible, pass optional state variable to track various data across
// multiple calls to LogMultiline. Otherwise, pass NULL.
// multiple calls to LogMultiline. Otherwise, pass null.
void LogMultiline(LoggingSeverity level, const char* label, bool input,
const void* data, size_t len, bool hex_mode,
LogMultilineState* state);
@ -351,9 +354,9 @@ inline bool LogCheckLevel(LoggingSeverity sev) {
(errno)
#endif // WEBRTC_WIN
#define LOG_TAG(sev, tag) \
#define LOG_TAG(sev, tag) \
LOG_SEVERITY_PRECONDITION(sev) \
rtc::LogMessage(NULL, 0, sev, tag).stream()
rtc::LogMessage(nullptr, 0, sev, tag).stream()
#define PLOG(sev, err) \
LOG_ERR_EX(sev, err)

16
webrtc/base/logging_unittest.cc
View File

@ -37,7 +37,7 @@ class LogSinkImpl
// Test basic logging operation. We should get the INFO log but not the VERBOSE.
// We should restore the correct global state at the end.
TEST(LogTest, SingleStream) {
int sev = LogMessage::GetLogToStream(NULL);
int sev = LogMessage::GetLogToStream(nullptr);
std::string str;
LogSinkImpl<StringStream> stream(&str);
@ -52,14 +52,14 @@ TEST(LogTest, SingleStream) {
LogMessage::RemoveLogToStream(&stream);
EXPECT_EQ(LS_NONE, LogMessage::GetLogToStream(&stream));
EXPECT_EQ(sev, LogMessage::GetLogToStream(NULL));
EXPECT_EQ(sev, LogMessage::GetLogToStream(nullptr));
}
// Test using multiple log streams. The INFO stream should get the INFO message,
// the VERBOSE stream should get the INFO and the VERBOSE.
// We should restore the correct global state at the end.
TEST(LogTest, MultipleStreams) {
int sev = LogMessage::GetLogToStream(NULL);
int sev = LogMessage::GetLogToStream(nullptr);
std::string str1, str2;
LogSinkImpl<StringStream> stream1(&str1), stream2(&str2);
@ -81,7 +81,7 @@ TEST(LogTest, MultipleStreams) {
EXPECT_EQ(LS_NONE, LogMessage::GetLogToStream(&stream2));
EXPECT_EQ(LS_NONE, LogMessage::GetLogToStream(&stream1));
EXPECT_EQ(sev, LogMessage::GetLogToStream(NULL));
EXPECT_EQ(sev, LogMessage::GetLogToStream(nullptr));
}
// Ensure we don't crash when adding/removing streams while threads are going.
@ -100,7 +100,7 @@ class LogThread : public Thread {
};
TEST(LogTest, MultipleThreads) {
int sev = LogMessage::GetLogToStream(NULL);
int sev = LogMessage::GetLogToStream(nullptr);
LogThread thread1, thread2, thread3;
thread1.Start();
@ -117,7 +117,7 @@ TEST(LogTest, MultipleThreads) {
LogMessage::RemoveLogToStream(&stream3);
}
EXPECT_EQ(sev, LogMessage::GetLogToStream(NULL));
EXPECT_EQ(sev, LogMessage::GetLogToStream(nullptr));
}
@ -137,11 +137,11 @@ TEST(LogTest, WallClockStartTime) {
TEST(LogTest, MAYBE_Perf) {
Pathname path;
EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, NULL));
EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, nullptr));
path.SetPathname(Filesystem::TempFilename(path, "ut"));
LogSinkImpl<FileStream> stream;
EXPECT_TRUE(stream.Open(path.pathname(), "wb", NULL));
EXPECT_TRUE(stream.Open(path.pathname(), "wb", nullptr));
stream.DisableBuffering();
LogMessage::AddLogToStream(&stream, LS_SENSITIVE);

6
webrtc/base/macutils.cc
View File

@ -24,7 +24,7 @@ namespace rtc {
///////////////////////////////////////////////////////////////////////////////
bool ToUtf8(const CFStringRef str16, std::string* str8) {
if ((NULL == str16) || (NULL == str8)) {
if ((nullptr == str16) || (nullptr == str8)) {
return false;
}
size_t maxlen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str16),
@ -39,14 +39,14 @@ bool ToUtf8(const CFStringRef str16, std::string* str8) {
}
bool ToUtf16(const std::string& str8, CFStringRef* str16) {
if (NULL == str16) {
if (nullptr == str16) {
return false;
}
*str16 = CFStringCreateWithBytes(kCFAllocatorDefault,
reinterpret_cast<const UInt8*>(str8.data()),
str8.length(), kCFStringEncodingUTF8,
false);
return NULL != *str16;
return nullptr != *str16;
}
void DecodeFourChar(UInt32 fc, std::string* out) {

2
webrtc/base/messagedigest.cc
View File

@ -34,7 +34,7 @@ MessageDigest* MessageDigestFactory::Create(const std::string& alg) {
MessageDigest* digest = new OpenSSLDigest(alg);
if (digest->Size() == 0) { // invalid algorithm
delete digest;
digest = NULL;
digest = nullptr;
}
return digest;
}

12
webrtc/base/messagequeue.cc
View File

@ -49,7 +49,7 @@ class SCOPED_LOCKABLE DebugNonReentrantCritScope {
//------------------------------------------------------------------
// MessageQueueManager
MessageQueueManager* MessageQueueManager::instance_ = NULL;
MessageQueueManager* MessageQueueManager::instance_ = nullptr;
MessageQueueManager* MessageQueueManager::Instance() {
// Note: This is not thread safe, but it is first called before threads are
@ -60,7 +60,7 @@ MessageQueueManager* MessageQueueManager::Instance() {
}
bool MessageQueueManager::IsInitialized() {
return instance_ != NULL;
return instance_ != nullptr;
}
MessageQueueManager::MessageQueueManager() : locked_(false) {}
@ -99,7 +99,7 @@ void MessageQueueManager::RemoveInternal(MessageQueue *message_queue) {
destroy = message_queues_.empty();
}
if (destroy) {
instance_ = NULL;
instance_ = nullptr;
delete this;
}
}
@ -214,11 +214,11 @@ void MessageQueue::DoDestroy() {
// is going away.
SignalQueueDestroyed();
MessageQueueManager::Remove(this);
Clear(NULL);
Clear(nullptr);
SharedScope ss(&ss_lock_);
if (ss_) {
ss_->SetMessageQueue(NULL);
ss_->SetMessageQueue(nullptr);
}
}
@ -333,7 +333,7 @@ bool MessageQueue::Get(Message *pmsg, int cmsWait, bool process_io) {
}
// If this was a dispose message, delete it and skip it.
if (MQID_DISPOSE == pmsg->message_id) {
RTC_DCHECK(NULL == pmsg->phandler);
RTC_DCHECK(nullptr == pmsg->phandler);
delete pmsg->pdata;
*pmsg = Message();
continue;

16
webrtc/base/messagequeue.h
View File

@ -157,8 +157,8 @@ struct Message {
Message()
: phandler(nullptr), message_id(0), pdata(nullptr), ts_sensitive(0) {}
inline bool Match(MessageHandler* handler, uint32_t id) const {
return (handler == NULL || handler == phandler)
&& (id == MQID_ANY || id == message_id);
return (handler == nullptr || handler == phandler) &&
(id == MQID_ANY || id == message_id);
}
Location posted_from;
MessageHandler *phandler;
@ -236,27 +236,27 @@ class MessageQueue {
virtual void Post(const Location& posted_from,
MessageHandler* phandler,
uint32_t id = 0,
MessageData* pdata = NULL,
MessageData* pdata = nullptr,
bool time_sensitive = false);
virtual void PostDelayed(const Location& posted_from,
int cmsDelay,
MessageHandler* phandler,
uint32_t id = 0,
MessageData* pdata = NULL);
MessageData* pdata = nullptr);
virtual void PostAt(const Location& posted_from,
int64_t tstamp,
MessageHandler* phandler,
uint32_t id = 0,
MessageData* pdata = NULL);
MessageData* pdata = nullptr);
// TODO(honghaiz): Remove this when all the dependencies are removed.
virtual void PostAt(const Location& posted_from,
uint32_t tstamp,
MessageHandler* phandler,
uint32_t id = 0,
MessageData* pdata = NULL);
MessageData* pdata = nullptr);
virtual void Clear(MessageHandler* phandler,
uint32_t id = MQID_ANY,
MessageList* removed = NULL);
MessageList* removed = nullptr);
virtual void Dispatch(Message *pmsg);
virtual void ReceiveSends();
@ -272,7 +272,7 @@ class MessageQueue {
// Internally posts a message which causes the doomed object to be deleted
template<class T> void Dispose(T* doomed) {
if (doomed) {
Post(RTC_FROM_HERE, NULL, MQID_DISPOSE, new DisposeData<T>(doomed));
Post(RTC_FROM_HERE, nullptr, MQID_DISPOSE, new DisposeData<T>(doomed));
}
}

14
webrtc/base/messagequeue_unittest.cc
View File

@ -57,13 +57,13 @@ struct DeletedLockChecker {
static void DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(
MessageQueue* q) {
EXPECT_TRUE(q != NULL);
EXPECT_TRUE(q != nullptr);
int64_t now = TimeMillis();
q->PostAt(RTC_FROM_HERE, now, NULL, 3);
q->PostAt(RTC_FROM_HERE, now - 2, NULL, 0);
q->PostAt(RTC_FROM_HERE, now - 1, NULL, 1);
q->PostAt(RTC_FROM_HERE, now, NULL, 4);
q->PostAt(RTC_FROM_HERE, now - 1, NULL, 2);
q->PostAt(RTC_FROM_HERE, now, nullptr, 3);
q->PostAt(RTC_FROM_HERE, now - 2, nullptr, 0);
q->PostAt(RTC_FROM_HERE, now - 1, nullptr, 1);
q->PostAt(RTC_FROM_HERE, now, nullptr, 4);
q->PostAt(RTC_FROM_HERE, now - 1, nullptr, 2);
Message msg;
for (size_t i=0; i<5; ++i) {
@ -120,7 +120,7 @@ TEST_F(MessageQueueTest, DiposeHandlerWithPostedMessagePending) {
}
struct UnwrapMainThreadScope {
UnwrapMainThreadScope() : rewrap_(Thread::Current() != NULL) {
UnwrapMainThreadScope() : rewrap_(Thread::Current() != nullptr) {
if (rewrap_) ThreadManager::Instance()->UnwrapCurrentThread();
}
~UnwrapMainThreadScope() {

2
webrtc/base/nat_unittest.cc
View File

@ -336,7 +336,7 @@ class NatTcpTest : public testing::Test, public sigslot::has_slots<> {
}
void OnAcceptEvent(AsyncSocket* socket) {
accepted_.reset(server_->Accept(NULL));
accepted_.reset(server_->Accept(nullptr));
}
void OnCloseEvent(AsyncSocket* socket, int error) {

27
webrtc/base/natsocketfactory.cc
View File

@ -71,9 +71,13 @@ size_t UnpackAddressFromNAT(const char* buf, size_t buf_size,
class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
public:
explicit NATSocket(NATInternalSocketFactory* sf, int family, int type)
: sf_(sf), family_(family), type_(type), connected_(false),
socket_(NULL), buf_(NULL), size_(0) {
}
: sf_(sf),
family_(family),
type_(type),
connected_(false),
socket_(nullptr),
buf_(nullptr),
size_(0) {}
~NATSocket() override {
delete socket_;
@ -104,7 +108,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
} else {
server_addr_.Clear();
delete socket_;
socket_ = NULL;
socket_ = nullptr;
}
return result;
@ -211,7 +215,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
connected_ = false;
remote_addr_ = SocketAddress();
delete socket_;
socket_ = NULL;
socket_ = nullptr;
}
}
return result;
@ -339,8 +343,7 @@ AsyncSocket* NATSocketFactory::CreateInternalSocket(int family, int type,
// NATSocketServer
NATSocketServer::NATSocketServer(SocketServer* server)
: server_(server), msg_queue_(NULL) {
}
: server_(server), msg_queue_(nullptr) {}
NATSocketServer::Translator* NATSocketServer::GetTranslator(
const SocketAddress& ext_ip) {
@ -351,7 +354,7 @@ NATSocketServer::Translator* NATSocketServer::AddTranslator(
const SocketAddress& ext_ip, const SocketAddress& int_ip, NATType type) {
// Fail if a translator already exists with this extternal address.
if (nats_.Get(ext_ip))
return NULL;
return nullptr;
return nats_.Add(ext_ip, new Translator(this, type, int_ip, server_, ext_ip));
}
@ -392,7 +395,7 @@ void NATSocketServer::WakeUp() {
AsyncSocket* NATSocketServer::CreateInternalSocket(int family, int type,
const SocketAddress& local_addr, SocketAddress* nat_addr) {
AsyncSocket* socket = NULL;
AsyncSocket* socket = nullptr;
Translator* nat = nats_.FindClient(local_addr);
if (nat) {
socket = nat->internal_factory()->CreateAsyncSocket(family, type);
@ -430,7 +433,7 @@ NATSocketServer::Translator* NATSocketServer::Translator::AddTranslator(
const SocketAddress& ext_ip, const SocketAddress& int_ip, NATType type) {
// Fail if a translator already exists with this extternal address.
if (nats_.Get(ext_ip))
return NULL;
return nullptr;
AddClient(ext_ip);
return nats_.Add(ext_ip,
@ -477,7 +480,7 @@ NATSocketServer::TranslatorMap::~TranslatorMap() {
NATSocketServer::Translator* NATSocketServer::TranslatorMap::Get(
const SocketAddress& ext_ip) {
TranslatorMap::iterator it = find(ext_ip);
return (it != end()) ? it->second : NULL;
return (it != end()) ? it->second : nullptr;
}
NATSocketServer::Translator* NATSocketServer::TranslatorMap::Add(
@ -497,7 +500,7 @@ void NATSocketServer::TranslatorMap::Remove(
NATSocketServer::Translator* NATSocketServer::TranslatorMap::FindClient(
const SocketAddress& int_ip) {
Translator* nat = NULL;
Translator* nat = nullptr;
for (TranslatorMap::iterator it = begin(); it != end() && !nat; ++it) {
nat = it->second->FindClient(int_ip);
}

6
webrtc/base/nethelpers.cc
View File

@ -43,7 +43,7 @@ int ResolveHostname(const std::string& hostname, int family,
return -1;
}
addresses->clear();
struct addrinfo* result = NULL;
struct addrinfo* result = nullptr;
struct addrinfo hints = {0};
hints.ai_family = family;
// |family| here will almost always be AF_UNSPEC, because |family| comes from
@ -64,7 +64,7 @@ int ResolveHostname(const std::string& hostname, int family,
// https://android.googlesource.com/platform/bionic/+/
// 7e0bfb511e85834d7c6cb9631206b62f82701d60/libc/netbsd/net/getaddrinfo.c#1657
hints.ai_flags = AI_ADDRCONFIG;
int ret = getaddrinfo(hostname.c_str(), NULL, &hints, &result);
int ret = getaddrinfo(hostname.c_str(), nullptr, &hints, &result);
if (ret != 0) {
return ret;
}
@ -151,7 +151,7 @@ bool HasIPv6Enabled() {
}
DWORD protbuff_size = 4096;
std::unique_ptr<char[]> protocols;
LPWSAPROTOCOL_INFOW protocol_infos = NULL;
LPWSAPROTOCOL_INFOW protocol_infos = nullptr;
int requested_protocols[2] = {AF_INET6, 0};
int err = 0;

17
webrtc/base/network.cc
View File

@ -392,9 +392,10 @@ Network* NetworkManagerBase::GetNetworkFromAddress(
}
BasicNetworkManager::BasicNetworkManager()
: thread_(NULL), sent_first_update_(false), start_count_(0),
ignore_non_default_routes_(false) {
}
: thread_(nullptr),
sent_first_update_(false),
start_count_(0),
ignore_non_default_routes_(false) {}
BasicNetworkManager::~BasicNetworkManager() {
}
@ -420,8 +421,8 @@ void BasicNetworkManager::ConvertIfAddrs(struct ifaddrs* interfaces,
NetworkList* networks) const {
NetworkMap current_networks;
for (struct ifaddrs* cursor = interfaces;
cursor != NULL; cursor = cursor->ifa_next) {
for (struct ifaddrs* cursor = interfaces; cursor != nullptr;
cursor = cursor->ifa_next) {
IPAddress prefix;
IPAddress mask;
InterfaceAddress ip;
@ -518,7 +519,7 @@ unsigned int GetPrefix(PIP_ADAPTER_PREFIX prefixlist,
unsigned int best_length = 0;
while (prefixlist) {
// Look for the longest matching prefix in the prefixlist.
if (prefixlist->Address.lpSockaddr == NULL ||
if (prefixlist->Address.lpSockaddr == nullptr ||
prefixlist->Address.lpSockaddr->sa_family != ip.family()) {
prefixlist = prefixlist->Next;
continue;
@ -660,7 +661,7 @@ bool BasicNetworkManager::CreateNetworks(bool include_ignored,
#if defined(WEBRTC_LINUX)
bool IsDefaultRoute(const std::string& network_name) {
FileStream fs;
if (!fs.Open("/proc/net/route", "r", NULL)) {
if (!fs.Open("/proc/net/route", "r", nullptr)) {
LOG(LS_WARNING) << "Couldn't read /proc/net/route, skipping default "
<< "route check (assuming everything is a default route).";
return true;
@ -711,7 +712,7 @@ bool BasicNetworkManager::IsIgnoredNetwork(const Network& network) const {
// VMware Virtual Ethernet Adapter for VMnet1
// but don't ignore any GUEST side adapters with a description like:
// VMware Accelerated AMD PCNet Adapter #2
if (strstr(network.description().c_str(), "VMnet") != NULL) {
if (strstr(network.description().c_str(), "VMnet") != nullptr) {
return true;
}
#endif

95
webrtc/base/openssladapter.cc
View File

@ -40,14 +40,14 @@
#if defined(WEBRTC_WIN)
#define MUTEX_TYPE HANDLE
#define MUTEX_SETUP(x) (x) = CreateMutex(NULL, FALSE, NULL)
#define MUTEX_CLEANUP(x) CloseHandle(x)
#define MUTEX_LOCK(x) WaitForSingleObject((x), INFINITE)
#define MUTEX_UNLOCK(x) ReleaseMutex(x)
#define THREAD_ID GetCurrentThreadId()
#define MUTEX_SETUP(x) (x) = CreateMutex(nullptr, FALSE, nullptr)
#define MUTEX_CLEANUP(x) CloseHandle(x)
#define MUTEX_LOCK(x) WaitForSingleObject((x), INFINITE)
#define MUTEX_UNLOCK(x) ReleaseMutex(x)
#define THREAD_ID GetCurrentThreadId()
#elif defined(WEBRTC_POSIX)
#define MUTEX_TYPE pthread_mutex_t
#define MUTEX_SETUP(x) pthread_mutex_init(&(x), NULL)
#define MUTEX_SETUP(x) pthread_mutex_init(&(x), nullptr)
#define MUTEX_CLEANUP(x) pthread_mutex_destroy(&(x))
#define MUTEX_LOCK(x) pthread_mutex_lock(&(x))
#define MUTEX_UNLOCK(x) pthread_mutex_unlock(&(x))
@ -75,24 +75,16 @@ static int socket_free(BIO* data);
// TODO(davidben): This should be const once BoringSSL is assumed.
static BIO_METHOD methods_socket = {
BIO_TYPE_BIO,
"socket",
socket_write,
socket_read,
socket_puts,
0,
socket_ctrl,
socket_new,
socket_free,
NULL,
BIO_TYPE_BIO, "socket", socket_write, socket_read, socket_puts, 0,
socket_ctrl, socket_new, socket_free, nullptr,
};
static BIO_METHOD* BIO_s_socket2() { return(&methods_socket); }
static BIO* BIO_new_socket(rtc::AsyncSocket* socket) {
BIO* ret = BIO_new(BIO_s_socket2());
if (ret == NULL) {
return NULL;
if (ret == nullptr) {
return nullptr;
}
ret->ptr = socket;
return ret;
@ -107,7 +99,7 @@ static int socket_new(BIO* b) {
}
static int socket_free(BIO* b) {
if (b == NULL)
if (b == nullptr)
return 0;
return 1;
}
@ -171,7 +163,7 @@ namespace rtc {
#ifndef OPENSSL_IS_BORINGSSL
// This array will store all of the mutexes available to OpenSSL.
static MUTEX_TYPE* mutex_buf = NULL;
static MUTEX_TYPE* mutex_buf = nullptr;
static void locking_function(int mode, int n, const char * file, int line) {
if (mode & CRYPTO_LOCK) {
@ -191,7 +183,7 @@ static unsigned long id_function() { // NOLINT
static CRYPTO_dynlock_value* dyn_create_function(const char* file, int line) {
CRYPTO_dynlock_value* value = new CRYPTO_dynlock_value;
if (!value)
return NULL;
return nullptr;
MUTEX_SETUP(value->mutex);
return value;
}
@ -213,7 +205,7 @@ static void dyn_destroy_function(CRYPTO_dynlock_value* l,
#endif // #ifndef OPENSSL_IS_BORINGSSL
VerificationCallback OpenSSLAdapter::custom_verify_callback_ = NULL;
VerificationCallback OpenSSLAdapter::custom_verify_callback_ = nullptr;
bool OpenSSLAdapter::InitializeSSL(VerificationCallback callback) {
if (!InitializeSSLThread() || !SSL_library_init())
@ -254,29 +246,29 @@ bool OpenSSLAdapter::CleanupSSL() {
#ifndef OPENSSL_IS_BORINGSSL
if (!mutex_buf)
return false;
CRYPTO_set_id_callback(NULL);
CRYPTO_set_locking_callback(NULL);
CRYPTO_set_dynlock_create_callback(NULL);
CRYPTO_set_dynlock_lock_callback(NULL);
CRYPTO_set_dynlock_destroy_callback(NULL);
CRYPTO_set_id_callback(nullptr);
CRYPTO_set_locking_callback(nullptr);
CRYPTO_set_dynlock_create_callback(nullptr);
CRYPTO_set_dynlock_lock_callback(nullptr);
CRYPTO_set_dynlock_destroy_callback(nullptr);
for (int i = 0; i < CRYPTO_num_locks(); ++i)
MUTEX_CLEANUP(mutex_buf[i]);
delete [] mutex_buf;
mutex_buf = NULL;
mutex_buf = nullptr;
#endif // #ifndef OPENSSL_IS_BORINGSSL
return true;
}
OpenSSLAdapter::OpenSSLAdapter(AsyncSocket* socket)
: SSLAdapter(socket),
state_(SSL_NONE),
ssl_read_needs_write_(false),
ssl_write_needs_read_(false),
restartable_(false),
ssl_(NULL), ssl_ctx_(NULL),
ssl_mode_(SSL_MODE_TLS),
custom_verification_succeeded_(false) {
}
: SSLAdapter(socket),
state_(SSL_NONE),
ssl_read_needs_write_(false),
ssl_write_needs_read_(false),
restartable_(false),
ssl_(nullptr),
ssl_ctx_(nullptr),
ssl_mode_(SSL_MODE_TLS),
custom_verification_succeeded_(false) {}
OpenSSLAdapter::~OpenSSLAdapter() {
Cleanup();
@ -316,7 +308,7 @@ OpenSSLAdapter::BeginSSL() {
RTC_DCHECK(state_ == SSL_CONNECTING);
int err = 0;
BIO* bio = NULL;
BIO* bio = nullptr;
// First set up the context
if (!ssl_ctx_)
@ -346,7 +338,7 @@ OpenSSLAdapter::BeginSSL() {
SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
// the SSL object owns the bio now
bio = NULL;
bio = nullptr;
// Do the connect
err = ContinueSSL();
@ -437,12 +429,12 @@ OpenSSLAdapter::Cleanup() {
if (ssl_) {
SSL_free(ssl_);
ssl_ = NULL;
ssl_ = nullptr;
}
if (ssl_ctx_) {
SSL_CTX_free(ssl_ctx_);
ssl_ctx_ = NULL;
ssl_ctx_ = nullptr;
}
// Clear the DTLS timer
@ -707,7 +699,7 @@ bool OpenSSLAdapter::VerifyServerName(SSL* ssl, const char* host,
// Checking the return from SSL_get_peer_certificate here is not strictly
// necessary. With our setup, it is not possible for it to return
// NULL. However, it is good form to check the return.
// null. However, it is good form to check the return.
X509* certificate = SSL_get_peer_certificate(ssl);
if (!certificate)
return false;
@ -725,7 +717,7 @@ bool OpenSSLAdapter::VerifyServerName(SSL* ssl, const char* host,
BIO_free(mem);
char* cipher_description =
SSL_CIPHER_description(SSL_get_current_cipher(ssl), NULL, 128);
SSL_CIPHER_description(SSL_get_current_cipher(ssl), nullptr, 128);
LOG(LS_INFO) << "Cipher: " << cipher_description;
OPENSSL_free(cipher_description);
}
@ -755,10 +747,9 @@ bool OpenSSLAdapter::VerifyServerName(SSL* ssl, const char* host,
char data[256];
X509_NAME* subject;
if (!ok
&& ((subject = X509_get_subject_name(certificate)) != NULL)
&& (X509_NAME_get_text_by_NID(subject, NID_commonName,
data, sizeof(data)) > 0)) {
if (!ok && ((subject = X509_get_subject_name(certificate)) != nullptr) &&
(X509_NAME_get_text_by_NID(subject, NID_commonName, data, sizeof(data)) >
0)) {
data[sizeof(data)-1] = 0;
if (_stricmp(data, host) == 0)
ok = true;
@ -875,8 +866,8 @@ bool OpenSSLAdapter::ConfigureTrustedRootCertificates(SSL_CTX* ctx) {
for (size_t i = 0; i < arraysize(kSSLCertCertificateList); i++) {
const unsigned char* cert_buffer = kSSLCertCertificateList[i];
size_t cert_buffer_len = kSSLCertCertificateSizeList[i];
X509* cert = d2i_X509(NULL, &cert_buffer,
checked_cast<long>(cert_buffer_len));
X509* cert =
d2i_X509(nullptr, &cert_buffer, checked_cast<long>(cert_buffer_len));
if (cert) {
int return_value = X509_STORE_add_cert(SSL_CTX_get_cert_store(ctx), cert);
if (return_value == 0) {
@ -894,16 +885,16 @@ SSL_CTX*
OpenSSLAdapter::SetupSSLContext() {
SSL_CTX* ctx = SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ?
DTLSv1_client_method() : TLSv1_client_method());
if (ctx == NULL) {
if (ctx == nullptr) {
unsigned long error = ERR_get_error(); // NOLINT: type used by OpenSSL.
LOG(LS_WARNING) << "SSL_CTX creation failed: "
<< '"' << ERR_reason_error_string(error) << "\" "
<< "(error=" << error << ')';
return NULL;
return nullptr;
}
if (!ConfigureTrustedRootCertificates(ctx)) {
SSL_CTX_free(ctx);
return NULL;
return nullptr;
}
#if !defined(NDEBUG)

10
webrtc/base/openssldigest.cc
View File

@ -18,9 +18,9 @@ namespace rtc {
OpenSSLDigest::OpenSSLDigest(const std::string& algorithm) {
EVP_MD_CTX_init(&ctx_);
if (GetDigestEVP(algorithm, &md_)) {
EVP_DigestInit_ex(&ctx_, md_, NULL);
EVP_DigestInit_ex(&ctx_, md_, nullptr);
} else {
md_ = NULL;
md_ = nullptr;
}
}
@ -48,7 +48,7 @@ size_t OpenSSLDigest::Finish(void* buf, size_t len) {
}
unsigned int md_len;
EVP_DigestFinal_ex(&ctx_, static_cast<unsigned char*>(buf), &md_len);
EVP_DigestInit_ex(&ctx_, md_, NULL); // prepare for future Update()s
EVP_DigestInit_ex(&ctx_, md_, nullptr); // prepare for future Update()s
RTC_DCHECK(md_len == Size());
return md_len;
}
@ -80,8 +80,8 @@ bool OpenSSLDigest::GetDigestEVP(const std::string& algorithm,
bool OpenSSLDigest::GetDigestName(const EVP_MD* md,
std::string* algorithm) {
RTC_DCHECK(md != NULL);
RTC_DCHECK(algorithm != NULL);
RTC_DCHECK(md != nullptr);
RTC_DCHECK(algorithm != nullptr);
int md_type = EVP_MD_type(md);
if (md_type == NID_md5) {

56
webrtc/base/opensslidentity.cc
View File

@ -46,13 +46,13 @@ static EVP_PKEY* MakeKey(const KeyParams& key_params) {
RSA* rsa = RSA_new();
if (!pkey || !exponent || !rsa ||
!BN_set_word(exponent, key_params.rsa_params().pub_exp) ||
!RSA_generate_key_ex(rsa, key_length, exponent, NULL) ||
!RSA_generate_key_ex(rsa, key_length, exponent, nullptr) ||
!EVP_PKEY_assign_RSA(pkey, rsa)) {
EVP_PKEY_free(pkey);
BN_free(exponent);
RSA_free(rsa);
LOG(LS_ERROR) << "Failed to make RSA key pair";
return NULL;
return nullptr;
}
// ownership of rsa struct was assigned, don't free it.
BN_free(exponent);
@ -71,19 +71,19 @@ static EVP_PKEY* MakeKey(const KeyParams& key_params) {
EVP_PKEY_free(pkey);
EC_KEY_free(ec_key);
LOG(LS_ERROR) << "Failed to make EC key pair";
return NULL;
return nullptr;
}
// ownership of ec_key struct was assigned, don't free it.
} else {
// Add generation of any other curves here.
EVP_PKEY_free(pkey);
LOG(LS_ERROR) << "ECDSA key requested for unknown curve";
return NULL;
return nullptr;
}
} else {
EVP_PKEY_free(pkey);
LOG(LS_ERROR) << "Key type requested not understood";
return NULL;
return nullptr;
}
LOG(LS_INFO) << "Returning key pair";
@ -94,12 +94,12 @@ static EVP_PKEY* MakeKey(const KeyParams& key_params) {
// given key pair. Caller is responsible for freeing the returned object.
static X509* MakeCertificate(EVP_PKEY* pkey, const SSLIdentityParams& params) {
LOG(LS_INFO) << "Making certificate for " << params.common_name;
X509* x509 = NULL;
BIGNUM* serial_number = NULL;
X509_NAME* name = NULL;
X509* x509 = nullptr;
BIGNUM* serial_number = nullptr;
X509_NAME* name = nullptr;
time_t epoch_off = 0; // Time offset since epoch.
if ((x509=X509_new()) == NULL)
if ((x509 = X509_new()) == nullptr)
goto error;
if (!X509_set_pubkey(x509, pkey))
@ -108,9 +108,9 @@ static X509* MakeCertificate(EVP_PKEY* pkey, const SSLIdentityParams& params) {
// serial number
// temporary reference to serial number inside x509 struct
ASN1_INTEGER* asn1_serial_number;
if ((serial_number = BN_new()) == NULL ||
if ((serial_number = BN_new()) == nullptr ||
!BN_pseudo_rand(serial_number, SERIAL_RAND_BITS, 0, 0) ||
(asn1_serial_number = X509_get_serialNumber(x509)) == NULL ||
(asn1_serial_number = X509_get_serialNumber(x509)) == nullptr ||
!BN_to_ASN1_INTEGER(serial_number, asn1_serial_number))
goto error;
@ -124,12 +124,11 @@ static X509* MakeCertificate(EVP_PKEY* pkey, const SSLIdentityParams& params) {
// arbitrary common_name. Note that this certificate goes out in
// clear during SSL negotiation, so there may be a privacy issue in
// putting anything recognizable here.
if ((name = X509_NAME_new()) == NULL ||
!X509_NAME_add_entry_by_NID(
name, NID_commonName, MBSTRING_UTF8,
(unsigned char*)params.common_name.c_str(), -1, -1, 0) ||
!X509_set_subject_name(x509, name) ||
!X509_set_issuer_name(x509, name))
if ((name = X509_NAME_new()) == nullptr ||
!X509_NAME_add_entry_by_NID(name, NID_commonName, MBSTRING_UTF8,
(unsigned char*)params.common_name.c_str(),
-1, -1, 0) ||
!X509_set_subject_name(x509, name) || !X509_set_issuer_name(x509, name))
goto error;
if (!X509_time_adj(X509_get_notBefore(x509), params.not_before, &epoch_off) ||
@ -148,7 +147,7 @@ static X509* MakeCertificate(EVP_PKEY* pkey, const SSLIdentityParams& params) {
BN_free(serial_number);
X509_NAME_free(name);
X509_free(x509);
return NULL;
return nullptr;
}
// This dumps the SSL error stack to the log.
@ -166,7 +165,7 @@ OpenSSLKeyPair* OpenSSLKeyPair::Generate(const KeyParams& key_params) {
EVP_PKEY* pkey = MakeKey(key_params);
if (!pkey) {
LogSSLErrors("Generating key pair");
return NULL;
return nullptr;
}
return new OpenSSLKeyPair(pkey);
}
@ -289,7 +288,7 @@ OpenSSLCertificate* OpenSSLCertificate::Generate(
X509* x509 = MakeCertificate(key_pair->pkey(), actual_params);
if (!x509) {
LogSSLErrors("Generating certificate");
return NULL;
return nullptr;
}
#if !defined(NDEBUG)
PrintCert(x509);
@ -303,13 +302,14 @@ OpenSSLCertificate* OpenSSLCertificate::FromPEMString(
const std::string& pem_string) {
BIO* bio = BIO_new_mem_buf(const_cast<char*>(pem_string.c_str()), -1);
if (!bio)
return NULL;
return nullptr;
BIO_set_mem_eof_return(bio, 0);
X509* x509 = PEM_read_bio_X509(bio, NULL, NULL, const_cast<char*>("\0"));
X509* x509 =
PEM_read_bio_X509(bio, nullptr, nullptr, const_cast<char*>("\0"));
BIO_free(bio); // Frees the BIO, but not the pointed-to string.
if (!x509)
return NULL;
return nullptr;
OpenSSLCertificate* ret = new OpenSSLCertificate(x509);
X509_free(x509);
@ -441,7 +441,7 @@ void OpenSSLCertificate::ToDER(Buffer* der_buffer) const {
}
void OpenSSLCertificate::AddReference() const {
RTC_DCHECK(x509_ != NULL);
RTC_DCHECK(x509_ != nullptr);
#if defined(OPENSSL_IS_BORINGSSL)
X509_up_ref(x509_);
#else
@ -476,8 +476,8 @@ int64_t OpenSSLCertificate::CertificateExpirationTime() const {
OpenSSLIdentity::OpenSSLIdentity(OpenSSLKeyPair* key_pair,
OpenSSLCertificate* certificate)
: key_pair_(key_pair), certificate_(certificate) {
RTC_DCHECK(key_pair != NULL);
RTC_DCHECK(certificate != NULL);
RTC_DCHECK(key_pair != nullptr);
RTC_DCHECK(certificate != nullptr);
}
OpenSSLIdentity::~OpenSSLIdentity() = default;
@ -493,7 +493,7 @@ OpenSSLIdentity* OpenSSLIdentity::GenerateInternal(
delete key_pair;
}
LOG(LS_INFO) << "Identity generation failed";
return NULL;
return nullptr;
}
OpenSSLIdentity* OpenSSLIdentity::GenerateWithExpiration(
@ -503,7 +503,7 @@ OpenSSLIdentity* OpenSSLIdentity::GenerateWithExpiration(
SSLIdentityParams params;
params.key_params = key_params;
params.common_name = common_name;
time_t now = time(NULL);
time_t now = time(nullptr);
params.not_before = now + kCertificateWindowInSeconds;
params.not_after = now + certificate_lifetime;
if (params.not_before > params.not_after)

2
webrtc/base/opensslidentity.h
View File

@ -30,7 +30,7 @@ namespace rtc {
class OpenSSLKeyPair {
public:
explicit OpenSSLKeyPair(EVP_PKEY* pkey) : pkey_(pkey) {
RTC_DCHECK(pkey_ != NULL);
RTC_DCHECK(pkey_ != nullptr);
}
static OpenSSLKeyPair* Generate(const KeyParams& key_params);

156
webrtc/base/opensslstreamadapter.cc
View File

@ -86,70 +86,62 @@ struct SslCipherMapEntry {
// (as available in OpenSSL if compiled with tracing enabled) or a similar
// method.
static const SslCipherMapEntry kSslCipherMap[] = {
// TLS v1.0 ciphersuites from RFC2246.
DEFINE_CIPHER_ENTRY_SSL3(RSA_RC4_128_SHA),
{SSL3_CK_RSA_DES_192_CBC3_SHA,
"TLS_RSA_WITH_3DES_EDE_CBC_SHA"},
// TLS v1.0 ciphersuites from RFC2246.
DEFINE_CIPHER_ENTRY_SSL3(RSA_RC4_128_SHA),
{SSL3_CK_RSA_DES_192_CBC3_SHA, "TLS_RSA_WITH_3DES_EDE_CBC_SHA"},
// AES ciphersuites from RFC3268.
{TLS1_CK_RSA_WITH_AES_128_SHA,
"TLS_RSA_WITH_AES_128_CBC_SHA"},
{TLS1_CK_DHE_RSA_WITH_AES_128_SHA,
"TLS_DHE_RSA_WITH_AES_128_CBC_SHA"},
{TLS1_CK_RSA_WITH_AES_256_SHA,
"TLS_RSA_WITH_AES_256_CBC_SHA"},
{TLS1_CK_DHE_RSA_WITH_AES_256_SHA,
"TLS_DHE_RSA_WITH_AES_256_CBC_SHA"},
// AES ciphersuites from RFC3268.
{TLS1_CK_RSA_WITH_AES_128_SHA, "TLS_RSA_WITH_AES_128_CBC_SHA"},
{TLS1_CK_DHE_RSA_WITH_AES_128_SHA, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"},
{TLS1_CK_RSA_WITH_AES_256_SHA, "TLS_RSA_WITH_AES_256_CBC_SHA"},
{TLS1_CK_DHE_RSA_WITH_AES_256_SHA, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"},
// ECC ciphersuites from RFC4492.
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_RC4_128_SHA),
{TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA,
"TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"},
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_128_CBC_SHA),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_256_CBC_SHA),
// ECC ciphersuites from RFC4492.
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_RC4_128_SHA),
{TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA,
"TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"},
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_128_CBC_SHA),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_256_CBC_SHA),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_RC4_128_SHA),
{TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA,
"TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"},
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_128_CBC_SHA),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_256_CBC_SHA),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_RC4_128_SHA),
{TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA,
"TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"},
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_128_CBC_SHA),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_256_CBC_SHA),
// TLS v1.2 ciphersuites.
{TLS1_CK_RSA_WITH_AES_128_SHA256,
"TLS_RSA_WITH_AES_128_CBC_SHA256"},
{TLS1_CK_RSA_WITH_AES_256_SHA256,
"TLS_RSA_WITH_AES_256_CBC_SHA256"},
{TLS1_CK_DHE_RSA_WITH_AES_128_SHA256,
"TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"},
{TLS1_CK_DHE_RSA_WITH_AES_256_SHA256,
"TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"},
// TLS v1.2 ciphersuites.
{TLS1_CK_RSA_WITH_AES_128_SHA256, "TLS_RSA_WITH_AES_128_CBC_SHA256"},
{TLS1_CK_RSA_WITH_AES_256_SHA256, "TLS_RSA_WITH_AES_256_CBC_SHA256"},
{TLS1_CK_DHE_RSA_WITH_AES_128_SHA256,
"TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"},
{TLS1_CK_DHE_RSA_WITH_AES_256_SHA256,
"TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"},
// TLS v1.2 GCM ciphersuites from RFC5288.
DEFINE_CIPHER_ENTRY_TLS1(RSA_WITH_AES_128_GCM_SHA256),
DEFINE_CIPHER_ENTRY_TLS1(RSA_WITH_AES_256_GCM_SHA384),
DEFINE_CIPHER_ENTRY_TLS1(DHE_RSA_WITH_AES_128_GCM_SHA256),
DEFINE_CIPHER_ENTRY_TLS1(DHE_RSA_WITH_AES_256_GCM_SHA384),
DEFINE_CIPHER_ENTRY_TLS1(DH_RSA_WITH_AES_128_GCM_SHA256),
DEFINE_CIPHER_ENTRY_TLS1(DH_RSA_WITH_AES_256_GCM_SHA384),
// TLS v1.2 GCM ciphersuites from RFC5288.
DEFINE_CIPHER_ENTRY_TLS1(RSA_WITH_AES_128_GCM_SHA256),
DEFINE_CIPHER_ENTRY_TLS1(RSA_WITH_AES_256_GCM_SHA384),
DEFINE_CIPHER_ENTRY_TLS1(DHE_RSA_WITH_AES_128_GCM_SHA256),
DEFINE_CIPHER_ENTRY_TLS1(DHE_RSA_WITH_AES_256_GCM_SHA384),
DEFINE_CIPHER_ENTRY_TLS1(DH_RSA_WITH_AES_128_GCM_SHA256),
DEFINE_CIPHER_ENTRY_TLS1(DH_RSA_WITH_AES_256_GCM_SHA384),
// ECDH HMAC based ciphersuites from RFC5289.
{TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256,
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"},
{TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384,
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"},
{TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256,
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"},
{TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384,
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"},
// ECDH HMAC based ciphersuites from RFC5289.
{TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256,
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"},
{TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384,
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"},
{TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256,
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"},
{TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384,
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"},
// ECDH GCM based ciphersuites from RFC5289.
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_128_GCM_SHA256),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_256_GCM_SHA384),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_128_GCM_SHA256),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_256_GCM_SHA384),
// ECDH GCM based ciphersuites from RFC5289.
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_128_GCM_SHA256),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_256_GCM_SHA384),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_128_GCM_SHA256),
DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_256_GCM_SHA384),
{0, NULL}
};
{0, nullptr}};
#endif // #ifndef OPENSSL_IS_BORINGSSL
#if defined(_MSC_VER)
@ -175,24 +167,16 @@ static int stream_free(BIO* data);
// TODO(davidben): This should be const once BoringSSL is assumed.
static BIO_METHOD methods_stream = {
BIO_TYPE_BIO,
"stream",
stream_write,
stream_read,
stream_puts,
0,
stream_ctrl,
stream_new,
stream_free,
NULL,
BIO_TYPE_BIO, "stream", stream_write, stream_read, stream_puts, 0,
stream_ctrl, stream_new, stream_free, nullptr,
};
static BIO_METHOD* BIO_s_stream() { return(&methods_stream); }
static BIO* BIO_new_stream(StreamInterface* stream) {
BIO* ret = BIO_new(BIO_s_stream());
if (ret == NULL)
return NULL;
if (ret == nullptr)
return nullptr;
ret->ptr = stream;
return ret;
}
@ -208,7 +192,7 @@ static int stream_new(BIO* b) {
}
static int stream_free(BIO* b) {
if (b == NULL)
if (b == nullptr)
return 0;
return 1;
}
@ -283,8 +267,8 @@ OpenSSLStreamAdapter::OpenSSLStreamAdapter(StreamInterface* stream)
role_(SSL_CLIENT),
ssl_read_needs_write_(false),
ssl_write_needs_read_(false),
ssl_(NULL),
ssl_ctx_(NULL),
ssl_(nullptr),
ssl_ctx_(nullptr),
ssl_mode_(SSL_MODE_TLS),
ssl_max_version_(SSL_PROTOCOL_TLS_12) {}
@ -387,7 +371,7 @@ bool OpenSSLStreamAdapter::GetSslCipherSuite(int* cipher_suite) {
return false;
const SSL_CIPHER* current_cipher = SSL_get_current_cipher(ssl_);
if (current_cipher == NULL) {
if (current_cipher == nullptr) {
return false;
}
@ -516,13 +500,13 @@ void OpenSSLStreamAdapter::SetMode(SSLMode mode) {
}
void OpenSSLStreamAdapter::SetMaxProtocolVersion(SSLProtocolVersion version) {
RTC_DCHECK(ssl_ctx_ == NULL);
RTC_DCHECK(ssl_ctx_ == nullptr);
ssl_max_version_ = version;
}
void OpenSSLStreamAdapter::SetInitialRetransmissionTimeout(
int timeout_ms) {
RTC_DCHECK(ssl_ctx_ == NULL);
RTC_DCHECK(ssl_ctx_ == nullptr);
dtls_handshake_timeout_ms_ = timeout_ms;
}
@ -780,10 +764,10 @@ int OpenSSLStreamAdapter::BeginSSL() {
// The underlying stream has opened.
LOG(LS_INFO) << "BeginSSL with peer.";
BIO* bio = NULL;
BIO* bio = nullptr;
// First set up the context.
RTC_DCHECK(ssl_ctx_ == NULL);
RTC_DCHECK(ssl_ctx_ == nullptr);
ssl_ctx_ = SetupSSLContext();
if (!ssl_ctx_)
return -1;
@ -820,7 +804,7 @@ int OpenSSLStreamAdapter::BeginSSL() {
// commonly supported. BoringSSL doesn't need explicit configuration and has
// a reasonable default set.
EC_KEY* ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
if (ecdh == NULL)
if (ecdh == nullptr)
return -1;
SSL_set_options(ssl_, SSL_OP_SINGLE_ECDH_USE);
SSL_set_tmp_ecdh(ssl_, ecdh);
@ -935,11 +919,11 @@ void OpenSSLStreamAdapter::Cleanup(uint8_t alert) {
}
#endif
SSL_free(ssl_);
ssl_ = NULL;
ssl_ = nullptr;
}
if (ssl_ctx_) {
SSL_CTX_free(ssl_ctx_);
ssl_ctx_ = NULL;
ssl_ctx_ = nullptr;
}
identity_.reset();
peer_certificate_.reset();
@ -961,7 +945,7 @@ void OpenSSLStreamAdapter::OnMessage(Message* msg) {
}
SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
SSL_CTX *ctx = NULL;
SSL_CTX* ctx = nullptr;
#ifdef OPENSSL_IS_BORINGSSL
ctx = SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ?
@ -1026,8 +1010,8 @@ SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
ctx = SSL_CTX_new(method);
#endif // OPENSSL_IS_BORINGSSL
if (ctx == NULL)
return NULL;
if (ctx == nullptr)
return nullptr;
#ifdef OPENSSL_IS_BORINGSSL
SSL_CTX_set_min_proto_version(ctx, ssl_mode_ == SSL_MODE_DTLS ?
@ -1054,7 +1038,7 @@ SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
if (identity_ && !identity_->ConfigureIdentity(ctx)) {
SSL_CTX_free(ctx);
return NULL;
return nullptr;
}
#if !defined(NDEBUG)
@ -1075,13 +1059,13 @@ SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
// remove HMAC-SHA256 and HMAC-SHA384 cipher suites, not GCM cipher suites
// with SHA256 or SHA384 as the handshake hash.
// This matches the list of SSLClientSocketOpenSSL in Chromium.
SSL_CTX_set_cipher_list(ctx,
"DEFAULT:!NULL:!aNULL:!SHA256:!SHA384:!aECDH:!AESGCM+AES256:!aPSK");
SSL_CTX_set_cipher_list(
ctx, "DEFAULT:!NULL:!aNULL:!SHA256:!SHA384:!aECDH:!AESGCM+AES256:!aPSK");
if (!srtp_ciphers_.empty()) {
if (SSL_CTX_set_tlsext_use_srtp(ctx, srtp_ciphers_.c_str())) {
SSL_CTX_free(ctx);
return NULL;
return nullptr;
}
}

2
webrtc/base/optionsfile_unittest.cc
View File

@ -47,7 +47,7 @@ class MAYBE_OptionsFileTest : public testing::Test {
public:
MAYBE_OptionsFileTest() {
Pathname dir;
RTC_CHECK(Filesystem::GetTemporaryFolder(dir, true, NULL));
RTC_CHECK(Filesystem::GetTemporaryFolder(dir, true, nullptr));
test_file_ = Filesystem::TempFilename(dir, ".testfile");
OpenStore();
}

2
webrtc/base/pathutils.cc
View File

@ -43,7 +43,7 @@ const char DEFAULT_FOLDER_DELIM = '/';
///////////////////////////////////////////////////////////////////////////////
bool Pathname::IsFolderDelimiter(char ch) {
return (NULL != ::strchr(FOLDER_DELIMS, ch));
return (nullptr != ::strchr(FOLDER_DELIMS, ch));
}
char Pathname::DefaultFolderDelimiter() {

16
webrtc/base/physicalsocketserver.cc
View File

@ -1118,15 +1118,15 @@ class EventDispatcher : public Dispatcher {
}
~EventDispatcher() {
if (hev_ != NULL) {
if (hev_ != nullptr) {
ss_->Remove(this);
WSACloseEvent(hev_);
hev_ = NULL;
hev_ = nullptr;
}
}
virtual void Signal() {
if (hev_ != NULL)
if (hev_ != nullptr)
WSASetEvent(hev_);
}
@ -1268,7 +1268,7 @@ void PhysicalSocketServer::Remove(Dispatcher *pdispatcher) {
bool PhysicalSocketServer::Wait(int cmsWait, bool process_io) {
// Calculate timing information
struct timeval *ptvWait = NULL;
struct timeval* ptvWait = nullptr;
struct timeval tvWait;
struct timeval tvStop;
if (cmsWait != kForever) {
@ -1278,7 +1278,7 @@ bool PhysicalSocketServer::Wait(int cmsWait, bool process_io) {
ptvWait = &tvWait;
// Calculate when to return in a timeval
gettimeofday(&tvStop, NULL);
gettimeofday(&tvStop, nullptr);
tvStop.tv_sec += tvWait.tv_sec;
tvStop.tv_usec += tvWait.tv_usec;
if (tvStop.tv_usec >= 1000000) {
@ -1330,7 +1330,7 @@ bool PhysicalSocketServer::Wait(int cmsWait, bool process_io) {
// < 0 means error
// 0 means timeout
// > 0 means count of descriptors ready
int n = select(fdmax + 1, &fdsRead, &fdsWrite, NULL, ptvWait);
int n = select(fdmax + 1, &fdsRead, &fdsWrite, nullptr, ptvWait);
// If error, return error.
if (n < 0) {
@ -1405,7 +1405,7 @@ bool PhysicalSocketServer::Wait(int cmsWait, bool process_io) {
ptvWait->tv_sec = 0;
ptvWait->tv_usec = 0;
struct timeval tvT;
gettimeofday(&tvT, NULL);
gettimeofday(&tvT, nullptr);
if ((tvStop.tv_sec > tvT.tv_sec)
|| ((tvStop.tv_sec == tvT.tv_sec)
&& (tvStop.tv_usec > tvT.tv_usec))) {
@ -1473,7 +1473,7 @@ bool PhysicalSocketServer::InstallSignal(int signum, void (*handler)(int)) {
#else
act.sa_flags = 0;
#endif
if (sigaction(signum, &act, NULL) != 0) {
if (sigaction(signum, &act, nullptr) != 0) {
LOG_ERR(LS_ERROR) << "Couldn't set sigaction";
return false;
}

10
webrtc/base/physicalsocketserver_unittest.cc
View File

@ -483,9 +483,9 @@ class PosixSignalDeliveryTest : public testing::Test {
}
void TearDown() {
ss_.reset(NULL);
ss_.reset(nullptr);
signals_received_.clear();
signaled_thread_ = NULL;
signaled_thread_ = nullptr;
}
bool ExpectSignal(int signum) {
@ -518,7 +518,7 @@ class PosixSignalDeliveryTest : public testing::Test {
};
std::vector<int> PosixSignalDeliveryTest::signals_received_;
Thread *PosixSignalDeliveryTest::signaled_thread_ = NULL;
Thread* PosixSignalDeliveryTest::signaled_thread_ = nullptr;
// Test receiving a synchronous signal while not in Wait() and then entering
// Wait() afterwards.
@ -563,7 +563,7 @@ class RaiseSigTermRunnable : public Runnable {
// be delivered to us.
sigset_t mask;
sigemptyset(&mask);
pthread_sigmask(SIG_SETMASK, &mask, NULL);
pthread_sigmask(SIG_SETMASK, &mask, nullptr);
// Raise it.
raise(SIGTERM);
@ -578,7 +578,7 @@ TEST_F(PosixSignalDeliveryTest, SignalOnDifferentThread) {
sigset_t mask;
sigemptyset(&mask);
sigaddset(&mask, SIGTERM);
EXPECT_EQ(0, pthread_sigmask(SIG_SETMASK, &mask, NULL));
EXPECT_EQ(0, pthread_sigmask(SIG_SETMASK, &mask, nullptr));
// Start a new thread that raises it. It will have to be delivered to that
// thread. Our implementation should safely handle it and dispatch
// RecordSignal() on this thread.

4
webrtc/base/platform_file.cc
View File

@ -26,10 +26,10 @@ const PlatformFile kInvalidPlatformFileValue = INVALID_HANDLE_VALUE;
FILE* FdopenPlatformFileForWriting(PlatformFile file) {
if (file == kInvalidPlatformFileValue)
return NULL;
return nullptr;
int fd = _open_osfhandle(reinterpret_cast<intptr_t>(file), 0);
if (fd < 0)
return NULL;
return nullptr;
return _fdopen(fd, "w");
}

2
webrtc/base/platform_thread.cc
View File

@ -149,7 +149,7 @@ void PlatformThread::Start() {
// See bug 2902 for background on STACK_SIZE_PARAM_IS_A_RESERVATION.
// Set the reserved stack stack size to 1M, which is the default on Windows
// and Linux.
thread_ = ::CreateThread(NULL, 1024 * 1024, &StartThread, this,
thread_ = ::CreateThread(nullptr, 1024 * 1024, &StartThread, this,
STACK_SIZE_PARAM_IS_A_RESERVATION, &thread_id_);
RTC_CHECK(thread_) << "CreateThread failed";
RTC_DCHECK(thread_id_);

10
webrtc/base/proxy_unittest.cc
View File

@ -31,16 +31,14 @@ static const SocketAddress kBogusProxyIntAddr("1.2.3.4", 999);
// Sets up a virtual socket server and HTTPS/SOCKS5 proxy servers.
class ProxyTest : public testing::Test {
public:
ProxyTest() : ss_(new rtc::VirtualSocketServer(NULL)) {
ProxyTest() : ss_(new rtc::VirtualSocketServer(nullptr)) {
Thread::Current()->set_socketserver(ss_.get());
socks_.reset(new rtc::SocksProxyServer(
ss_.get(), kSocksProxyIntAddr, ss_.get(), kSocksProxyExtAddr));
https_.reset(new rtc::HttpListenServer());
https_->Listen(kHttpsProxyIntAddr);
}
~ProxyTest() {
Thread::Current()->set_socketserver(NULL);
}
~ProxyTest() { Thread::Current()->set_socketserver(nullptr); }
rtc::SocketServer* ss() { return ss_.get(); }
@ -65,7 +63,7 @@ TEST_F(ProxyTest, TestSocks5Connect) {
rtc::AsyncTCPSocket* packet_socket = rtc::AsyncTCPSocket::Create(
proxy_socket, SocketAddress(INADDR_ANY, 0), server.address());
EXPECT_TRUE(packet_socket != NULL);
EXPECT_TRUE(packet_socket != nullptr);
rtc::TestClient client(packet_socket);
EXPECT_EQ(Socket::CS_CONNECTING, proxy_socket->GetState());
@ -73,6 +71,6 @@ TEST_F(ProxyTest, TestSocks5Connect) {
EXPECT_EQ(Socket::CS_CONNECTED, proxy_socket->GetState());
EXPECT_EQ(server.address(), client.remote_address());
client.Send("foo", 3);
EXPECT_TRUE(client.CheckNextPacket("foo", 3, NULL));
EXPECT_TRUE(client.CheckNextPacket("foo", 3, nullptr));
EXPECT_TRUE(client.CheckNoPacket());
}

14
webrtc/base/proxyserver.cc
View File

@ -24,7 +24,7 @@ ProxyServer::ProxyServer(
: ext_factory_(ext_factory), ext_ip_(ext_ip.ipaddr(), 0), // strip off port
server_socket_(int_factory->CreateAsyncSocket(int_addr.family(),
SOCK_STREAM)) {
RTC_DCHECK(server_socket_.get() != NULL);
RTC_DCHECK(server_socket_.get() != nullptr);
RTC_DCHECK(int_addr.family() == AF_INET || int_addr.family() == AF_INET6);
server_socket_->Bind(int_addr);
server_socket_->Listen(5);
@ -43,8 +43,8 @@ SocketAddress ProxyServer::GetServerAddress() {
}
void ProxyServer::OnAcceptEvent(AsyncSocket* socket) {
RTC_DCHECK(socket != NULL && socket == server_socket_.get());
AsyncSocket* int_socket = socket->Accept(NULL);
RTC_DCHECK(socket != nullptr && socket == server_socket_.get());
AsyncSocket* int_socket = socket->Accept(nullptr);
AsyncProxyServerSocket* wrapped_socket = WrapSocket(int_socket);
AsyncSocket* ext_socket = ext_factory_->CreateAsyncSocket(ext_ip_.family(),
SOCK_STREAM);
@ -84,7 +84,7 @@ ProxyBinding::~ProxyBinding() = default;
void ProxyBinding::OnConnectRequest(AsyncProxyServerSocket* socket,
const SocketAddress& addr) {
RTC_DCHECK(!connected_ && ext_socket_.get() != NULL);
RTC_DCHECK(!connected_ && ext_socket_.get() != nullptr);
ext_socket_->Connect(addr);
// TODO: handle errors here
}
@ -103,7 +103,7 @@ void ProxyBinding::OnInternalClose(AsyncSocket* socket, int err) {
}
void ProxyBinding::OnExternalConnect(AsyncSocket* socket) {
RTC_DCHECK(socket != NULL);
RTC_DCHECK(socket != nullptr);
connected_ = true;
int_socket_->SendConnectResult(0, socket->GetRemoteAddress());
}
@ -126,7 +126,7 @@ void ProxyBinding::OnExternalClose(AsyncSocket* socket, int err) {
void ProxyBinding::Read(AsyncSocket* socket, FifoBuffer* buffer) {
// Only read if the buffer is empty.
RTC_DCHECK(socket != NULL);
RTC_DCHECK(socket != nullptr);
size_t size;
int read;
if (buffer->GetBuffered(&size) && size == 0) {
@ -137,7 +137,7 @@ void ProxyBinding::Read(AsyncSocket* socket, FifoBuffer* buffer) {
}
void ProxyBinding::Write(AsyncSocket* socket, FifoBuffer* buffer) {
RTC_DCHECK(socket != NULL);
RTC_DCHECK(socket != nullptr);
size_t size;
int written;
const void* p = buffer->GetReadData(&size);

4
webrtc/base/scoped_autorelease_pool.h
View File

@ -43,9 +43,9 @@ class ScopedAutoreleasePool {
// as a stack object" discipline.
//
// Note: new is declared as "throw()" to get around a gcc warning about new
// returning NULL, but this method will never get called and therefore will
// returning null, but this method will never get called and therefore will
// never actually throw any exception.
void* operator new(size_t size) throw() { return NULL; }
void* operator new(size_t size) throw() { return nullptr; }
void operator delete (void* ptr) {}
NSAutoreleasePool* pool_;

13
webrtc/base/scoped_ref_ptr.h
View File

@ -30,7 +30,7 @@
// void some_other_function() {
// scoped_refptr<MyFoo> foo = new MyFoo();
// ...
// foo = NULL; // explicitly releases |foo|
// foo = nullptr; // explicitly releases |foo|
// ...
// if (foo)
// foo->Method(param);
@ -45,7 +45,7 @@
// scoped_refptr<MyFoo> b;
//
// b.swap(a);
// // now, |b| references the MyFoo object, and |a| references NULL.
// // now, |b| references the MyFoo object, and |a| references null.
// }
//
// To make both |a| and |b| in the above example reference the same MyFoo
@ -70,8 +70,7 @@ namespace rtc {
template <class T>
class scoped_refptr {
public:
scoped_refptr() : ptr_(NULL) {
}
scoped_refptr() : ptr_(nullptr) {}
scoped_refptr(T* p) : ptr_(p) {
if (ptr_)
@ -106,12 +105,12 @@ class scoped_refptr {
// Release a pointer.
// The return value is the current pointer held by this object.
// If this object holds a NULL pointer, the return value is NULL.
// After this operation, this object will hold a NULL pointer,
// If this object holds a null pointer, the return value is null.
// After this operation, this object will hold a null pointer,
// and will not own the object any more.
T* release() {
T* retVal = ptr_;
ptr_ = NULL;
ptr_ = nullptr;
return retVal;
}

8
webrtc/base/sharedexclusivelock_unittest.cc
View File

@ -61,7 +61,7 @@ class ReadTask : public SharedExclusiveTask {
private:
virtual void OnMessage(Message* message) {
RTC_CHECK(rtc::Thread::Current() == worker_thread_.get());
RTC_CHECK(message != NULL);
RTC_CHECK(message != nullptr);
RTC_CHECK(message->message_id == kMsgRead);
TypedMessageData<int*>* message_data =
@ -73,7 +73,7 @@ class ReadTask : public SharedExclusiveTask {
done_->Set();
}
delete message->pdata;
message->pdata = NULL;
message->pdata = nullptr;
}
};
@ -91,7 +91,7 @@ class WriteTask : public SharedExclusiveTask {
private:
virtual void OnMessage(Message* message) {
RTC_CHECK(rtc::Thread::Current() == worker_thread_.get());
RTC_CHECK(message != NULL);
RTC_CHECK(message != nullptr);
RTC_CHECK(message->message_id == kMsgWrite);
TypedMessageData<int>* message_data =
@ -103,7 +103,7 @@ class WriteTask : public SharedExclusiveTask {
done_->Set();
}
delete message->pdata;
message->pdata = NULL;
message->pdata = nullptr;
}
};

4
webrtc/base/signalthread.cc
View File

@ -113,7 +113,7 @@ void SignalThread::OnMessage(Message *msg) {
// SignalThread this makes an assert in thread.cc fire.
//
// Calling Stop() on the worker ensures that the OS thread that underlies
// the worker will finish, and will be set to NULL, enabling us to call
// the worker will finish, and will be set to null, enabling us to call
// Start() again.
worker_.Stop();
SignalWorkDone(this);
@ -144,7 +144,7 @@ void SignalThread::Run() {
void SignalThread::OnMainThreadDestroyed() {
EnterExit ee(this);
main_ = NULL;
main_ = nullptr;
}
bool SignalThread::Worker::IsProcessingMessages() {

2
webrtc/base/signalthread_unittest.cc
View File

@ -36,7 +36,7 @@ class SignalThreadTest : public testing::Test, public sigslot::has_slots<> {
protected:
virtual void OnWorkStart() {
ASSERT_TRUE(harness_ != NULL);
ASSERT_TRUE(harness_ != nullptr);
++harness_->thread_started_;
EXPECT_EQ(harness_->main_thread_, Thread::Current());
EXPECT_FALSE(worker()->RunningForTest()); // not started yet

10
webrtc/base/sigslot.h
View File

@ -216,13 +216,9 @@ namespace sigslot {
class multi_threaded_local
{
public:
multi_threaded_local()
{
pthread_mutex_init(&m_mutex, NULL);
}
multi_threaded_local(const multi_threaded_local&)
{
pthread_mutex_init(&m_mutex, NULL);
multi_threaded_local() { pthread_mutex_init(&m_mutex, nullptr); }
multi_threaded_local(const multi_threaded_local&) {
pthread_mutex_init(&m_mutex, nullptr);
}
~multi_threaded_local()
{

5
webrtc/base/sigslot_unittest.cc
View File

@ -32,8 +32,7 @@ template<class slot_policy = sigslot::single_threaded,
class signal_policy = sigslot::single_threaded>
class SigslotReceiver : public sigslot::has_slots<slot_policy> {
public:
SigslotReceiver() : signal_(NULL), signal_count_(0) {
}
SigslotReceiver() : signal_(nullptr), signal_count_(0) {}
~SigslotReceiver() {
}
@ -47,7 +46,7 @@ class SigslotReceiver : public sigslot::has_slots<slot_policy> {
void Disconnect() {
if (!signal_) return;
signal_->disconnect(this);
signal_ = NULL;
signal_ = nullptr;
}
void OnSignal() {
++signal_count_;

8
webrtc/base/sigslottester_unittest.cc
View File

@ -68,9 +68,9 @@ TEST(SigslotTester, TestSignalWithPointerToConstArgs) {
SigslotTester1<const std::string*, const std::string*> slot1(&source1,
&capture1);
EXPECT_EQ(0, slot1.callback_count());
source1.emit(NULL);
source1.emit(nullptr);
EXPECT_EQ(1, slot1.callback_count());
EXPECT_EQ(NULL, capture1);
EXPECT_EQ(nullptr, capture1);
}
TEST(SigslotTester, TestSignalWithConstPointerArgs) {
@ -78,9 +78,9 @@ TEST(SigslotTester, TestSignalWithConstPointerArgs) {
std::string* capture1;
SigslotTester1<std::string* const, std::string*> slot1(&source1, &capture1);
EXPECT_EQ(0, slot1.callback_count());
source1.emit(NULL);
source1.emit(nullptr);
EXPECT_EQ(1, slot1.callback_count());
EXPECT_EQ(NULL, capture1);
EXPECT_EQ(nullptr, capture1);
}
} // namespace rtc

6
webrtc/base/socket_unittest.cc
View File

@ -224,7 +224,7 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
// Ensure no pending server connections, since we haven't done anything yet.
EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
EXPECT_TRUE(NULL == server->Accept(&accept_addr));
EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_TRUE(accept_addr.IsNil());
// Attempt connect to listening socket.
@ -335,7 +335,7 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
// Should be no pending server connections.
EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
EXPECT_TRUE(NULL == server->Accept(&accept_addr));
EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_EQ(IPAddress(), accept_addr.ipaddr());
}
@ -376,7 +376,7 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
EXPECT_TRUE(client->GetRemoteAddress().IsNil());
// Should be no pending server connections.
EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
EXPECT_TRUE(NULL == server->Accept(&accept_addr));
EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_TRUE(accept_addr.IsNil());
}

2
webrtc/base/socketadapters.cc
View File

@ -281,7 +281,7 @@ int AsyncHttpsProxySocket::Close() {
state_ = PS_ERROR;
dest_.Clear();
delete context_;
context_ = NULL;
context_ = nullptr;
return BufferedReadAdapter::Close();
}

4
webrtc/base/socketaddress.cc
View File

@ -184,7 +184,7 @@ bool SocketAddress::FromString(const std::string& str) {
if (closebracket != std::string::npos) {
std::string::size_type colon = str.find(':', closebracket);
if (colon != std::string::npos && colon > closebracket) {
SetPort(strtoul(str.substr(colon + 1).c_str(), NULL, 10));
SetPort(strtoul(str.substr(colon + 1).c_str(), nullptr, 10));
SetIP(str.substr(1, closebracket - 1));
} else {
return false;
@ -194,7 +194,7 @@ bool SocketAddress::FromString(const std::string& str) {
std::string::size_type pos = str.find(':');
if (std::string::npos == pos)
return false;
SetPort(strtoul(str.substr(pos + 1).c_str(), NULL, 10));
SetPort(strtoul(str.substr(pos + 1).c_str(), nullptr, 10));
SetIP(str.substr(0, pos));
}
return true;

2
webrtc/base/socketaddress_unittest.cc
View File

@ -237,7 +237,7 @@ TEST(SocketAddressTest, TestToFromSockAddrStorage) {
EXPECT_FALSE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
EXPECT_EQ(from, addr);
EXPECT_FALSE(SocketAddressFromSockAddrStorage(addr_storage, NULL));
EXPECT_FALSE(SocketAddressFromSockAddrStorage(addr_storage, nullptr));
}
bool AreEqual(const SocketAddress& addr1,

12
webrtc/base/socketstream.cc
View File

@ -14,7 +14,7 @@
namespace rtc {
SocketStream::SocketStream(AsyncSocket* socket) : socket_(NULL) {
SocketStream::SocketStream(AsyncSocket* socket) : socket_(nullptr) {
Attach(socket);
}
@ -41,13 +41,13 @@ AsyncSocket* SocketStream::Detach() {
socket_->SignalReadEvent.disconnect(this);
socket_->SignalWriteEvent.disconnect(this);
socket_->SignalCloseEvent.disconnect(this);
socket_ = NULL;
socket_ = nullptr;
}
return socket;
}
StreamState SocketStream::GetState() const {
RTC_DCHECK(socket_ != NULL);
RTC_DCHECK(socket_ != nullptr);
switch (socket_->GetState()) {
case Socket::CS_CONNECTED:
return SS_OPEN;
@ -61,7 +61,7 @@ StreamState SocketStream::GetState() const {
StreamResult SocketStream::Read(void* buffer, size_t buffer_len,
size_t* read, int* error) {
RTC_DCHECK(socket_ != NULL);
RTC_DCHECK(socket_ != nullptr);
int result = socket_->Recv(buffer, buffer_len, nullptr);
if (result < 0) {
if (socket_->IsBlocking())
@ -80,7 +80,7 @@ StreamResult SocketStream::Read(void* buffer, size_t buffer_len,
StreamResult SocketStream::Write(const void* data, size_t data_len,
size_t* written, int* error) {
RTC_DCHECK(socket_ != NULL);
RTC_DCHECK(socket_ != nullptr);
int result = socket_->Send(data, data_len);
if (result < 0) {
if (socket_->IsBlocking())
@ -95,7 +95,7 @@ StreamResult SocketStream::Write(const void* data, size_t data_len,
}
void SocketStream::Close() {
RTC_DCHECK(socket_ != NULL);
RTC_DCHECK(socket_ != nullptr);
socket_->Close();
}

4
webrtc/base/ssladapter.h
View File

@ -34,7 +34,7 @@ class SSLAdapter : public AsyncSocketAdapter {
// negotiation will begin as soon as the socket connects.
virtual int StartSSL(const char* hostname, bool restartable) = 0;
// Create the default SSL adapter for this platform. On failure, returns NULL
// Create the default SSL adapter for this platform. On failure, returns null
// and deletes |socket|. Otherwise, the returned SSLAdapter takes ownership
// of |socket|.
static SSLAdapter* Create(AsyncSocket* socket);
@ -50,7 +50,7 @@ typedef bool (*VerificationCallback)(void* cert);
// Call this on the main thread, before using SSL.
// Call CleanupSSLThread when finished with SSL.
bool InitializeSSL(VerificationCallback callback = NULL);
bool InitializeSSL(VerificationCallback callback = nullptr);
// Call to initialize additional threads.
bool InitializeSSLThread();

12
webrtc/base/ssladapter_unittest.cc
View File

@ -165,8 +165,8 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> {
}
int Send(const std::string& message) {
if (ssl_stream_adapter_ == NULL
|| ssl_stream_adapter_->GetState() != rtc::SS_OPEN) {
if (ssl_stream_adapter_ == nullptr ||
ssl_stream_adapter_->GetState() != rtc::SS_OPEN) {
// No connection yet.
return -1;
}
@ -187,7 +187,7 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> {
void AcceptConnection(const rtc::SocketAddress& address) {
// Only a single connection is supported.
ASSERT_TRUE(ssl_stream_adapter_ == NULL);
ASSERT_TRUE(ssl_stream_adapter_ == nullptr);
// This is only for DTLS.
ASSERT_EQ(rtc::SSL_MODE_DTLS, ssl_mode_);
@ -202,9 +202,9 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> {
void OnServerSocketReadEvent(rtc::AsyncSocket* socket) {
// Only a single connection is supported.
ASSERT_TRUE(ssl_stream_adapter_ == NULL);
ASSERT_TRUE(ssl_stream_adapter_ == nullptr);
DoHandshake(server_socket_->Accept(NULL));
DoHandshake(server_socket_->Accept(nullptr));
}
void OnSSLStreamAdapterEvent(rtc::StreamInterface* stream, int sig, int err) {
@ -274,7 +274,7 @@ class SSLAdapterTestBase : public testing::Test,
explicit SSLAdapterTestBase(const rtc::SSLMode& ssl_mode,
const rtc::KeyParams& key_params)
: ssl_mode_(ssl_mode),
ss_scope_(new rtc::VirtualSocketServer(NULL)),
ss_scope_(new rtc::VirtualSocketServer(nullptr)),
server_(new SSLAdapterTestDummyServer(ssl_mode_, key_params)),
client_(new SSLAdapterTestDummyClient(ssl_mode_)),
handshake_wait_(kTimeout) {}

10
webrtc/base/sslfingerprint.cc
View File

@ -23,7 +23,7 @@ namespace rtc {
SSLFingerprint* SSLFingerprint::Create(
const std::string& algorithm, const rtc::SSLIdentity* identity) {
if (!identity) {
return NULL;
return nullptr;
}
return Create(algorithm, &(identity->certificate()));
@ -36,7 +36,7 @@ SSLFingerprint* SSLFingerprint::Create(
bool ret = cert->ComputeDigest(
algorithm, digest_val, sizeof(digest_val), &digest_len);
if (!ret) {
return NULL;
return nullptr;
}
return new SSLFingerprint(algorithm, digest_val, digest_len);
@ -45,10 +45,10 @@ SSLFingerprint* SSLFingerprint::Create(
SSLFingerprint* SSLFingerprint::CreateFromRfc4572(
const std::string& algorithm, const std::string& fingerprint) {
if (algorithm.empty() || !rtc::IsFips180DigestAlgorithm(algorithm))
return NULL;
return nullptr;
if (fingerprint.empty())
return NULL;
return nullptr;
size_t value_len;
char value[rtc::MessageDigest::kMaxSize];
@ -57,7 +57,7 @@ SSLFingerprint* SSLFingerprint::CreateFromRfc4572(
fingerprint.length(),
':');
if (!value_len)
return NULL;
return nullptr;
return new SSLFingerprint(algorithm, reinterpret_cast<uint8_t*>(value),
value_len);

6
webrtc/base/sslidentity.h
View File

@ -51,9 +51,9 @@ struct SSLCertificateStats {
class SSLCertificate {
public:
// Parses and builds a certificate from a PEM encoded string.
// Returns NULL on failure.
// Returns null on failure.
// The length of the string representation of the certificate is
// stored in *pem_length if it is non-NULL, and only if
// stored in *pem_length if it is non-null, and only if
// parsing was successful.
// Caller is responsible for freeing the returned object.
static SSLCertificate* FromPEMString(const std::string& pem_string);
@ -216,7 +216,7 @@ class SSLIdentity {
// parameters are defined in |key_param|. The certificate's lifetime in
// seconds from the current time is defined in |certificate_lifetime|; it
// should be a non-negative number.
// Returns NULL on failure.
// Returns null on failure.
// Caller is responsible for freeing the returned object.
static SSLIdentity* GenerateWithExpiration(const std::string& common_name,
const KeyParams& key_param,

2
webrtc/base/sslstreamadapter.h
View File

@ -211,7 +211,7 @@ class SSLStreamAdapter : public StreamAdapterInterface {
// part of the RFC defining each exporter
// usage (IN)
// context/context_len -- a context to bind to for this connection;
// optional, can be NULL, 0 (IN)
// optional, can be null, 0 (IN)
// use_context -- whether to use the context value
// (needed to distinguish no context from
// zero-length ones).

18
webrtc/base/sslstreamadapter_unittest.cc
View File

@ -225,10 +225,10 @@ class SSLStreamAdapterTestBase : public testing::Test,
client_private_key_pem_(client_private_key_pem),
client_key_type_(client_key_type),
server_key_type_(server_key_type),
client_stream_(NULL),
server_stream_(NULL),
client_identity_(NULL),
server_identity_(NULL),
client_stream_(nullptr),
server_stream_(nullptr),
client_identity_(nullptr),
server_identity_(nullptr),
delay_(0),
mtu_(1460),
loss_(0),
@ -627,7 +627,7 @@ class SSLStreamAdapterTestTLS
send_stream_.ReserveSize(size);
for (int i = 0; i < size; ++i) {
char ch = static_cast<char>(i);
send_stream_.Write(&ch, 1, NULL, NULL);
send_stream_.Write(&ch, 1, nullptr, nullptr);
}
send_stream_.Rewind();
@ -660,7 +660,7 @@ class SSLStreamAdapterTestTLS
for (;;) {
send_stream_.GetPosition(&position);
if (send_stream_.Read(block, sizeof(block), &tosend, NULL) !=
if (send_stream_.Read(block, sizeof(block), &tosend, nullptr) !=
rtc::SR_EOS) {
rv = client_ssl_->Write(block, tosend, &sent, 0);
@ -706,7 +706,7 @@ class SSLStreamAdapterTestTLS
ASSERT_EQ(rtc::SR_SUCCESS, r);
LOG(LS_VERBOSE) << "Read " << bread;
recv_stream_.Write(buffer, bread, NULL, NULL);
recv_stream_.Write(buffer, bread, nullptr, nullptr);
}
}
@ -896,11 +896,11 @@ TEST_P(SSLStreamAdapterTestTLS, ReadWriteAfterClose) {
size_t dummy;
// It's an error to write after closed.
rv = client_ssl_->Write(block, sizeof(block), &dummy, NULL);
rv = client_ssl_->Write(block, sizeof(block), &dummy, nullptr);
ASSERT_EQ(rtc::SR_ERROR, rv);
// But after closed read gives you EOS.
rv = client_ssl_->Read(block, sizeof(block), &dummy, NULL);
rv = client_ssl_->Read(block, sizeof(block), &dummy, nullptr);
ASSERT_EQ(rtc::SR_EOS, rv);
};

81
webrtc/base/stream.cc
View File

@ -78,7 +78,7 @@ StreamResult StreamInterface::ReadLine(std::string* line) {
StreamResult result = SR_SUCCESS;
while (true) {
char ch;
result = Read(&ch, sizeof(ch), NULL, NULL);
result = Read(&ch, sizeof(ch), nullptr, nullptr);
if (result != SR_SUCCESS) {
break;
}
@ -103,11 +103,11 @@ void StreamInterface::PostEvent(int events, int err) {
}
const void* StreamInterface::GetReadData(size_t* data_len) {
return NULL;
return nullptr;
}
void* StreamInterface::GetWriteBuffer(size_t* buf_len) {
return NULL;
return nullptr;
}
bool StreamInterface::SetPosition(size_t position) {
@ -156,7 +156,7 @@ void StreamInterface::OnMessage(Message* msg) {
StreamAdapterInterface::StreamAdapterInterface(StreamInterface* stream,
bool owned)
: stream_(stream), owned_(owned) {
if (NULL != stream_)
if (nullptr != stream_)
stream_->SignalEvent.connect(this, &StreamAdapterInterface::OnEvent);
}
@ -208,21 +208,21 @@ bool StreamAdapterInterface::Flush() {
}
void StreamAdapterInterface::Attach(StreamInterface* stream, bool owned) {
if (NULL != stream_)
if (nullptr != stream_)
stream_->SignalEvent.disconnect(this);
if (owned_)
delete stream_;
stream_ = stream;
owned_ = owned;
if (NULL != stream_)
if (nullptr != stream_)
stream_->SignalEvent.connect(this, &StreamAdapterInterface::OnEvent);
}
StreamInterface* StreamAdapterInterface::Detach() {
if (NULL != stream_)
if (nullptr != stream_)
stream_->SignalEvent.disconnect(this);
StreamInterface* stream = stream_;
stream_ = NULL;
stream_ = nullptr;
return stream;
}
@ -273,7 +273,7 @@ StreamResult StreamTap::Read(void* buffer, size_t buffer_len,
StreamResult res = StreamAdapterInterface::Read(buffer, buffer_len,
read, error);
if ((res == SR_SUCCESS) && (tap_result_ == SR_SUCCESS)) {
tap_result_ = tap_->WriteAll(buffer, *read, NULL, &tap_error_);
tap_result_ = tap_->WriteAll(buffer, *read, nullptr, &tap_error_);
}
return res;
}
@ -287,7 +287,7 @@ StreamResult StreamTap::Write(const void* data, size_t data_len,
StreamResult res = StreamAdapterInterface::Write(data, data_len,
written, error);
if ((res == SR_SUCCESS) && (tap_result_ == SR_SUCCESS)) {
tap_result_ = tap_->WriteAll(data, *written, NULL, &tap_error_);
tap_result_ = tap_->WriteAll(data, *written, nullptr, &tap_error_);
}
return res;
}
@ -325,8 +325,7 @@ void NullStream::Close() {
// FileStream
///////////////////////////////////////////////////////////////////////////////
FileStream::FileStream() : file_(NULL) {
}
FileStream::FileStream() : file_(nullptr) {}
FileStream::~FileStream() {
FileStream::Close();
@ -351,7 +350,7 @@ bool FileStream::Open(const std::string& filename, const char* mode,
if (!file_ && error) {
*error = errno;
}
return (file_ != NULL);
return (file_ != nullptr);
}
bool FileStream::OpenShare(const std::string& filename, const char* mode,
@ -365,7 +364,7 @@ bool FileStream::OpenShare(const std::string& filename, const char* mode,
*error = errno;
return false;
}
return file_ != NULL;
return file_ != nullptr;
} else {
if (error) {
*error = -1;
@ -380,11 +379,11 @@ bool FileStream::OpenShare(const std::string& filename, const char* mode,
bool FileStream::DisableBuffering() {
if (!file_)
return false;
return (setvbuf(file_, NULL, _IONBF, 0) == 0);
return (setvbuf(file_, nullptr, _IONBF, 0) == 0);
}
StreamState FileStream::GetState() const {
return (file_ == NULL) ? SS_CLOSED : SS_OPEN;
return (file_ == nullptr) ? SS_CLOSED : SS_OPEN;
}
StreamResult FileStream::Read(void* buffer, size_t buffer_len,
@ -422,7 +421,7 @@ StreamResult FileStream::Write(const void* data, size_t data_len,
void FileStream::Close() {
if (file_) {
DoClose();
file_ = NULL;
file_ = nullptr;
}
}
@ -433,7 +432,7 @@ bool FileStream::SetPosition(size_t position) {
}
bool FileStream::GetPosition(size_t* position) const {
RTC_DCHECK(NULL != position);
RTC_DCHECK(nullptr != position);
if (!file_)
return false;
long result = ftell(file_);
@ -445,7 +444,7 @@ bool FileStream::GetPosition(size_t* position) const {
}
bool FileStream::GetSize(size_t* size) const {
RTC_DCHECK(NULL != size);
RTC_DCHECK(nullptr != size);
if (!file_)
return false;
struct stat file_stats;
@ -457,7 +456,7 @@ bool FileStream::GetSize(size_t* size) const {
}
bool FileStream::GetAvailable(size_t* size) const {
RTC_DCHECK(NULL != size);
RTC_DCHECK(nullptr != size);
if (!GetSize(size))
return false;
long result = ftell(file_);
@ -493,7 +492,7 @@ bool FileStream::Flush() {
#if defined(WEBRTC_POSIX) && !defined(__native_client__)
bool FileStream::TryLock() {
if (file_ == NULL) {
if (file_ == nullptr) {
// Stream not open.
RTC_NOTREACHED();
return false;
@ -503,7 +502,7 @@ bool FileStream::TryLock() {
}
bool FileStream::Unlock() {
if (file_ == NULL) {
if (file_ == nullptr) {
// Stream not open.
RTC_NOTREACHED();
return false;
@ -523,9 +522,7 @@ void FileStream::DoClose() {
///////////////////////////////////////////////////////////////////////////////
MemoryStreamBase::MemoryStreamBase()
: buffer_(NULL), buffer_length_(0), data_length_(0),
seek_position_(0) {
}
: buffer_(nullptr), buffer_length_(0), data_length_(0), seek_position_(0) {}
StreamState MemoryStreamBase::GetState() const {
return SS_OPEN;
@ -610,7 +607,7 @@ bool MemoryStreamBase::GetAvailable(size_t* size) const {
}
bool MemoryStreamBase::ReserveSize(size_t size) {
return (SR_SUCCESS == DoReserve(size, NULL));
return (SR_SUCCESS == DoReserve(size, nullptr));
}
StreamResult MemoryStreamBase::DoReserve(size_t size, int* error) {
@ -619,17 +616,14 @@ StreamResult MemoryStreamBase::DoReserve(size_t size, int* error) {
///////////////////////////////////////////////////////////////////////////////
MemoryStream::MemoryStream()
: buffer_alloc_(NULL) {
}
MemoryStream::MemoryStream() : buffer_alloc_(nullptr) {}
MemoryStream::MemoryStream(const char* data)
: buffer_alloc_(NULL) {
MemoryStream::MemoryStream(const char* data) : buffer_alloc_(nullptr) {
SetData(data, strlen(data));
}
MemoryStream::MemoryStream(const void* data, size_t length)
: buffer_alloc_(NULL) {
: buffer_alloc_(nullptr) {
SetData(data, length);
}
@ -819,7 +813,7 @@ void FifoBuffer::ConsumeReadData(size_t size) {
void* FifoBuffer::GetWriteBuffer(size_t* size) {
CritScope cs(&crit_);
if (state_ == SS_CLOSED) {
return NULL;
return nullptr;
}
// if empty, reset the write position to the beginning, so we can get
@ -943,8 +937,8 @@ StreamResult LoggingAdapter::Write(const void* data, size_t data_len,
}
void LoggingAdapter::Close() {
LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_);
LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_);
LogMultiline(level_, label_.c_str(), false, nullptr, 0, hex_mode_, &lms_);
LogMultiline(level_, label_.c_str(), true, nullptr, 0, hex_mode_, &lms_);
LOG_V(level_) << label_ << " Closed locally";
StreamAdapterInterface::Close();
}
@ -953,8 +947,8 @@ void LoggingAdapter::OnEvent(StreamInterface* stream, int events, int err) {
if (events & SE_OPEN) {
LOG_V(level_) << label_ << " Open";
} else if (events & SE_CLOSE) {
LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_);
LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_);
LogMultiline(level_, label_.c_str(), false, nullptr, 0, hex_mode_, &lms_);
LogMultiline(level_, label_.c_str(), true, nullptr, 0, hex_mode_, &lms_);
LOG_V(level_) << label_ << " Closed with error: " << err;
}
StreamAdapterInterface::OnEvent(stream, events, err);
@ -1066,9 +1060,10 @@ StreamReference::StreamReference(StreamRefCount* stream_ref_count,
///////////////////////////////////////////////////////////////////////////////
StreamResult Flow(StreamInterface* source,
char* buffer, size_t buffer_len,
char* buffer,
size_t buffer_len,
StreamInterface* sink,
size_t* data_len /* = NULL */) {
size_t* data_len /* = nullptr */) {
RTC_DCHECK(buffer_len > 0);
StreamResult result;
@ -1083,8 +1078,8 @@ StreamResult Flow(StreamInterface* source,
do {
// Read until buffer is full, end of stream, or error
while (!end_of_stream && (read_pos < buffer_len)) {
result = source->Read(buffer + read_pos, buffer_len - read_pos,
&count, NULL);
result = source->Read(buffer + read_pos, buffer_len - read_pos, &count,
nullptr);
if (result == SR_EOS) {
end_of_stream = true;
} else if (result != SR_SUCCESS) {
@ -1100,8 +1095,8 @@ StreamResult Flow(StreamInterface* source,
// Write until buffer is empty, or error (including end of stream)
write_pos = 0;
while (write_pos < read_pos) {
result = sink->Write(buffer + write_pos, read_pos - write_pos,
&count, NULL);
result = sink->Write(buffer + write_pos, read_pos - write_pos, &count,
nullptr);
if (result != SR_SUCCESS) {
if (data_len) {
*data_len = read_pos - write_pos;

12
webrtc/base/stream.h
View File

@ -125,7 +125,7 @@ class StreamInterface : public MessageHandler {
// The following four methods are used to avoid copying data multiple times.
// GetReadData returns a pointer to a buffer which is owned by the stream.
// The buffer contains data_len bytes. NULL is returned if no data is
// The buffer contains data_len bytes. null is returned if no data is
// available, or if the method fails. If the caller processes the data, it
// must call ConsumeReadData with the number of processed bytes. GetReadData
// does not require a matching call to ConsumeReadData if the data is not
@ -135,14 +135,14 @@ class StreamInterface : public MessageHandler {
virtual void ConsumeReadData(size_t used) {}
// GetWriteBuffer returns a pointer to a buffer which is owned by the stream.
// The buffer has a capacity of buf_len bytes. NULL is returned if there is
// The buffer has a capacity of buf_len bytes. null is returned if there is
// no buffer available, or if the method fails. The call may write data to
// the buffer, and then call ConsumeWriteBuffer with the number of bytes
// written. GetWriteBuffer does not require a matching call to
// ConsumeWriteData if no data is written. Write, ForceWrite, and
// ConsumeWriteData invalidate the buffer returned by GetWriteBuffer.
// TODO: Allow the caller to specify a minimum buffer size. If the specified
// amount of buffer is not yet available, return NULL and Signal SE_WRITE
// amount of buffer is not yet available, return null and Signal SE_WRITE
// when it is available. If the requested amount is too large, return an
// error.
virtual void* GetWriteBuffer(size_t* buf_len);
@ -703,8 +703,10 @@ class StreamReference : public StreamAdapterInterface {
// this is the data that read from source but can't move to destination.
// as a pass in parameter, it indicates data in buffer that should move to sink
StreamResult Flow(StreamInterface* source,
char* buffer, size_t buffer_len,
StreamInterface* sink, size_t* data_len = NULL);
char* buffer,
size_t buffer_len,
StreamInterface* sink,
size_t* data_len = nullptr);
///////////////////////////////////////////////////////////////////////////////

124
webrtc/base/stream_unittest.cc
View File

@ -79,7 +79,7 @@ void SeekTest(StreamInterface* stream, const unsigned char value) {
unsigned char buffer[13] = { 0 };
const size_t kBufSize = sizeof(buffer);
EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, nullptr), SR_SUCCESS);
EXPECT_EQ(bytes, kBufSize);
EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value));
EXPECT_TRUE(stream->GetPosition(&bytes));
@ -87,7 +87,7 @@ void SeekTest(StreamInterface* stream, const unsigned char value) {
EXPECT_TRUE(stream->SetPosition(7));
EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, nullptr), SR_SUCCESS);
EXPECT_EQ(bytes, kBufSize);
EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value + 7));
EXPECT_TRUE(stream->GetPosition(&bytes));
@ -106,52 +106,52 @@ TEST(FifoBufferTest, TestAll) {
// Test assumptions about base state
EXPECT_EQ(SS_OPEN, stream->GetState());
EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
EXPECT_TRUE(NULL != stream->GetReadData(&bytes));
EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
EXPECT_TRUE(nullptr != stream->GetReadData(&bytes));
EXPECT_EQ((size_t)0, bytes);
stream->ConsumeReadData(0);
EXPECT_TRUE(NULL != stream->GetWriteBuffer(&bytes));
EXPECT_TRUE(nullptr != stream->GetWriteBuffer(&bytes));
EXPECT_EQ(kSize, bytes);
stream->ConsumeWriteBuffer(0);
// Try a full write
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
EXPECT_EQ(kSize, bytes);
// Try a write that should block
EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL));
EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, nullptr));
// Try a full read
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize));
// Try a read that should block
EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
// Try a too-big write
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 2, &bytes, nullptr));
EXPECT_EQ(bytes, kSize);
// Try a too-big read
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, nullptr));
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize));
// Try some small writes and reads
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
@ -163,22 +163,22 @@ TEST(FifoBufferTest, TestAll) {
// XXXXWWWWWWWWXXXX 4567012345670123
// RRRRXXXXXXXXRRRR ....01234567....
// ....RRRRRRRR.... ................
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, nullptr));
EXPECT_EQ(kSize * 3 / 4, bytes);
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 4, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 4, &bytes, nullptr));
EXPECT_EQ(kSize / 4 , bytes);
EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(kSize / 2 , bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(kSize / 2 , bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
@ -187,27 +187,27 @@ TEST(FifoBufferTest, TestAll) {
stream->ConsumeWriteBuffer(0);
// Try using GetReadData to do a full read
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
q = stream->GetReadData(&bytes);
EXPECT_TRUE(NULL != q);
EXPECT_TRUE(nullptr != q);
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(q, in, kSize));
stream->ConsumeReadData(kSize);
EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
// Try using GetReadData to do some small reads
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
q = stream->GetReadData(&bytes);
EXPECT_TRUE(NULL != q);
EXPECT_TRUE(nullptr != q);
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(q, in, kSize / 2));
stream->ConsumeReadData(kSize / 2);
q = stream->GetReadData(&bytes);
EXPECT_TRUE(NULL != q);
EXPECT_TRUE(nullptr != q);
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(q, in + kSize / 2, kSize / 2));
stream->ConsumeReadData(kSize / 2);
EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
// Try using GetReadData in a wraparound case
// WWWWWWWWWWWWWWWW 0123456789ABCDEF
@ -215,16 +215,16 @@ TEST(FifoBufferTest, TestAll) {
// WWWWWWWW....XXXX 01234567....CDEF
// ............RRRR 01234567........
// RRRRRRRR........ ................
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
q = stream->GetReadData(&bytes);
EXPECT_TRUE(NULL != q);
EXPECT_TRUE(nullptr != q);
EXPECT_EQ(kSize / 4, bytes);
EXPECT_EQ(0, memcmp(q, in + kSize * 3 / 4, kSize / 4));
stream->ConsumeReadData(kSize / 4);
q = stream->GetReadData(&bytes);
EXPECT_TRUE(NULL != q);
EXPECT_TRUE(nullptr != q);
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(q, in, kSize / 2));
stream->ConsumeReadData(kSize / 2);
@ -235,26 +235,26 @@ TEST(FifoBufferTest, TestAll) {
// Try using GetWriteBuffer to do a full write
p = stream->GetWriteBuffer(&bytes);
EXPECT_TRUE(NULL != p);
EXPECT_TRUE(nullptr != p);
EXPECT_EQ(kSize, bytes);
memcpy(p, in, kSize);
stream->ConsumeWriteBuffer(kSize);
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize));
// Try using GetWriteBuffer to do some small writes
p = stream->GetWriteBuffer(&bytes);
EXPECT_TRUE(NULL != p);
EXPECT_TRUE(nullptr != p);
EXPECT_EQ(kSize, bytes);
memcpy(p, in, kSize / 2);
stream->ConsumeWriteBuffer(kSize / 2);
p = stream->GetWriteBuffer(&bytes);
EXPECT_TRUE(NULL != p);
EXPECT_TRUE(nullptr != p);
EXPECT_EQ(kSize / 2, bytes);
memcpy(p, in + kSize / 2, kSize / 2);
stream->ConsumeWriteBuffer(kSize / 2);
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize));
@ -264,53 +264,53 @@ TEST(FifoBufferTest, TestAll) {
// ........XXXXWWWW ........89AB0123
// WWWW....XXXXXXXX 4567....89AB0123
// RRRR....RRRRRRRR ................
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
p = stream->GetWriteBuffer(&bytes);
EXPECT_TRUE(NULL != p);
EXPECT_TRUE(nullptr != p);
EXPECT_EQ(kSize / 4, bytes);
memcpy(p, in, kSize / 4);
stream->ConsumeWriteBuffer(kSize / 4);
p = stream->GetWriteBuffer(&bytes);
EXPECT_TRUE(NULL != p);
EXPECT_TRUE(nullptr != p);
EXPECT_EQ(kSize / 2, bytes);
memcpy(p, in + kSize / 4, kSize / 4);
stream->ConsumeWriteBuffer(kSize / 4);
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, nullptr));
EXPECT_EQ(kSize * 3 / 4, bytes);
EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
EXPECT_EQ(0, memcmp(in, out + kSize / 4, kSize / 4));
// Check that the stream is now empty
EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
// Try growing the buffer
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
EXPECT_EQ(kSize, bytes);
EXPECT_TRUE(buf.SetCapacity(kSize * 2));
EXPECT_EQ(SR_SUCCESS, stream->Write(in + kSize, kSize, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in + kSize, kSize, &bytes, nullptr));
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, nullptr));
EXPECT_EQ(kSize * 2, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize * 2));
// Try shrinking the buffer
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
EXPECT_EQ(kSize, bytes);
EXPECT_TRUE(buf.SetCapacity(kSize));
EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize));
// Write to the stream, close it, read the remaining bytes
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
stream->Close();
EXPECT_EQ(SS_CLOSED, stream->GetState());
EXPECT_EQ(SR_EOS, stream->Write(in, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_EOS, stream->Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
EXPECT_EQ(SR_EOS, stream->Read(out, kSize / 2, &bytes, NULL));
EXPECT_EQ(SR_EOS, stream->Read(out, kSize / 2, &bytes, nullptr));
}
TEST(FifoBufferTest, FullBufferCheck) {
@ -318,7 +318,7 @@ TEST(FifoBufferTest, FullBufferCheck) {
buff.ConsumeWriteBuffer(10);
size_t free;
EXPECT_TRUE(buff.GetWriteBuffer(&free) != NULL);
EXPECT_TRUE(buff.GetWriteBuffer(&free) != nullptr);
EXPECT_EQ(0U, free);
}
@ -329,7 +329,7 @@ TEST(FifoBufferTest, WriteOffsetAndReadOffset) {
FifoBuffer buf(kSize);
// Write 14 bytes.
EXPECT_EQ(SR_SUCCESS, buf.Write(in, 14, NULL, NULL));
EXPECT_EQ(SR_SUCCESS, buf.Write(in, 14, nullptr, nullptr));
// Make sure data is in |buf|.
size_t buffered;
@ -345,10 +345,10 @@ TEST(FifoBufferTest, WriteOffsetAndReadOffset) {
EXPECT_EQ(12u, remaining);
// Write at offset 12, this should fail.
EXPECT_EQ(SR_BLOCK, buf.WriteOffset(in, 10, 12, NULL));
EXPECT_EQ(SR_BLOCK, buf.WriteOffset(in, 10, 12, nullptr));
// Write 8 bytes at offset 4, this wraps around the buffer.
EXPECT_EQ(SR_SUCCESS, buf.WriteOffset(in, 8, 4, NULL));
EXPECT_EQ(SR_SUCCESS, buf.WriteOffset(in, 8, 4, nullptr));
// Number of available space remains the same until we call
// ConsumeWriteBuffer().
@ -368,7 +368,7 @@ TEST(FifoBufferTest, WriteOffsetAndReadOffset) {
EXPECT_EQ(16u, buffered);
// Read at offset 16, this should fail since we don't have that much data.
EXPECT_EQ(SR_BLOCK, buf.ReadOffset(out, 10, 16, NULL));
EXPECT_EQ(SR_BLOCK, buf.ReadOffset(out, 10, 16, nullptr));
}
} // namespace rtc

6
webrtc/base/stringencode.cc
View File

@ -141,7 +141,7 @@ const unsigned char ASCII_CLASS[128] = {
size_t url_encode(char * buffer, size_t buflen,
const char * source, size_t srclen) {
if (NULL == buffer)
if (nullptr == buffer)
return srclen * 3 + 1;
if (buflen <= 0)
return 0;
@ -167,7 +167,7 @@ size_t url_encode(char * buffer, size_t buflen,
size_t url_decode(char * buffer, size_t buflen,
const char * source, size_t srclen) {
if (NULL == buffer)
if (nullptr == buffer)
return srclen + 1;
if (buflen <= 0)
return 0;
@ -546,7 +546,7 @@ size_t transform(std::string& value, size_t maxlen, const std::string& source,
std::string s_transform(const std::string& source, Transform t) {
// Ask transformation function to approximate the destination size (returns upper bound)
size_t maxlen = t(NULL, 0, source.data(), source.length());
size_t maxlen = t(nullptr, 0, source.data(), source.length());
char * buffer = STACK_ARRAY(char, maxlen);
size_t len = t(buffer, maxlen, source.data(), source.length());
std::string result(buffer, len);

28
webrtc/base/stringencode_unittest.cc
View File

@ -21,18 +21,18 @@ TEST(Utf8EncodeTest, EncodeDecode) {
size_t encsize, enclen;
unsigned long decoded;
} kTests[] = {
{ "a ", 5, 1, 'a' },
{ "\x7F ", 5, 1, 0x7F },
{ "\xC2\x80 ", 5, 2, 0x80 },
{ "\xDF\xBF ", 5, 2, 0x7FF },
{ "\xE0\xA0\x80 ", 5, 3, 0x800 },
{ "\xEF\xBF\xBF ", 5, 3, 0xFFFF },
{ "\xF0\x90\x80\x80 ", 5, 4, 0x10000 },
{ "\xF0\x90\x80\x80 ", 3, 0, 0x10000 },
{ "\xF0\xF0\x80\x80 ", 5, 0, 0 },
{ "\xF0\x90\x80 ", 5, 0, 0 },
{ "\x90\x80\x80 ", 5, 0, 0 },
{ NULL, 0, 0 },
{"a ", 5, 1, 'a'},
{"\x7F ", 5, 1, 0x7F},
{"\xC2\x80 ", 5, 2, 0x80},
{"\xDF\xBF ", 5, 2, 0x7FF},
{"\xE0\xA0\x80 ", 5, 3, 0x800},
{"\xEF\xBF\xBF ", 5, 3, 0xFFFF},
{"\xF0\x90\x80\x80 ", 5, 4, 0x10000},
{"\xF0\x90\x80\x80 ", 3, 0, 0x10000},
{"\xF0\xF0\x80\x80 ", 5, 0, 0},
{"\xF0\x90\x80 ", 5, 0, 0},
{"\x90\x80\x80 ", 5, 0, 0},
{nullptr, 0, 0},
};
for (size_t i = 0; kTests[i].encoded; ++i) {
unsigned long val = 0;
@ -248,7 +248,7 @@ TEST(TokenizeTest, CompareSubstrings) {
}
TEST(TokenizeTest, TokenizeAppend) {
ASSERT_EQ(0ul, tokenize_append("A B C", ' ', NULL));
ASSERT_EQ(0ul, tokenize_append("A B C", ' ', nullptr));
std::vector<std::string> fields;
@ -263,7 +263,7 @@ TEST(TokenizeTest, TokenizeAppend) {
}
TEST(TokenizeTest, TokenizeWithMarks) {
ASSERT_EQ(0ul, tokenize("D \"A B", ' ', '(', ')', NULL));
ASSERT_EQ(0ul, tokenize("D \"A B", ' ', '(', ')', nullptr));
std::vector<std::string> fields;
tokenize("A B C", ' ', '"', '"', &fields);

4
webrtc/base/stringutils.h
View File

@ -136,8 +136,8 @@ struct Traits {
// String utilities which work with char or wchar_t
///////////////////////////////////////////////////////////////////////////////
template<class CTYPE>
inline const CTYPE* nonnull(const CTYPE* str, const CTYPE* def_str = NULL) {
template <class CTYPE>
inline const CTYPE* nonnull(const CTYPE* str, const CTYPE* def_str = nullptr) {
return str ? str : (def_str ? def_str : Traits<CTYPE>::empty_str());
}

4
webrtc/base/stringutils_unittest.cc
View File

@ -33,13 +33,13 @@ TEST(string_matchTest, Matches) {
// Tests for ascii_string_compare().
// Tests NULL input.
// Tests null input.
TEST(ascii_string_compareTest, NullInput) {
// The following results in an access violation in
// ascii_string_compare. Is this a bug or by design? stringutils.h
// should document the expected behavior in this case.
// EXPECT_EQ(0, ascii_string_compare(NULL, NULL, 1, identity));
// EXPECT_EQ(0, ascii_string_compare(nullptr, nullptr, 1, identity));
}
// Tests comparing two strings of different lengths.

10
webrtc/base/task_unittest.cc
View File

@ -216,7 +216,7 @@ class TaskTest : public sigslot::has_slots<> {
for (i = 0; i < STUCK_TASK_COUNT; ++i) {
if (stuck_[i].xlat_ == id) {
stuck_[i].timed_out_ = true;
stuck_[i].task_ = NULL;
stuck_[i].task_ = nullptr;
break;
}
}
@ -231,7 +231,7 @@ class TaskTest : public sigslot::has_slots<> {
for (i = 0; i < HAPPY_TASK_COUNT; ++i) {
if (happy_[i].xlat_ == id) {
happy_[i].timed_out_ = true;
happy_[i].task_ = NULL;
happy_[i].task_ = nullptr;
break;
}
}
@ -245,7 +245,7 @@ class TaskTest : public sigslot::has_slots<> {
int i;
for (i = 0; i < HAPPY_TASK_COUNT; ++i) {
if (happy_[i].xlat_ == id) {
happy_[i].task_ = NULL;
happy_[i].task_ = nullptr;
break;
}
}
@ -347,7 +347,7 @@ class SetBoolOnDeleteTask : public Task {
SetBoolOnDeleteTask(TaskParent *parent, bool *set_when_deleted)
: Task(parent),
set_when_deleted_(set_when_deleted) {
EXPECT_TRUE(NULL != set_when_deleted);
EXPECT_TRUE(nullptr != set_when_deleted);
EXPECT_FALSE(*set_when_deleted);
}
@ -466,7 +466,7 @@ class TimeoutChangeTest : public sigslot::has_slots<> {
for (size_t i = 0; i < arraysize(stuck_tasks_); ++i) {
if (stuck_tasks_[i] && stuck_tasks_[i]->unique_id() == id) {
task_count_--;
stuck_tasks_[i] = NULL;
stuck_tasks_[i] = nullptr;
break;
}
}

13
webrtc/base/taskparent.cc
View File

@ -20,17 +20,16 @@ namespace rtc {
TaskParent::TaskParent(Task* derived_instance, TaskParent *parent)
: parent_(parent) {
RTC_DCHECK(derived_instance != NULL);
RTC_DCHECK(parent != NULL);
RTC_DCHECK(derived_instance != nullptr);
RTC_DCHECK(parent != nullptr);
runner_ = parent->GetRunner();
parent_->AddChild(derived_instance);
Initialize();
}
TaskParent::TaskParent(TaskRunner *derived_instance)
: parent_(NULL),
runner_(derived_instance) {
RTC_DCHECK(derived_instance != NULL);
TaskParent::TaskParent(TaskRunner* derived_instance)
: parent_(nullptr), runner_(derived_instance) {
RTC_DCHECK(derived_instance != nullptr);
Initialize();
}
@ -48,7 +47,7 @@ void TaskParent::AddChild(Task *child) {
#if RTC_DCHECK_IS_ON
bool TaskParent::IsChildTask(Task *task) {
RTC_DCHECK(task != NULL);
RTC_DCHECK(task != nullptr);
return task->parent_ == this && children_->find(task) != children_->end();
}
#endif

27
webrtc/base/taskrunner.cc
View File

@ -77,7 +77,7 @@ void TaskRunner::InternalRunTasks(bool in_destructor) {
Task* task = tasks_[i];
if (next_timeout_task_ &&
task->unique_id() == next_timeout_task_->unique_id()) {
next_timeout_task_ = NULL;
next_timeout_task_ = nullptr;
need_timeout_recalc = true;
}
@ -86,21 +86,19 @@ void TaskRunner::InternalRunTasks(bool in_destructor) {
#endif
delete task;
#if RTC_DCHECK_IS_ON
deleting_task_ = NULL;
deleting_task_ = nullptr;
#endif
tasks_[i] = NULL;
tasks_[i] = nullptr;
}
}
// Finally, remove nulls
// Finally, remove nulls.
std::vector<Task *>::iterator it;
it = std::remove(tasks_.begin(),
tasks_.end(),
reinterpret_cast<Task *>(NULL));
it = std::remove(tasks_.begin(), tasks_.end(), nullptr);
tasks_.erase(it, tasks_.end());
if (need_timeout_recalc)
RecalcNextTimeout(NULL);
RecalcNextTimeout(nullptr);
// Make sure that adjustments are done to account
// for any timeout changes (but don't call this
@ -118,7 +116,7 @@ void TaskRunner::PollTasks() {
// TODO: We need to guard against WakeTasks not updating
// next_timeout_task_. Maybe also add documentation in the header file once
// we understand this code better.
Task* old_timeout_task = NULL;
Task* old_timeout_task = nullptr;
while (next_timeout_task_ &&
old_timeout_task != next_timeout_task_ &&
next_timeout_task_->TimedOut()) {
@ -144,9 +142,10 @@ int64_t TaskRunner::next_task_timeout() const {
void TaskRunner::UpdateTaskTimeout(Task* task,
int64_t previous_task_timeout_time) {
RTC_DCHECK(task != NULL);
RTC_DCHECK(task != nullptr);
int64_t previous_timeout_time = next_task_timeout();
bool task_is_timeout_task = next_timeout_task_ != NULL &&
bool task_is_timeout_task =
next_timeout_task_ != nullptr &&
task->unique_id() == next_timeout_task_->unique_id();
if (task_is_timeout_task) {
previous_timeout_time = previous_task_timeout_time;
@ -156,7 +155,7 @@ void TaskRunner::UpdateTaskTimeout(Task* task,
// check to see if it's closer than the current
// "about to timeout" task
if (task->timeout_time()) {
if (next_timeout_task_ == NULL ||
if (next_timeout_task_ == nullptr ||
(task->timeout_time() <= next_timeout_task_->timeout_time())) {
next_timeout_task_ = task;
}
@ -184,14 +183,14 @@ void TaskRunner::RecalcNextTimeout(Task *exclude_task) {
// it has the closest timeout time
int64_t next_timeout_time = 0;
next_timeout_task_ = NULL;
next_timeout_task_ = nullptr;
for (size_t i = 0; i < tasks_.size(); ++i) {
Task *task = tasks_[i];
// if the task isn't complete, and it actually has a timeout time
if (!task->IsDone() && (task->timeout_time() > 0))
// if it doesn't match our "exclude" task
if (exclude_task == NULL ||
if (exclude_task == nullptr ||
exclude_task->unique_id() != task->unique_id())
// if its timeout time is sooner than our current timeout time
if (next_timeout_time == 0 ||

4
webrtc/base/testclient.cc
View File

@ -76,7 +76,7 @@ TestClient::Packet* TestClient::NextPacket(int timeout_ms) {
}
// Return the first packet placed in the queue.
Packet* packet = NULL;
Packet* packet = nullptr;
CritScope cs(&crit_);
if (packets_->size() > 0) {
packet = packets_->front();
@ -117,7 +117,7 @@ bool TestClient::CheckTimestamp(int64_t packet_timestamp) {
bool TestClient::CheckNoPacket() {
bool res;
Packet* packet = NextPacket(kNoPacketTimeoutMs);
res = (packet == NULL);
res = (packet == nullptr);
delete packet;
return res;
}

2
webrtc/base/testclient_unittest.cc
View File

@ -39,7 +39,7 @@ void TestTcpInternal(const SocketAddress& loopback) {
->CreateAsyncSocket(loopback.family(), SOCK_STREAM);
AsyncTCPSocket* tcp_socket = AsyncTCPSocket::Create(
socket, loopback, server.address());
ASSERT_TRUE(tcp_socket != NULL);
ASSERT_TRUE(tcp_socket != nullptr);
TestClient client(tcp_socket);
SocketAddress addr = client.address(), from;

2
webrtc/base/testechoserver.h
View File

@ -43,7 +43,7 @@ class TestEchoServer : public sigslot::has_slots<> {
private:
void OnAccept(AsyncSocket* socket) {
AsyncSocket* raw_socket = socket->Accept(NULL);
AsyncSocket* raw_socket = socket->Accept(nullptr);
if (raw_socket) {
AsyncTCPSocket* packet_socket = new AsyncTCPSocket(raw_socket, false);
packet_socket->SignalReadPacket.connect(this, &TestEchoServer::OnPacket);

17
webrtc/base/testutils.h
View File

@ -276,14 +276,12 @@ private:
class SocketTestClient : public sigslot::has_slots<> {
public:
SocketTestClient() {
Init(NULL, AF_INET);
}
SocketTestClient(AsyncSocket* socket) {
Init(socket, socket->GetLocalAddress().family());
SocketTestClient() { Init(nullptr, AF_INET); }
SocketTestClient(AsyncSocket* socket) {
Init(socket, socket->GetLocalAddress().family());
}
SocketTestClient(const SocketAddress& address) {
Init(NULL, address.family());
Init(nullptr, address.family());
socket_->Connect(address);
}
@ -408,8 +406,7 @@ class SocketTestServer : public sigslot::has_slots<> {
private:
void OnReadEvent(AsyncSocket* socket) {
AsyncSocket* accepted =
static_cast<AsyncSocket*>(socket_->Accept(NULL));
AsyncSocket* accepted = static_cast<AsyncSocket*>(socket_->Accept(nullptr));
if (!accepted)
return;
clients_.push_back(new SocketTestClient(accepted));
@ -530,9 +527,9 @@ inline AssertionResult CmpHelperMemEq(const char* expected_expression,
#if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
struct XDisplay {
XDisplay() : display_(XOpenDisplay(NULL)) { }
XDisplay() : display_(XOpenDisplay(nullptr)) {}
~XDisplay() { if (display_) XCloseDisplay(display_); }
bool IsValid() const { return display_ != NULL; }
bool IsValid() const { return display_ != nullptr; }
operator Display*() { return display_; }
private:
Display* display_;

34
webrtc/base/thread.cc
View File

@ -43,7 +43,7 @@ Thread* Thread::Current() {
#if defined(WEBRTC_POSIX)
ThreadManager::ThreadManager() {
pthread_key_create(&key_, NULL);
pthread_key_create(&key_, nullptr);
#ifndef NO_MAIN_THREAD_WRAPPING
WrapCurrentThread();
#endif
@ -98,7 +98,7 @@ void ThreadManager::SetCurrentThread(Thread *thread) {
Thread *ThreadManager::WrapCurrentThread() {
Thread* result = CurrentThread();
if (NULL == result) {
if (nullptr == result) {
result = new Thread();
result->WrapCurrentWithThreadManager(this, true);
}
@ -134,7 +134,7 @@ Thread::Thread(SocketServer* ss)
: MessageQueue(ss, false),
running_(true, false),
#if defined(WEBRTC_WIN)
thread_(NULL),
thread_(nullptr),
thread_id_(0),
#endif
owned_(true),
@ -147,7 +147,7 @@ Thread::Thread(std::unique_ptr<SocketServer> ss)
: MessageQueue(std::move(ss), false),
running_(true, false),
#if defined(WEBRTC_WIN)
thread_(NULL),
thread_(nullptr),
thread_id_(0),
#endif
owned_(true),
@ -182,7 +182,7 @@ bool Thread::SleepMs(int milliseconds) {
struct timespec ts;
ts.tv_sec = milliseconds / 1000;
ts.tv_nsec = (milliseconds % 1000) * 1000000;
int ret = nanosleep(&ts, NULL);
int ret = nanosleep(&ts, nullptr);
if (ret != 0) {
LOG_ERR(LS_WARNING) << "nanosleep() returning early";
return false;
@ -218,7 +218,7 @@ bool Thread::Start(Runnable* runnable) {
init->thread = this;
init->runnable = runnable;
#if defined(WEBRTC_WIN)
thread_ = CreateThread(NULL, 0, PreRun, init, 0, &thread_id_);
thread_ = CreateThread(nullptr, 0, PreRun, init, 0, &thread_id_);
if (thread_) {
running_.Set();
} else {
@ -244,13 +244,13 @@ bool Thread::WrapCurrent() {
void Thread::UnwrapCurrent() {
// Clears the platform-specific thread-specific storage.
ThreadManager::Instance()->SetCurrentThread(NULL);
ThreadManager::Instance()->SetCurrentThread(nullptr);
#if defined(WEBRTC_WIN)
if (thread_ != NULL) {
if (thread_ != nullptr) {
if (!CloseHandle(thread_)) {
LOG_GLE(LS_ERROR) << "When unwrapping thread, failed to close handle.";
}
thread_ = NULL;
thread_ = nullptr;
}
#endif
running_.Reset();
@ -269,10 +269,10 @@ void Thread::Join() {
}
#if defined(WEBRTC_WIN)
RTC_DCHECK(thread_ != NULL);
RTC_DCHECK(thread_ != nullptr);
WaitForSingleObject(thread_, INFINITE);
CloseHandle(thread_);
thread_ = NULL;
thread_ = nullptr;
thread_id_ = 0;
#elif defined(WEBRTC_POSIX)
void *pv;
@ -360,7 +360,7 @@ void Thread::Send(const Location& posted_from,
AutoThread thread;
Thread *current_thread = Thread::Current();
RTC_DCHECK(current_thread != NULL); // AutoThread ensures this
RTC_DCHECK(current_thread != nullptr); // AutoThread ensures this
bool ready = false;
{
@ -405,7 +405,7 @@ void Thread::Send(const Location& posted_from,
}
void Thread::ReceiveSends() {
ReceiveSendsFromThread(NULL);
ReceiveSendsFromThread(nullptr);
}
void Thread::ReceiveSendsFromThread(const Thread* source) {
@ -432,7 +432,7 @@ void Thread::ReceiveSendsFromThread(const Thread* source) {
bool Thread::PopSendMessageFromThread(const Thread* source, _SendMessage* msg) {
for (std::list<_SendMessage>::iterator it = sendlist_.begin();
it != sendlist_.end(); ++it) {
if (it->thread == source || source == NULL) {
if (it->thread == source || source == nullptr) {
*msg = *it;
sendlist_.erase(it);
return true;
@ -456,7 +456,7 @@ void Thread::Clear(MessageHandler* phandler,
// Remove messages on sendlist_ with phandler
// Object target cleared: remove from send list, wakeup/set ready
// if sender not NULL.
// if sender not null.
std::list<_SendMessage>::iterator iter = sendlist_.begin();
while (iter != sendlist_.end()) {
@ -538,7 +538,7 @@ AutoThread::AutoThread() {
AutoThread::~AutoThread() {
Stop();
if (ThreadManager::Instance()->CurrentThread() == this) {
ThreadManager::Instance()->SetCurrentThread(NULL);
ThreadManager::Instance()->SetCurrentThread(nullptr);
}
}
@ -548,7 +548,7 @@ ComThread::~ComThread() {
}
void ComThread::Run() {
HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
RTC_DCHECK(SUCCEEDED(hr));
if (SUCCEEDED(hr)) {
Thread::Run();

14
webrtc/base/thread.h
View File

@ -56,7 +56,7 @@ class ThreadManager {
// unexpected contexts (like inside browser plugins) and it would be a
// shame to break it. It is also conceivable on Win32 that we won't even
// be able to get synchronization privileges, in which case the result
// will have a NULL handle.
// will have a null handle.
Thread *WrapCurrentThread();
void UnwrapCurrentThread();
@ -133,12 +133,12 @@ class LOCKABLE Thread : public MessageQueue {
static bool SleepMs(int millis);
// Sets the thread's name, for debugging. Must be called before Start().
// If |obj| is non-NULL, its value is appended to |name|.
// If |obj| is non-null, its value is appended to |name|.
const std::string& name() const { return name_; }
bool SetName(const std::string& name, const void* obj);
// Starts the execution of the thread.
bool Start(Runnable* runnable = NULL);
bool Start(Runnable* runnable = nullptr);
// Tells the thread to stop and waits until it is joined.
// Never call Stop on the current thread. Instead use the inherited Quit
@ -154,7 +154,7 @@ class LOCKABLE Thread : public MessageQueue {
virtual void Send(const Location& posted_from,
MessageHandler* phandler,
uint32_t id = 0,
MessageData* pdata = NULL);
MessageData* pdata = nullptr);
// Convenience method to invoke a functor on another thread. Caller must
// provide the |ReturnT| template argument, which cannot (easily) be deduced.
@ -174,7 +174,7 @@ class LOCKABLE Thread : public MessageQueue {
// From MessageQueue
void Clear(MessageHandler* phandler,
uint32_t id = MQID_ANY,
MessageList* removed = NULL) override;
MessageList* removed = nullptr) override;
void ReceiveSends() override;
// ProcessMessages will process I/O and dispatch messages until:
@ -255,11 +255,11 @@ class LOCKABLE Thread : public MessageQueue {
// Return true if the thread was started and hasn't yet stopped.
bool running() { return running_.Wait(0); }
// Processes received "Send" requests. If |source| is not NULL, only requests
// Processes received "Send" requests. If |source| is not null, only requests
// from |source| are processed, otherwise, all requests are processed.
void ReceiveSendsFromThread(const Thread* source);
// If |source| is not NULL, pops the first "Send" message from |source| in
// If |source| is not null, pops the first "Send" message from |source| in
// |sendlist_|, otherwise, pops the first "Send" message of |sendlist_|.
// The caller must lock |crit_| before calling.
// Returns true if there is such a message.

4
webrtc/base/thread_checker_unittest.cc
View File

@ -54,7 +54,7 @@ class CallDoStuffOnThread : public Thread {
explicit CallDoStuffOnThread(ThreadCheckerClass* thread_checker_class)
: Thread(),
thread_checker_class_(thread_checker_class) {
SetName("call_do_stuff_on_thread", NULL);
SetName("call_do_stuff_on_thread", nullptr);
}
void Run() override { thread_checker_class_->DoStuff(); }
@ -78,7 +78,7 @@ class DeleteThreadCheckerClassOnThread : public Thread {
ThreadCheckerClass* thread_checker_class)
: Thread(),
thread_checker_class_(thread_checker_class) {
SetName("delete_thread_checker_class_on_thread", NULL);
SetName("delete_thread_checker_class_on_thread", nullptr);
}
void Run() override { thread_checker_class_.reset(); }

8
webrtc/base/thread_unittest.cc
View File

@ -243,7 +243,7 @@ TEST(ThreadTest, Names) {
delete thread;
thread = new Thread();
// Name with no object parameter
EXPECT_TRUE(thread->SetName("No object", NULL));
EXPECT_TRUE(thread->SetName("No object", nullptr));
EXPECT_TRUE(thread->Start());
thread->Stop();
delete thread;
@ -292,7 +292,7 @@ TEST(ThreadTest, Invoke) {
TEST(ThreadTest, TwoThreadsInvokeNoDeadlock) {
AutoThread thread;
Thread* current_thread = Thread::Current();
ASSERT_TRUE(current_thread != NULL);
ASSERT_TRUE(current_thread != nullptr);
Thread other_thread;
other_thread.Start();
@ -443,7 +443,7 @@ class AsyncInvokeTest : public testing::Test {
AsyncInvokeTest()
: int_value_(0),
invoke_started_(true, false),
expected_thread_(NULL) {}
expected_thread_(nullptr) {}
int int_value_;
Event invoke_started_;
@ -788,7 +788,7 @@ class ComThreadTest : public testing::Test, public MessageHandler {
ComThreadTest() : done_(false) {}
protected:
virtual void OnMessage(Message* message) {
HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
// S_FALSE means the thread was already inited for a multithread apartment.
EXPECT_EQ(S_FALSE, hr);
if (SUCCEEDED(hr)) {

2
webrtc/base/timeutils.cc
View File

@ -189,7 +189,7 @@ int64_t TmToSeconds(const std::tm& tm) {
int64_t TimeUTCMicros() {
#if defined(WEBRTC_POSIX)
struct timeval time;
gettimeofday(&time, NULL);
gettimeofday(&time, nullptr);
// Convert from second (1.0) and microsecond (1e-6).
return (static_cast<int64_t>(time.tv_sec) * rtc::kNumMicrosecsPerSec +
time.tv_usec);

19
webrtc/base/trace_event.h
View File

@ -817,10 +817,9 @@ static inline void AddTraceEvent(char phase,
const char* name,
unsigned long long id,
unsigned char flags) {
TRACE_EVENT_API_ADD_TRACE_EVENT(
phase, category_enabled, name, id,
kZeroNumArgs, NULL, NULL, NULL,
flags);
TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_enabled, name, id,
kZeroNumArgs, nullptr, nullptr, nullptr,
flags);
}
template<class ARG1_TYPE>
@ -867,7 +866,7 @@ static inline void AddTraceEvent(char phase,
class TraceEndOnScopeClose {
public:
// Note: members of data_ intentionally left uninitialized. See Initialize.
TraceEndOnScopeClose() : p_data_(NULL) {}
TraceEndOnScopeClose() : p_data_(nullptr) {}
~TraceEndOnScopeClose() {
if (p_data_)
AddEventIfEnabled();
@ -885,12 +884,10 @@ class TraceEndOnScopeClose {
void AddEventIfEnabled() {
// Only called when p_data_ is non-null.
if (*p_data_->category_enabled) {
TRACE_EVENT_API_ADD_TRACE_EVENT(
TRACE_EVENT_PHASE_END,
p_data_->category_enabled,
p_data_->name, kNoEventId,
kZeroNumArgs, NULL, NULL, NULL,
TRACE_EVENT_FLAG_NONE);
TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_END,
p_data_->category_enabled, p_data_->name,
kNoEventId, kZeroNumArgs, nullptr,
nullptr, nullptr, TRACE_EVENT_FLAG_NONE);
}
}

2
webrtc/base/transformadapter.cc
View File

@ -175,7 +175,7 @@ TransformAdapter::Close() {
if (!direction_read_ && (state_ == ST_PROCESSING)) {
state_ = ST_FLUSHING;
do {
Write(0, 0, NULL, NULL);
Write(0, 0, nullptr, nullptr);
} while (state_ == ST_FLUSHING);
}
state_ = ST_COMPLETE;

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