Replace NULL with nullptr or null in webrtc/base/.
BUG=webrtc:7147
Review-Url: https://codereview.webrtc.org/2718663005
Cr-Original-Commit-Position: refs/heads/master@{#16878}
Cr-Mirrored-From: https://chromium.googlesource.com/external/webrtc
Cr-Mirrored-Commit: 37f5ecfd8f3337475872c9242221471784894f1c
diff --git a/base/asyncinvoker-inl.h b/base/asyncinvoker-inl.h
index d172eee..bce68d9 100644
--- a/base/asyncinvoker-inl.h
+++ b/base/asyncinvoker-inl.h
@@ -68,7 +68,7 @@
CritScope cs(&crit_);
callback_ = callback;
}
- bool CallbackCanceled() const { return calling_thread_ == NULL; }
+ bool CallbackCanceled() const { return calling_thread_ == nullptr; }
private:
Location callback_posted_from_;
diff --git a/base/asyncinvoker.cc b/base/asyncinvoker.cc
index aa65499..a143e25 100644
--- a/base/asyncinvoker.cc
+++ b/base/asyncinvoker.cc
@@ -147,8 +147,8 @@
// 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
diff --git a/base/asyncpacketsocket.h b/base/asyncpacketsocket.h
index f18839e..a540947 100644
--- a/base/asyncpacketsocket.h
+++ b/base/asyncpacketsocket.h
@@ -78,7 +78,7 @@
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;
diff --git a/base/asyncsocket.cc b/base/asyncsocket.cc
index 873badc..6c41596 100644
--- a/base/asyncsocket.cc
+++ b/base/asyncsocket.cc
@@ -19,7 +19,7 @@
AsyncSocket::~AsyncSocket() {
}
-AsyncSocketAdapter::AsyncSocketAdapter(AsyncSocket* socket) : socket_(NULL) {
+AsyncSocketAdapter::AsyncSocketAdapter(AsyncSocket* socket) : socket_(nullptr) {
Attach(socket);
}
diff --git a/base/asyncsocket.h b/base/asyncsocket.h
index bf6c88a..40cf1b5b 100644
--- a/base/asyncsocket.h
+++ b/base/asyncsocket.h
@@ -42,7 +42,7 @@
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.
diff --git a/base/asynctcpsocket.cc b/base/asynctcpsocket.cc
index 0b92b38..658541c 100644
--- a/base/asynctcpsocket.cc
+++ b/base/asynctcpsocket.cc
@@ -47,11 +47,11 @@
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 @@
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 @@
// 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,
diff --git a/base/asynctcpsocket.h b/base/asynctcpsocket.h
index cd5c104..2e4ff9a 100644
--- a/base/asynctcpsocket.h
+++ b/base/asynctcpsocket.h
@@ -51,7 +51,7 @@
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 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,
diff --git a/base/asyncudpsocket.cc b/base/asyncudpsocket.cc
index 3ce629c..0bccb73 100644
--- a/base/asyncudpsocket.cc
+++ b/base/asyncudpsocket.cc
@@ -22,7 +22,7 @@
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 @@
AsyncSocket* socket =
factory->CreateAsyncSocket(bind_address.family(), SOCK_DGRAM);
if (!socket)
- return NULL;
+ return nullptr;
return Create(socket, bind_address);
}
diff --git a/base/asyncudpsocket.h b/base/asyncudpsocket.h
index aa6a904..e5535e0 100644
--- a/base/asyncudpsocket.h
+++ b/base/asyncudpsocket.h
@@ -23,7 +23,7 @@
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);
diff --git a/base/base64.cc b/base/base64.cc
index 8fa1c81..43b6325 100644
--- a/base/base64.cc
+++ b/base/base64.cc
@@ -74,7 +74,7 @@
}
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 @@
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 @@
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;
diff --git a/base/base64.h b/base/base64.h
index 903e77e..eba3cc0 100644
--- a/base/base64.h
+++ b/base/base64.h
@@ -83,7 +83,7 @@
}
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,
diff --git a/base/base64_unittest.cc b/base/base64_unittest.cc
index 96bc695..6bfba79 100644
--- a/base/base64_unittest.cc
+++ b/base/base64_unittest.cc
@@ -339,14 +339,14 @@
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 @@
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));
}
diff --git a/base/bitbuffer.cc b/base/bitbuffer.cc
index fc8a899..4ea2b15 100644
--- a/base/bitbuffer.cc
+++ b/base/bitbuffer.cc
@@ -202,8 +202,8 @@
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_;
}
diff --git a/base/bitbuffer_unittest.cc b/base/bitbuffer_unittest.cc
index aa9a1e7..1614299 100644
--- a/base/bitbuffer_unittest.cc
+++ b/base/bitbuffer_unittest.cc
@@ -169,8 +169,8 @@
// 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
}
diff --git a/base/bytebuffer.cc b/base/bytebuffer.cc
index 317b6f3..859c123 100644
--- a/base/bytebuffer.cc
+++ b/base/bytebuffer.cc
@@ -23,12 +23,12 @@
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)
diff --git a/base/checks.cc b/base/checks.cc
index 6aaaf9ff8..32c2f58 100644
--- a/base/checks.cc
+++ b/base/checks.cc
@@ -67,7 +67,7 @@
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 @@
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.
diff --git a/base/checks.h b/base/checks.h
index e165741..c15a08c 100644
--- a/base/checks.h
+++ b/base/checks.h
@@ -163,13 +163,13 @@
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); \
}
diff --git a/base/event.cc b/base/event.cc
index 4b348f6..27506b3 100644
--- a/base/event.cc
+++ b/base/event.cc
@@ -27,10 +27,9 @@
#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 @@
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 @@
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;
diff --git a/base/event_tracer_unittest.cc b/base/event_tracer_unittest.cc
index ec474bd..a16c0ef 100644
--- a/base/event_tracer_unittest.cc
+++ b/base/event_tracer_unittest.cc
@@ -32,7 +32,7 @@
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;
diff --git a/base/fileutils.cc b/base/fileutils.cc
index a883995..ac21c18 100644
--- a/base/fileutils.cc
+++ b/base/fileutils.cc
@@ -40,7 +40,8 @@
#ifdef WEBRTC_WIN
: handle_(INVALID_HANDLE_VALUE) {
#else
- : dir_(NULL), dirent_(NULL) {
+ : dir_(nullptr),
+ dirent_(nullptr){
#endif
}
@@ -68,13 +69,13 @@
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 @@
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 @@
#endif
}
-FilesystemInterface* Filesystem::default_filesystem_ = NULL;
+FilesystemInterface* Filesystem::default_filesystem_ = nullptr;
FilesystemInterface *Filesystem::EnsureDefaultFilesystem() {
if (!default_filesystem_) {
diff --git a/base/fileutils.h b/base/fileutils.h
index 8b09099..8f6ec52 100644
--- a/base/fileutils.h
+++ b/base/fileutils.h
@@ -85,7 +85,7 @@
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,
diff --git a/base/fileutils_unittest.cc b/base/fileutils_unittest.cc
index 068d60e..a4e2850 100644
--- a/base/fileutils_unittest.cc
+++ b/base/fileutils_unittest.cc
@@ -27,13 +27,13 @@
// 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 @@
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 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
diff --git a/base/firewallsocketserver.cc b/base/firewallsocketserver.cc
index 92ac88f..30e5c3b 100644
--- a/base/firewallsocketserver.cc
+++ b/base/firewallsocketserver.cc
@@ -121,7 +121,7 @@
if (server_ && should_delete_server_) {
delete server_;
- server_ = NULL;
+ server_ = nullptr;
}
}
@@ -210,7 +210,7 @@
(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);
}
diff --git a/base/firewallsocketserver.h b/base/firewallsocketserver.h
index 26fc75e..95ff039 100644
--- a/base/firewallsocketserver.h
+++ b/base/firewallsocketserver.h
@@ -26,8 +26,8 @@
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 @@
void set_socketserver(SocketServer* server) {
if (server_ && should_delete_server_) {
delete server_;
- server_ = NULL;
+ server_ = nullptr;
should_delete_server_ = false;
}
server_ = server;
diff --git a/base/flags.cc b/base/flags.cc
index 4fcd4ac..9b7177c 100644
--- a/base/flags.cc
+++ b/base/flags.cc
@@ -106,19 +106,18 @@
// -----------------------------------------------------------------------------
// 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 @@
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 @@
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 @@
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 @@
}
// 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 @@
// remove the flag & value from the command
if (remove_flags)
while (j < i)
- argv[j++] = NULL;
+ argv[j++] = nullptr;
}
}
@@ -246,7 +244,7 @@
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;
diff --git a/base/flags.h b/base/flags.h
index 7a71487..d6a871e 100644
--- a/base/flags.h
+++ b/base/flags.h
@@ -189,19 +189,19 @@
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,
diff --git a/base/httpbase.cc b/base/httpbase.cc
index 6364554..bc8ac64 100644
--- a/base/httpbase.cc
+++ b/base/httpbase.cc
@@ -176,7 +176,7 @@
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 @@
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 @@
}
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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);
diff --git a/base/httpbase.h b/base/httpbase.h
index 7f368f8..4b834a4 100644
--- a/base/httpbase.h
+++ b/base/httpbase.h
@@ -113,7 +113,7 @@
// 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:
diff --git a/base/httpbase_unittest.cc b/base/httpbase_unittest.cc
index 8d8e097..52c1c53 100644
--- a/base/httpbase_unittest.cc
+++ b/base/httpbase_unittest.cc
@@ -54,7 +54,7 @@
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 @@
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::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 @@
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::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, SupportsSendNoDocument) {
// Queue response document
- SetupDocument(NULL);
+ SetupDocument(nullptr);
// Begin send
base.send(&data);
@@ -475,7 +477,7 @@
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 @@
// 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
diff --git a/base/httpcommon-inl.h b/base/httpcommon-inl.h
index 75ede29..f29f075 100644
--- a/base/httpcommon-inl.h
+++ b/base/httpcommon-inl.h
@@ -53,7 +53,7 @@
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);
diff --git a/base/httpcommon.cc b/base/httpcommon.cc
index 3d46ab2..031505b 100644
--- a/base/httpcommon.cc
+++ b/base/httpcommon.cc
@@ -341,7 +341,7 @@
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::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 @@
{
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 @@
#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 @@
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());
diff --git a/base/httpserver.cc b/base/httpserver.cc
index 083fc07..b190691 100644
--- a/base/httpserver.cc
+++ b/base/httpserver.cc
@@ -92,7 +92,7 @@
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::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 @@
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 @@
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 @@
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 @@
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 @@
} else if (mode == HM_CONNECT) {
base_.recv(¤t_->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::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);
diff --git a/base/httpserver.h b/base/httpserver.h
index c322e81..cbee734 100644
--- a/base/httpserver.h
+++ b/base/httpserver.h
@@ -51,8 +51,8 @@
// 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;
diff --git a/base/httpserver_unittest.cc b/base/httpserver_unittest.cc
index 0c653cb..96d5fb6 100644
--- a/base/httpserver_unittest.cc
+++ b/base/httpserver_unittest.cc
@@ -27,7 +27,7 @@
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 @@
}
void OnRequestComplete(HttpServer*, HttpServerTransaction* t, int) {
ASSERT_EQ(transaction, t);
- transaction = NULL;
+ transaction = nullptr;
}
void OnClosed(HttpServer*) {
server_closed = true;
@@ -78,7 +78,7 @@
// 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 @@
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
diff --git a/base/ifaddrs-android.cc b/base/ifaddrs-android.cc
index d8d28a5..f3c7838 100644
--- a/base/ifaddrs-android.cc
+++ b/base/ifaddrs-android.cc
@@ -39,7 +39,7 @@
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 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 @@
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 @@
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 @@
}
void freeifaddrs(struct ifaddrs* addrs) {
- struct ifaddrs* last = NULL;
+ struct ifaddrs* last = nullptr;
struct ifaddrs* cursor = addrs;
while (cursor) {
delete[] cursor->ifa_name;
diff --git a/base/logging.cc b/base/logging.cc
index 3624a40..25f85c9 100644
--- a/base/logging.cc
+++ b/base/logging.cc
@@ -110,7 +110,7 @@
// 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 @@
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 @@
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 @@
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 @@
}
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 @@
"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 @@
// stderr.
log_to_stderr = exists_and_is_valid && should_log;
}
- if (key != NULL) {
+ if (key != nullptr) {
CFRelease(key);
}
#endif
@@ -443,7 +447,7 @@
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 << "## "
diff --git a/base/logging.h b/base/logging.h
index 13f0b78..8f476a0 100644
--- a/base/logging.h
+++ b/base/logging.h
@@ -139,9 +139,12 @@
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 @@
// 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 @@
};
// 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 @@
(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)
diff --git a/base/logging_unittest.cc b/base/logging_unittest.cc
index 5035035..3d9fc9e 100644
--- a/base/logging_unittest.cc
+++ b/base/logging_unittest.cc
@@ -37,7 +37,7 @@
// 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 @@
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 @@
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 @@
};
TEST(LogTest, MultipleThreads) {
- int sev = LogMessage::GetLogToStream(NULL);
+ int sev = LogMessage::GetLogToStream(nullptr);
LogThread thread1, thread2, thread3;
thread1.Start();
@@ -117,7 +117,7 @@
LogMessage::RemoveLogToStream(&stream3);
}
- EXPECT_EQ(sev, LogMessage::GetLogToStream(NULL));
+ EXPECT_EQ(sev, LogMessage::GetLogToStream(nullptr));
}
@@ -137,11 +137,11 @@
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);
diff --git a/base/macutils.cc b/base/macutils.cc
index 0d9cae2..6e90722 100644
--- a/base/macutils.cc
+++ b/base/macutils.cc
@@ -24,7 +24,7 @@
///////////////////////////////////////////////////////////////////////////////
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 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) {
diff --git a/base/messagedigest.cc b/base/messagedigest.cc
index 5e8621c..05c8c4f 100644
--- a/base/messagedigest.cc
+++ b/base/messagedigest.cc
@@ -34,7 +34,7 @@
MessageDigest* digest = new OpenSSLDigest(alg);
if (digest->Size() == 0) { // invalid algorithm
delete digest;
- digest = NULL;
+ digest = nullptr;
}
return digest;
}
diff --git a/base/messagequeue.cc b/base/messagequeue.cc
index 4a30ad1..efe6188 100644
--- a/base/messagequeue.cc
+++ b/base/messagequeue.cc
@@ -49,7 +49,7 @@
//------------------------------------------------------------------
// 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 @@
}
bool MessageQueueManager::IsInitialized() {
- return instance_ != NULL;
+ return instance_ != nullptr;
}
MessageQueueManager::MessageQueueManager() : locked_(false) {}
@@ -99,7 +99,7 @@
destroy = message_queues_.empty();
}
if (destroy) {
- instance_ = NULL;
+ instance_ = nullptr;
delete this;
}
}
@@ -214,11 +214,11 @@
// 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 @@
}
// 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;
diff --git a/base/messagequeue.h b/base/messagequeue.h
index df50f54..20e2e13 100644
--- a/base/messagequeue.h
+++ b/base/messagequeue.h
@@ -157,8 +157,8 @@
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 @@
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 @@
// 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));
}
}
diff --git a/base/messagequeue_unittest.cc b/base/messagequeue_unittest.cc
index 8834ab5..9652bb3 100644
--- a/base/messagequeue_unittest.cc
+++ b/base/messagequeue_unittest.cc
@@ -57,13 +57,13 @@
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 @@
}
struct UnwrapMainThreadScope {
- UnwrapMainThreadScope() : rewrap_(Thread::Current() != NULL) {
+ UnwrapMainThreadScope() : rewrap_(Thread::Current() != nullptr) {
if (rewrap_) ThreadManager::Instance()->UnwrapCurrentThread();
}
~UnwrapMainThreadScope() {
diff --git a/base/nat_unittest.cc b/base/nat_unittest.cc
index bd630b3..f585eff 100644
--- a/base/nat_unittest.cc
+++ b/base/nat_unittest.cc
@@ -336,7 +336,7 @@
}
void OnAcceptEvent(AsyncSocket* socket) {
- accepted_.reset(server_->Accept(NULL));
+ accepted_.reset(server_->Accept(nullptr));
}
void OnCloseEvent(AsyncSocket* socket, int error) {
diff --git a/base/natsocketfactory.cc b/base/natsocketfactory.cc
index 37586fe..7aa6838 100644
--- a/base/natsocketfactory.cc
+++ b/base/natsocketfactory.cc
@@ -71,9 +71,13 @@
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 @@
} else {
server_addr_.Clear();
delete socket_;
- socket_ = NULL;
+ socket_ = nullptr;
}
return result;
@@ -211,7 +215,7 @@
connected_ = false;
remote_addr_ = SocketAddress();
delete socket_;
- socket_ = NULL;
+ socket_ = nullptr;
}
}
return result;
@@ -339,8 +343,7 @@
// 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 @@
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 @@
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 @@
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::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 @@
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);
}
diff --git a/base/nethelpers.cc b/base/nethelpers.cc
index 7ca6549..6c2ef9c 100644
--- a/base/nethelpers.cc
+++ b/base/nethelpers.cc
@@ -43,7 +43,7 @@
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 @@
// 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 @@
}
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;
diff --git a/base/network.cc b/base/network.cc
index 1092a04..69dc28c 100644
--- a/base/network.cc
+++ b/base/network.cc
@@ -392,9 +392,10 @@
}
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 @@
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 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 @@
#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 @@
// 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
diff --git a/base/openssladapter.cc b/base/openssladapter.cc
index 6f9049d..bc7b99b 100644
--- a/base/openssladapter.cc
+++ b/base/openssladapter.cc
@@ -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 @@
// 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_free(BIO* b) {
- if (b == NULL)
+ if (b == nullptr)
return 0;
return 1;
}
@@ -171,7 +163,7 @@
#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 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 @@
#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 @@
#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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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)
diff --git a/base/openssldigest.cc b/base/openssldigest.cc
index 37f2d0e..3115074 100644
--- a/base/openssldigest.cc
+++ b/base/openssldigest.cc
@@ -18,9 +18,9 @@
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 @@
}
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::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) {
diff --git a/base/opensslidentity.cc b/base/opensslidentity.cc
index 7b96f6a..9495496 100644
--- a/base/opensslidentity.cc
+++ b/base/opensslidentity.cc
@@ -46,13 +46,13 @@
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 @@
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 @@
// 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 @@
// 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 @@
// 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 @@
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 @@
EVP_PKEY* pkey = MakeKey(key_params);
if (!pkey) {
LogSSLErrors("Generating key pair");
- return NULL;
+ return nullptr;
}
return new OpenSSLKeyPair(pkey);
}
@@ -289,7 +288,7 @@
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 @@
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::AddReference() const {
- RTC_DCHECK(x509_ != NULL);
+ RTC_DCHECK(x509_ != nullptr);
#if defined(OPENSSL_IS_BORINGSSL)
X509_up_ref(x509_);
#else
@@ -476,8 +476,8 @@
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 @@
delete key_pair;
}
LOG(LS_INFO) << "Identity generation failed";
- return NULL;
+ return nullptr;
}
OpenSSLIdentity* OpenSSLIdentity::GenerateWithExpiration(
@@ -503,7 +503,7 @@
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)
diff --git a/base/opensslidentity.h b/base/opensslidentity.h
index e00978c..84716d1 100644
--- a/base/opensslidentity.h
+++ b/base/opensslidentity.h
@@ -30,7 +30,7 @@
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);
diff --git a/base/opensslstreamadapter.cc b/base/opensslstreamadapter.cc
index 45ff30a..afcf39f 100644
--- a/base/opensslstreamadapter.cc
+++ b/base/opensslstreamadapter.cc
@@ -86,70 +86,62 @@
// (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 @@
// 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_free(BIO* b) {
- if (b == NULL)
+ if (b == nullptr)
return 0;
return 1;
}
@@ -283,8 +267,8 @@
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 @@
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::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 @@
// 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 @@
// 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 @@
}
#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 @@
}
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 @@
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 @@
if (identity_ && !identity_->ConfigureIdentity(ctx)) {
SSL_CTX_free(ctx);
- return NULL;
+ return nullptr;
}
#if !defined(NDEBUG)
@@ -1075,13 +1059,13 @@
// 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;
}
}
diff --git a/base/optionsfile_unittest.cc b/base/optionsfile_unittest.cc
index 4eaf801..69bd719 100644
--- a/base/optionsfile_unittest.cc
+++ b/base/optionsfile_unittest.cc
@@ -47,7 +47,7 @@
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();
}
diff --git a/base/pathutils.cc b/base/pathutils.cc
index 80df0ef..f79c298 100644
--- a/base/pathutils.cc
+++ b/base/pathutils.cc
@@ -43,7 +43,7 @@
///////////////////////////////////////////////////////////////////////////////
bool Pathname::IsFolderDelimiter(char ch) {
- return (NULL != ::strchr(FOLDER_DELIMS, ch));
+ return (nullptr != ::strchr(FOLDER_DELIMS, ch));
}
char Pathname::DefaultFolderDelimiter() {
diff --git a/base/physicalsocketserver.cc b/base/physicalsocketserver.cc
index 5b49638..0d6cfa1 100644
--- a/base/physicalsocketserver.cc
+++ b/base/physicalsocketserver.cc
@@ -1118,15 +1118,15 @@
}
~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 @@
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 @@
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 @@
// < 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 @@
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 @@
#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;
}
diff --git a/base/physicalsocketserver_unittest.cc b/base/physicalsocketserver_unittest.cc
index 63d2f0d..0eea1d5 100644
--- a/base/physicalsocketserver_unittest.cc
+++ b/base/physicalsocketserver_unittest.cc
@@ -483,9 +483,9 @@
}
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 @@
};
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 @@
// 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 @@
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.
diff --git a/base/platform_file.cc b/base/platform_file.cc
index a41324f..a00543c 100644
--- a/base/platform_file.cc
+++ b/base/platform_file.cc
@@ -26,10 +26,10 @@
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");
}
diff --git a/base/platform_thread.cc b/base/platform_thread.cc
index 525f0dd..52f8810 100644
--- a/base/platform_thread.cc
+++ b/base/platform_thread.cc
@@ -149,7 +149,7 @@
// 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_);
diff --git a/base/proxy_unittest.cc b/base/proxy_unittest.cc
index 5c5a748..b72d228 100644
--- a/base/proxy_unittest.cc
+++ b/base/proxy_unittest.cc
@@ -31,16 +31,14 @@
// 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 @@
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 @@
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());
}
diff --git a/base/proxyserver.cc b/base/proxyserver.cc
index 66cf695..713a986 100644
--- a/base/proxyserver.cc
+++ b/base/proxyserver.cc
@@ -24,7 +24,7 @@
: 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 @@
}
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 @@
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::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::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::Write(AsyncSocket* socket, FifoBuffer* buffer) {
- RTC_DCHECK(socket != NULL);
+ RTC_DCHECK(socket != nullptr);
size_t size;
int written;
const void* p = buffer->GetReadData(&size);
diff --git a/base/scoped_autorelease_pool.h b/base/scoped_autorelease_pool.h
index 14a5c5f..2e0a204 100644
--- a/base/scoped_autorelease_pool.h
+++ b/base/scoped_autorelease_pool.h
@@ -43,9 +43,9 @@
// 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_;
diff --git a/base/scoped_ref_ptr.h b/base/scoped_ref_ptr.h
index df66912..26aff03 100644
--- a/base/scoped_ref_ptr.h
+++ b/base/scoped_ref_ptr.h
@@ -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 @@
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 @@
// 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;
}
diff --git a/base/sharedexclusivelock_unittest.cc b/base/sharedexclusivelock_unittest.cc
index 132bbd9..e0462ff 100644
--- a/base/sharedexclusivelock_unittest.cc
+++ b/base/sharedexclusivelock_unittest.cc
@@ -61,7 +61,7 @@
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 @@
done_->Set();
}
delete message->pdata;
- message->pdata = NULL;
+ message->pdata = nullptr;
}
};
@@ -91,7 +91,7 @@
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 @@
done_->Set();
}
delete message->pdata;
- message->pdata = NULL;
+ message->pdata = nullptr;
}
};
diff --git a/base/signalthread.cc b/base/signalthread.cc
index 40df02f..be2741e 100644
--- a/base/signalthread.cc
+++ b/base/signalthread.cc
@@ -113,7 +113,7 @@
// 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::OnMainThreadDestroyed() {
EnterExit ee(this);
- main_ = NULL;
+ main_ = nullptr;
}
bool SignalThread::Worker::IsProcessingMessages() {
diff --git a/base/signalthread_unittest.cc b/base/signalthread_unittest.cc
index 0029acf..15f665a 100644
--- a/base/signalthread_unittest.cc
+++ b/base/signalthread_unittest.cc
@@ -36,7 +36,7 @@
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
diff --git a/base/sigslot.h b/base/sigslot.h
index b1a6e8c..4534ec9 100644
--- a/base/sigslot.h
+++ b/base/sigslot.h
@@ -216,13 +216,9 @@
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()
{
diff --git a/base/sigslot_unittest.cc b/base/sigslot_unittest.cc
index d7d64b4..cb77336 100644
--- a/base/sigslot_unittest.cc
+++ b/base/sigslot_unittest.cc
@@ -32,8 +32,7 @@
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 @@
void Disconnect() {
if (!signal_) return;
signal_->disconnect(this);
- signal_ = NULL;
+ signal_ = nullptr;
}
void OnSignal() {
++signal_count_;
diff --git a/base/sigslottester_unittest.cc b/base/sigslottester_unittest.cc
index 778e352..00b2577 100755
--- a/base/sigslottester_unittest.cc
+++ b/base/sigslottester_unittest.cc
@@ -68,9 +68,9 @@
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 @@
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
diff --git a/base/socket_unittest.cc b/base/socket_unittest.cc
index 16edf90..4a59a16 100644
--- a/base/socket_unittest.cc
+++ b/base/socket_unittest.cc
@@ -224,7 +224,7 @@
// 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 @@
// 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 @@
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());
}
diff --git a/base/socketadapters.cc b/base/socketadapters.cc
index 5f01b2f..060029c 100644
--- a/base/socketadapters.cc
+++ b/base/socketadapters.cc
@@ -281,7 +281,7 @@
state_ = PS_ERROR;
dest_.Clear();
delete context_;
- context_ = NULL;
+ context_ = nullptr;
return BufferedReadAdapter::Close();
}
diff --git a/base/socketaddress.cc b/base/socketaddress.cc
index 8cb53c5..d931f72 100644
--- a/base/socketaddress.cc
+++ b/base/socketaddress.cc
@@ -184,7 +184,7 @@
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 @@
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;
diff --git a/base/socketaddress_unittest.cc b/base/socketaddress_unittest.cc
index e235447..072918e 100644
--- a/base/socketaddress_unittest.cc
+++ b/base/socketaddress_unittest.cc
@@ -237,7 +237,7 @@
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,
diff --git a/base/socketstream.cc b/base/socketstream.cc
index 9407c96..a218dd8 100644
--- a/base/socketstream.cc
+++ b/base/socketstream.cc
@@ -14,7 +14,7 @@
namespace rtc {
-SocketStream::SocketStream(AsyncSocket* socket) : socket_(NULL) {
+SocketStream::SocketStream(AsyncSocket* socket) : socket_(nullptr) {
Attach(socket);
}
@@ -41,13 +41,13 @@
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 @@
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::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 @@
}
void SocketStream::Close() {
- RTC_DCHECK(socket_ != NULL);
+ RTC_DCHECK(socket_ != nullptr);
socket_->Close();
}
diff --git a/base/ssladapter.h b/base/ssladapter.h
index 57e8ee9..0317544 100644
--- a/base/ssladapter.h
+++ b/base/ssladapter.h
@@ -34,7 +34,7 @@
// 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 @@
// 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();
diff --git a/base/ssladapter_unittest.cc b/base/ssladapter_unittest.cc
index c591f19..c8afbe6 100644
--- a/base/ssladapter_unittest.cc
+++ b/base/ssladapter_unittest.cc
@@ -165,8 +165,8 @@
}
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 @@
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 @@
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 @@
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) {}
diff --git a/base/sslfingerprint.cc b/base/sslfingerprint.cc
index e172a2c..bd15743 100644
--- a/base/sslfingerprint.cc
+++ b/base/sslfingerprint.cc
@@ -23,7 +23,7 @@
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 @@
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::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 @@
fingerprint.length(),
':');
if (!value_len)
- return NULL;
+ return nullptr;
return new SSLFingerprint(algorithm, reinterpret_cast<uint8_t*>(value),
value_len);
diff --git a/base/sslidentity.h b/base/sslidentity.h
index 181174b..263d0dc 100644
--- a/base/sslidentity.h
+++ b/base/sslidentity.h
@@ -51,9 +51,9 @@
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 @@
// 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,
diff --git a/base/sslstreamadapter.h b/base/sslstreamadapter.h
index e4df774..e1d1d85 100644
--- a/base/sslstreamadapter.h
+++ b/base/sslstreamadapter.h
@@ -211,7 +211,7 @@
// 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).
diff --git a/base/sslstreamadapter_unittest.cc b/base/sslstreamadapter_unittest.cc
index 737118a..b5184e6 100644
--- a/base/sslstreamadapter_unittest.cc
+++ b/base/sslstreamadapter_unittest.cc
@@ -225,10 +225,10 @@
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 @@
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 @@
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 @@
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 @@
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);
};
diff --git a/base/stream.cc b/base/stream.cc
index f58d367..67ef104 100644
--- a/base/stream.cc
+++ b/base/stream.cc
@@ -78,7 +78,7 @@
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 @@
}
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 @@
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 @@
}
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 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 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 @@
// FileStream
///////////////////////////////////////////////////////////////////////////////
-FileStream::FileStream() : file_(NULL) {
-}
+FileStream::FileStream() : file_(nullptr) {}
FileStream::~FileStream() {
FileStream::Close();
@@ -351,7 +350,7 @@
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 @@
*error = errno;
return false;
}
- return file_ != NULL;
+ return file_ != nullptr;
} else {
if (error) {
*error = -1;
@@ -380,11 +379,11 @@
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 @@
void FileStream::Close() {
if (file_) {
DoClose();
- file_ = NULL;
+ file_ = nullptr;
}
}
@@ -433,7 +432,7 @@
}
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::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::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 @@
#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::Unlock() {
- if (file_ == NULL) {
+ if (file_ == nullptr) {
// Stream not open.
RTC_NOTREACHED();
return false;
@@ -523,9 +522,7 @@
///////////////////////////////////////////////////////////////////////////////
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::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 @@
///////////////////////////////////////////////////////////////////////////////
-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::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 @@
}
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 @@
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 @@
///////////////////////////////////////////////////////////////////////////////
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 @@
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 @@
// 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;
diff --git a/base/stream.h b/base/stream.h
index 33090df..dbc2ad7 100644
--- a/base/stream.h
+++ b/base/stream.h
@@ -125,7 +125,7 @@
// 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 @@
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 @@
// 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);
///////////////////////////////////////////////////////////////////////////////
diff --git a/base/stream_unittest.cc b/base/stream_unittest.cc
index 8cfd052..0fbb6ab 100644
--- a/base/stream_unittest.cc
+++ b/base/stream_unittest.cc
@@ -79,7 +79,7 @@
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 @@
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 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 @@
// 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 @@
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 @@
// 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 @@
// 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 @@
// ........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 @@
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 @@
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 @@
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 @@
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
diff --git a/base/stringencode.cc b/base/stringencode.cc
index 7c11a05..c7d206f 100644
--- a/base/stringencode.cc
+++ b/base/stringencode.cc
@@ -141,7 +141,7 @@
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_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 @@
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);
diff --git a/base/stringencode_unittest.cc b/base/stringencode_unittest.cc
index fbd7975..60929f3 100644
--- a/base/stringencode_unittest.cc
+++ b/base/stringencode_unittest.cc
@@ -21,18 +21,18 @@
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, 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, 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);
diff --git a/base/stringutils.h b/base/stringutils.h
index de25658..4c241f0 100644
--- a/base/stringutils.h
+++ b/base/stringutils.h
@@ -136,8 +136,8 @@
// 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());
}
diff --git a/base/stringutils_unittest.cc b/base/stringutils_unittest.cc
index 5e034dd..7d5b8e2 100644
--- a/base/stringutils_unittest.cc
+++ b/base/stringutils_unittest.cc
@@ -33,13 +33,13 @@
// 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.
diff --git a/base/task_unittest.cc b/base/task_unittest.cc
index 38ceb14..b26d670 100644
--- a/base/task_unittest.cc
+++ b/base/task_unittest.cc
@@ -216,7 +216,7 @@
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 @@
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 @@
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 @@
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 @@
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;
}
}
diff --git a/base/taskparent.cc b/base/taskparent.cc
index f923c5a..aee22a8 100644
--- a/base/taskparent.cc
+++ b/base/taskparent.cc
@@ -20,17 +20,16 @@
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 @@
#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
diff --git a/base/taskrunner.cc b/base/taskrunner.cc
index 79e48ec..0ee5d02 100644
--- a/base/taskrunner.cc
+++ b/base/taskrunner.cc
@@ -77,7 +77,7 @@
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 @@
#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 @@
// 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 @@
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 @@
// 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 @@
// 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 ||
diff --git a/base/testclient.cc b/base/testclient.cc
index 361bf36..e797c6f 100644
--- a/base/testclient.cc
+++ b/base/testclient.cc
@@ -76,7 +76,7 @@
}
// 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::CheckNoPacket() {
bool res;
Packet* packet = NextPacket(kNoPacketTimeoutMs);
- res = (packet == NULL);
+ res = (packet == nullptr);
delete packet;
return res;
}
diff --git a/base/testclient_unittest.cc b/base/testclient_unittest.cc
index bdd06b3..5507813 100644
--- a/base/testclient_unittest.cc
+++ b/base/testclient_unittest.cc
@@ -39,7 +39,7 @@
->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;
diff --git a/base/testechoserver.h b/base/testechoserver.h
index 76d714b..97606c1 100644
--- a/base/testechoserver.h
+++ b/base/testechoserver.h
@@ -43,7 +43,7 @@
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);
diff --git a/base/testutils.h b/base/testutils.h
index ac7fd93..305d3d0 100644
--- a/base/testutils.h
+++ b/base/testutils.h
@@ -276,14 +276,12 @@
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 @@
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 @@
#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_;
diff --git a/base/thread.cc b/base/thread.cc
index 591253f..a7db418 100644
--- a/base/thread.cc
+++ b/base/thread.cc
@@ -43,7 +43,7 @@
#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 @@
Thread *ThreadManager::WrapCurrentThread() {
Thread* result = CurrentThread();
- if (NULL == result) {
+ if (nullptr == result) {
result = new Thread();
result->WrapCurrentWithThreadManager(this, true);
}
@@ -134,7 +134,7 @@
: MessageQueue(ss, false),
running_(true, false),
#if defined(WEBRTC_WIN)
- thread_(NULL),
+ thread_(nullptr),
thread_id_(0),
#endif
owned_(true),
@@ -147,7 +147,7 @@
: 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 @@
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 @@
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 @@
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 @@
}
#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 @@
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::ReceiveSends() {
- ReceiveSendsFromThread(NULL);
+ ReceiveSendsFromThread(nullptr);
}
void Thread::ReceiveSendsFromThread(const Thread* source) {
@@ -432,7 +432,7 @@
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 @@
// 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() {
Stop();
if (ThreadManager::Instance()->CurrentThread() == this) {
- ThreadManager::Instance()->SetCurrentThread(NULL);
+ ThreadManager::Instance()->SetCurrentThread(nullptr);
}
}
@@ -548,7 +548,7 @@
}
void ComThread::Run() {
- HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+ HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
RTC_DCHECK(SUCCEEDED(hr));
if (SUCCEEDED(hr)) {
Thread::Run();
diff --git a/base/thread.h b/base/thread.h
index 58fa3f0..5751df3 100644
--- a/base/thread.h
+++ b/base/thread.h
@@ -56,7 +56,7 @@
// 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 @@
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 @@
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 @@
// 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 @@
// 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.
diff --git a/base/thread_checker_unittest.cc b/base/thread_checker_unittest.cc
index dee1653..e995b50 100644
--- a/base/thread_checker_unittest.cc
+++ b/base/thread_checker_unittest.cc
@@ -54,7 +54,7 @@
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 @@
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(); }
diff --git a/base/thread_unittest.cc b/base/thread_unittest.cc
index e4e74d6..39f2b2e 100644
--- a/base/thread_unittest.cc
+++ b/base/thread_unittest.cc
@@ -243,7 +243,7 @@
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, 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 @@
AsyncInvokeTest()
: int_value_(0),
invoke_started_(true, false),
- expected_thread_(NULL) {}
+ expected_thread_(nullptr) {}
int int_value_;
Event invoke_started_;
@@ -788,7 +788,7 @@
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)) {
diff --git a/base/timeutils.cc b/base/timeutils.cc
index 509b695..7fcc2f4 100644
--- a/base/timeutils.cc
+++ b/base/timeutils.cc
@@ -189,7 +189,7 @@
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);
diff --git a/base/trace_event.h b/base/trace_event.h
index 3789886..3e99374 100644
--- a/base/trace_event.h
+++ b/base/trace_event.h
@@ -817,10 +817,9 @@
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 @@
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 @@
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);
}
}
diff --git a/base/transformadapter.cc b/base/transformadapter.cc
index 8944464..1f1a2a0 100644
--- a/base/transformadapter.cc
+++ b/base/transformadapter.cc
@@ -175,7 +175,7 @@
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;
diff --git a/base/unittest_main.cc b/base/unittest_main.cc
index 3de0528..1600217 100644
--- a/base/unittest_main.cc
+++ b/base/unittest_main.cc
@@ -66,7 +66,7 @@
testing::InitGoogleTest(&argc, argv);
rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, false);
if (FLAG_help) {
- rtc::FlagList::Print(NULL, false);
+ rtc::FlagList::Print(nullptr, false);
return 0;
}
diff --git a/base/unixfilesystem.cc b/base/unixfilesystem.cc
index a011094..d0da709 100644
--- a/base/unixfilesystem.cc
+++ b/base/unixfilesystem.cc
@@ -63,10 +63,10 @@
namespace rtc {
#if !defined(WEBRTC_ANDROID) && !defined(WEBRTC_MAC)
-char* UnixFilesystem::app_temp_path_ = NULL;
+char* UnixFilesystem::app_temp_path_ = nullptr;
#else
-char* UnixFilesystem::provided_app_data_folder_ = NULL;
-char* UnixFilesystem::provided_app_temp_folder_ = NULL;
+char* UnixFilesystem::provided_app_data_folder_ = nullptr;
+char* UnixFilesystem::provided_app_temp_folder_ = nullptr;
void UnixFilesystem::SetAppDataFolder(const std::string& folder) {
delete [] provided_app_data_folder_;
@@ -126,9 +126,9 @@
FileStream *UnixFilesystem::OpenFile(const Pathname &filename,
const std::string &mode) {
FileStream *fs = new FileStream();
- if (fs && !fs->Open(filename.pathname().c_str(), mode.c_str(), NULL)) {
+ if (fs && !fs->Open(filename.pathname().c_str(), mode.c_str(), nullptr)) {
delete fs;
- fs = NULL;
+ fs = nullptr;
}
return fs;
}
@@ -157,7 +157,7 @@
bool UnixFilesystem::GetTemporaryFolder(Pathname &pathname, bool create,
const std::string *append) {
#if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
- RTC_DCHECK(provided_app_temp_folder_ != NULL);
+ RTC_DCHECK(provided_app_temp_folder_ != nullptr);
pathname.SetPathname(provided_app_temp_folder_, "");
#else
if (const char* tmpdir = getenv("TMPDIR")) {
@@ -238,8 +238,8 @@
return false;
}
- while (source->Read(buf, sizeof(buf), &len, NULL) == SR_SUCCESS)
- dest->Write(buf, len, NULL, NULL);
+ while (source->Read(buf, sizeof(buf), &len, nullptr) == SR_SUCCESS)
+ dest->Write(buf, len, nullptr, nullptr);
delete source;
delete dest;
@@ -248,7 +248,7 @@
bool UnixFilesystem::IsTemporaryPath(const Pathname& pathname) {
#if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
- RTC_DCHECK(provided_app_temp_folder_ != NULL);
+ RTC_DCHECK(provided_app_temp_folder_ != nullptr);
#endif
const char* const kTempPrefixes[] = {
@@ -315,13 +315,13 @@
bool UnixFilesystem::GetAppTempFolder(Pathname* path) {
#if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
- RTC_DCHECK(provided_app_temp_folder_ != NULL);
+ RTC_DCHECK(provided_app_temp_folder_ != nullptr);
path->SetPathname(provided_app_temp_folder_);
return true;
#else
RTC_DCHECK(!application_name_.empty());
// TODO: Consider whether we are worried about thread safety.
- if (app_temp_path_ != NULL && strlen(app_temp_path_) > 0) {
+ if (app_temp_path_ != nullptr && strlen(app_temp_path_) > 0) {
path->SetPathname(app_temp_path_);
return true;
}
@@ -348,7 +348,7 @@
char* buf = new char[size];
if (!buf) {
- return NULL;
+ return nullptr;
}
strcpyn(buf, size, str.c_str());
diff --git a/base/unixfilesystem.h b/base/unixfilesystem.h
index 8338e5c..6f90959 100644
--- a/base/unixfilesystem.h
+++ b/base/unixfilesystem.h
@@ -35,7 +35,7 @@
#endif
// Opens a file. Returns an open StreamInterface if function succeeds.
- // Otherwise, returns NULL.
+ // Otherwise, returns null.
FileStream* OpenFile(const Pathname& filename,
const std::string& mode) override;
diff --git a/base/virtualsocket_unittest.cc b/base/virtualsocket_unittest.cc
index 4ee2c75..b884748 100644
--- a/base/virtualsocket_unittest.cc
+++ b/base/virtualsocket_unittest.cc
@@ -137,10 +137,10 @@
class VirtualSocketServerTest : public testing::Test {
public:
- VirtualSocketServerTest() : ss_(new VirtualSocketServer(NULL)),
- kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
- kIPv6AnyAddress(IPAddress(in6addr_any), 0) {
- }
+ VirtualSocketServerTest()
+ : ss_(new VirtualSocketServer(nullptr)),
+ kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
+ kIPv6AnyAddress(IPAddress(in6addr_any), 0) {}
void CheckPortIncrementalization(const SocketAddress& post,
const SocketAddress& pre) {
@@ -263,7 +263,7 @@
// No pending server connections
EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
- EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+ EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_EQ(AF_UNSPEC, accept_addr.family());
// Attempt connect to listening socket
@@ -287,7 +287,7 @@
// Server has pending connection
EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
Socket* accepted = server->Accept(&accept_addr);
- EXPECT_TRUE(NULL != accepted);
+ EXPECT_TRUE(nullptr != accepted);
EXPECT_NE(accept_addr, kEmptyAddr);
EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
@@ -330,7 +330,7 @@
// No pending server connections
EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
- EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+ EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_EQ(accept_addr, nil_addr);
// Connection failed
@@ -409,7 +409,7 @@
// Server accepts connection
EXPECT_TRUE(sink.Check(server.get(), testing::SSE_READ));
std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
- ASSERT_TRUE(NULL != accepted.get());
+ ASSERT_TRUE(nullptr != accepted.get());
sink.Monitor(accepted.get());
// Client closes before connection complets
@@ -686,7 +686,7 @@
// incremental port behavior could ensure the 2 Binds result in different
// address.
void DelayTest(const SocketAddress& initial_addr) {
- time_t seed = ::time(NULL);
+ time_t seed = ::time(nullptr);
LOG(LS_VERBOSE) << "seed = " << seed;
srand(static_cast<unsigned int>(seed));
@@ -766,7 +766,7 @@
ss_->ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
Socket* accepted = server->Accept(&accept_address);
- EXPECT_TRUE(NULL != accepted);
+ EXPECT_TRUE(nullptr != accepted);
EXPECT_NE(kEmptyAddr, accept_address);
ss_->ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(client, testing::SSE_OPEN));
@@ -777,7 +777,7 @@
ss_->ProcessMessagesUntilIdle();
EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
- EXPECT_TRUE(NULL == server->Accept(&accept_address));
+ EXPECT_TRUE(nullptr == server->Accept(&accept_address));
EXPECT_EQ(accept_address, kEmptyAddr);
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
@@ -818,9 +818,7 @@
virtual void SetUp() {
Thread::Current()->set_socketserver(ss_);
}
- virtual void TearDown() {
- Thread::Current()->set_socketserver(NULL);
- }
+ virtual void TearDown() { Thread::Current()->set_socketserver(nullptr); }
VirtualSocketServer* ss_;
const SocketAddress kIPv4AnyAddress;
@@ -1096,7 +1094,7 @@
VirtualSocketServer::CreateDistribution(kTestMean[midx],
kStdDev,
kTestSamples[sidx]);
- ASSERT_TRUE(NULL != f);
+ ASSERT_TRUE(nullptr != f);
ASSERT_EQ(kTestSamples[sidx], f->size());
double sum = 0;
for (uint32_t i = 0; i < f->size(); ++i) {
diff --git a/base/virtualsocketserver.cc b/base/virtualsocketserver.cc
index d9c7eeb..57f218e 100644
--- a/base/virtualsocketserver.cc
+++ b/base/virtualsocketserver.cc
@@ -64,7 +64,7 @@
public:
Packet(const char* data, size_t size, const SocketAddress& from)
: size_(size), consumed_(0), from_(from) {
- RTC_DCHECK(NULL != data);
+ RTC_DCHECK(nullptr != data);
data_ = new char[size_];
memcpy(data_, data, size_);
}
@@ -103,7 +103,7 @@
async_(async),
state_(CS_CLOSED),
error_(0),
- listen_queue_(NULL),
+ listen_queue_(nullptr),
network_size_(0),
recv_buffer_size_(0),
bound_(false),
@@ -184,7 +184,7 @@
listen_queue_->pop_front();
}
delete listen_queue_;
- listen_queue_ = NULL;
+ listen_queue_ = nullptr;
}
// Disconnect stream sockets
if (CS_CONNECTED == state_) {
@@ -210,7 +210,7 @@
server_->msg_queue_->Clear(this, MSG_ID_CONNECT, &msgs);
}
for (MessageList::iterator it = msgs.begin(); it != msgs.end(); ++it) {
- RTC_DCHECK(NULL != it->pdata);
+ RTC_DCHECK(nullptr != it->pdata);
MessageAddress* data = static_cast<MessageAddress*>(it->pdata);
// Lookup remote side.
@@ -308,7 +308,7 @@
recv_buffer_size_ -= data_read;
if (was_full) {
VirtualSocket* sender = server_->LookupBinding(remote_addr_);
- RTC_DCHECK(NULL != sender);
+ RTC_DCHECK(nullptr != sender);
server_->SendTcp(sender);
}
}
@@ -323,16 +323,16 @@
error_ = EINVAL;
return -1;
}
- RTC_DCHECK(NULL == listen_queue_);
+ RTC_DCHECK(nullptr == listen_queue_);
listen_queue_ = new ListenQueue;
state_ = CS_CONNECTING;
return 0;
}
VirtualSocket* VirtualSocket::Accept(SocketAddress* paddr) {
- if (NULL == listen_queue_) {
+ if (nullptr == listen_queue_) {
error_ = EINVAL;
- return NULL;
+ return nullptr;
}
while (!listen_queue_->empty()) {
VirtualSocket* socket = new VirtualSocket(server_, AF_INET, type_, async_);
@@ -355,7 +355,7 @@
return socket;
}
error_ = EWOULDBLOCK;
- return NULL;
+ return nullptr;
}
int VirtualSocket::GetError() const {
@@ -393,7 +393,7 @@
void VirtualSocket::OnMessage(Message* pmsg) {
if (pmsg->message_id == MSG_ID_PACKET) {
- RTC_DCHECK(NULL != pmsg->pdata);
+ RTC_DCHECK(nullptr != pmsg->pdata);
Packet* packet = static_cast<Packet*>(pmsg->pdata);
recv_buffer_.push_back(packet);
@@ -402,9 +402,9 @@
SignalReadEvent(this);
}
} else if (pmsg->message_id == MSG_ID_CONNECT) {
- RTC_DCHECK(NULL != pmsg->pdata);
+ RTC_DCHECK(nullptr != pmsg->pdata);
MessageAddress* data = static_cast<MessageAddress*>(pmsg->pdata);
- if (listen_queue_ != NULL) {
+ if (listen_queue_ != nullptr) {
listen_queue_->push_back(data->addr);
if (async_) {
SignalReadEvent(this);
@@ -525,7 +525,7 @@
VirtualSocketServer::VirtualSocketServer(SocketServer* ss)
: server_(ss),
server_owned_(false),
- msg_queue_(NULL),
+ msg_queue_(nullptr),
stop_on_idle_(false),
next_ipv4_(kInitialNextIPv4),
next_ipv6_(kInitialNextIPv6),
@@ -670,7 +670,7 @@
int VirtualSocketServer::Bind(VirtualSocket* socket,
const SocketAddress& addr) {
- RTC_DCHECK(NULL != socket);
+ RTC_DCHECK(nullptr != socket);
// Address must be completely specified at this point
RTC_DCHECK(!IPIsUnspec(addr.ipaddr()));
RTC_DCHECK(addr.port() != 0);
@@ -683,7 +683,7 @@
}
int VirtualSocketServer::Bind(VirtualSocket* socket, SocketAddress* addr) {
- RTC_DCHECK(NULL != socket);
+ RTC_DCHECK(nullptr != socket);
if (!IPIsUnspec(addr->ipaddr())) {
addr->SetIP(addr->ipaddr().Normalized());
@@ -757,7 +757,7 @@
remote.port());
SocketAddressPair address_pair(local_normalized, remote_normalized);
ConnectionMap::iterator it = connections_->find(address_pair);
- return (connections_->end() != it) ? it->second : NULL;
+ return (connections_->end() != it) ? it->second : nullptr;
}
void VirtualSocketServer::RemoveConnection(const SocketAddress& local,
@@ -784,7 +784,7 @@
<< socket->GetLocalAddress() << " and " << remote_addr;
return -1;
}
- if (remote != NULL) {
+ if (remote != nullptr) {
SocketAddress addr = socket->GetLocalAddress();
msg_queue_->PostDelayed(RTC_FROM_HERE, delay, remote, MSG_ID_CONNECT,
new MessageAddress(addr));
diff --git a/base/virtualsocketserver.h b/base/virtualsocketserver.h
index 6782d80..3d4171b 100644
--- a/base/virtualsocketserver.h
+++ b/base/virtualsocketserver.h
@@ -213,10 +213,10 @@
uint32_t samples);
static double Evaluate(Function* f, double x);
- // NULL out our message queue if it goes away. Necessary in the case where
+ // Null out our message queue if it goes away. Necessary in the case where
// our lifetime is greater than that of the thread we are using, since we
// try to send Close messages for all connected sockets when we shutdown.
- void OnMessageQueueDestroyed() { msg_queue_ = NULL; }
+ void OnMessageQueueDestroyed() { msg_queue_ = nullptr; }
// Determine if two sockets should be able to communicate.
// We don't (currently) specify an address family for sockets; instead,
diff --git a/base/weak_ptr.cc b/base/weak_ptr.cc
index 4eef7ea..8a07a87 100644
--- a/base/weak_ptr.cc
+++ b/base/weak_ptr.cc
@@ -73,7 +73,7 @@
RTC_DCHECK(checker_.CalledSequentially());
if (flag_.get()) {
flag_->Invalidate();
- flag_ = NULL;
+ flag_ = nullptr;
}
}
diff --git a/base/win32.cc b/base/win32.cc
index cc94282..485f7a6 100644
--- a/base/win32.cc
+++ b/base/win32.cc
@@ -35,7 +35,7 @@
const char* win32_inet_ntop(int af, const void *src,
char* dst, socklen_t size) {
if (!src || !dst) {
- return NULL;
+ return nullptr;
}
switch (af) {
case AF_INET: {
@@ -45,7 +45,7 @@
return inet_ntop_v6(src, dst, size);
}
}
- return NULL;
+ return nullptr;
}
// As above, but for inet_pton. Implements inet_pton for v4 and v6.
@@ -66,7 +66,7 @@
// Outputs "dotted-quad" decimal notation.
const char* inet_ntop_v4(const void* src, char* dst, socklen_t size) {
if (size < INET_ADDRSTRLEN) {
- return NULL;
+ return nullptr;
}
const struct in_addr* as_in_addr =
reinterpret_cast<const struct in_addr*>(src);
@@ -81,7 +81,7 @@
// Helper function for inet_ntop for IPv6 addresses.
const char* inet_ntop_v6(const void* src, char* dst, socklen_t size) {
if (size < INET6_ADDRSTRLEN) {
- return NULL;
+ return nullptr;
}
const uint16_t* as_shorts = reinterpret_cast<const uint16_t*>(src);
int runpos[8];
@@ -318,7 +318,7 @@
//
void FileTimeToUnixTime(const FILETIME& ft, time_t* ut) {
- RTC_DCHECK(NULL != ut);
+ RTC_DCHECK(nullptr != ut);
// FILETIME has an earlier date base than time_t (1/1/1970), so subtract off
// the difference.
@@ -342,7 +342,7 @@
}
void UnixTimeToFileTime(const time_t& ut, FILETIME* ft) {
- RTC_DCHECK(NULL != ft);
+ RTC_DCHECK(nullptr != ft);
// FILETIME has an earlier date base than time_t (1/1/1970), so add in
// the difference.
@@ -373,9 +373,9 @@
// TODO: Write unittests
// Convert to Utf16
- int wlen = ::MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(),
- static_cast<int>(utf8.length() + 1), NULL,
- 0);
+ int wlen =
+ ::MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(),
+ static_cast<int>(utf8.length() + 1), nullptr, 0);
if (0 == wlen) {
return false;
}
@@ -388,11 +388,11 @@
// Replace forward slashes with backslashes
std::replace(wfilename, wfilename + wlen, L'/', L'\\');
// Convert to complete filename
- DWORD full_len = ::GetFullPathName(wfilename, 0, NULL, NULL);
+ DWORD full_len = ::GetFullPathName(wfilename, 0, nullptr, nullptr);
if (0 == full_len) {
return false;
}
- wchar_t* filepart = NULL;
+ wchar_t* filepart = nullptr;
wchar_t* full_filename = STACK_ARRAY(wchar_t, full_len + 6);
wchar_t* start = full_filename + 6;
if (0 == ::GetFullPathName(wfilename, full_len, start, &filepart)) {
@@ -436,9 +436,8 @@
HANDLE process = ::GetCurrentProcess(), token;
if (OpenProcessToken(process, TOKEN_QUERY | TOKEN_QUERY_SOURCE, &token)) {
DWORD size;
- if (!GetTokenInformation(token, TokenIntegrityLevel, NULL, 0, &size) &&
+ if (!GetTokenInformation(token, TokenIntegrityLevel, nullptr, 0, &size) &&
GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
-
char* buf = STACK_ARRAY(char, size);
TOKEN_MANDATORY_LABEL* til =
reinterpret_cast<TOKEN_MANDATORY_LABEL*>(buf);
diff --git a/base/win32.h b/base/win32.h
index dba9b77..22a17c5 100644
--- a/base/win32.h
+++ b/base/win32.h
@@ -48,7 +48,7 @@
inline std::wstring ToUtf16(const char* utf8, size_t len) {
int len16 = ::MultiByteToWideChar(CP_UTF8, 0, utf8, static_cast<int>(len),
- NULL, 0);
+ nullptr, 0);
wchar_t* ws = STACK_ARRAY(wchar_t, len16);
::MultiByteToWideChar(CP_UTF8, 0, utf8, static_cast<int>(len), ws, len16);
return std::wstring(ws, len16);
@@ -60,10 +60,10 @@
inline std::string ToUtf8(const wchar_t* wide, size_t len) {
int len8 = ::WideCharToMultiByte(CP_UTF8, 0, wide, static_cast<int>(len),
- NULL, 0, NULL, NULL);
+ nullptr, 0, nullptr, nullptr);
char* ns = STACK_ARRAY(char, len8);
::WideCharToMultiByte(CP_UTF8, 0, wide, static_cast<int>(len), ns, len8,
- NULL, NULL);
+ nullptr, nullptr);
return std::string(ns, len8);
}
@@ -98,21 +98,19 @@
inline bool IsWindowsVistaOrLater() {
int major;
- return (GetOsVersion(&major, NULL, NULL) && major >= kWindowsVista);
+ return (GetOsVersion(&major, nullptr, nullptr) && major >= kWindowsVista);
}
inline bool IsWindowsXpOrLater() {
int major, minor;
- return (GetOsVersion(&major, &minor, NULL) &&
- (major >= kWindowsVista ||
- (major == kWindows2000 && minor >= 1)));
+ return (GetOsVersion(&major, &minor, nullptr) &&
+ (major >= kWindowsVista || (major == kWindows2000 && minor >= 1)));
}
inline bool IsWindows8OrLater() {
int major, minor;
- return (GetOsVersion(&major, &minor, NULL) &&
- (major > kWindowsVista ||
- (major == kWindowsVista && minor >= 2)));
+ return (GetOsVersion(&major, &minor, nullptr) &&
+ (major > kWindowsVista || (major == kWindowsVista && minor >= 2)));
}
// Determine the current integrity level of the process.
diff --git a/base/win32filesystem.cc b/base/win32filesystem.cc
index 9e4ef51..4bc2218 100644
--- a/base/win32filesystem.cc
+++ b/base/win32filesystem.cc
@@ -60,15 +60,15 @@
}
}
- return (::CreateDirectory(path16.c_str(), NULL) != 0);
+ return (::CreateDirectory(path16.c_str(), nullptr) != 0);
}
FileStream *Win32Filesystem::OpenFile(const Pathname &filename,
const std::string &mode) {
FileStream *fs = new FileStream();
- if (fs && !fs->Open(filename.pathname().c_str(), mode.c_str(), NULL)) {
+ if (fs && !fs->Open(filename.pathname().c_str(), mode.c_str(), nullptr)) {
delete fs;
- fs = NULL;
+ fs = nullptr;
}
return fs;
}
@@ -105,7 +105,7 @@
return false;
pathname.clear();
pathname.SetFolder(ToUtf8(buffer));
- if (append != NULL) {
+ if (append != nullptr) {
RTC_DCHECK(!append->empty());
pathname.AppendFolder(*append);
}
@@ -210,7 +210,7 @@
bool Win32Filesystem::GetAppPathname(Pathname* path) {
TCHAR buffer[MAX_PATH + 1];
- if (0 == ::GetModuleFileName(NULL, buffer, arraysize(buffer)))
+ if (0 == ::GetModuleFileName(nullptr, buffer, arraysize(buffer)))
return false;
path->SetPathname(ToUtf8(buffer));
return true;
diff --git a/base/win32filesystem.h b/base/win32filesystem.h
index dd3caed..3ceaa20 100644
--- a/base/win32filesystem.h
+++ b/base/win32filesystem.h
@@ -17,8 +17,8 @@
class Win32Filesystem : public FilesystemInterface {
public:
- // Opens a file. Returns an open StreamInterface if function succeeds. Otherwise,
- // returns NULL.
+ // Opens a file. Returns an open StreamInterface if function succeeds.
+ // Otherwise, returns null.
virtual FileStream *OpenFile(const Pathname &filename,
const std::string &mode);
@@ -61,7 +61,7 @@
// All of the following functions set pathname and return true if successful.
// Returned paths always include a trailing backslash.
// If create is true, the path will be recursively created.
- // If append is non-NULL, it will be appended (and possibly created).
+ // If append is non-null, it will be appended (and possibly created).
virtual std::string TempFilename(const Pathname &dir, const std::string &prefix);
diff --git a/base/win32socketserver.cc b/base/win32socketserver.cc
index adf360b..3ee88db 100644
--- a/base/win32socketserver.cc
+++ b/base/win32socketserver.cc
@@ -165,7 +165,7 @@
};
void Win32Socket::EventSink::Dispose() {
- parent_ = NULL;
+ parent_ = nullptr;
if (::IsWindow(handle())) {
::DestroyWindow(handle());
} else {
@@ -227,9 +227,14 @@
/////////////////////////////////////////////////////////////////////////////
Win32Socket::Win32Socket()
- : socket_(INVALID_SOCKET), error_(0), state_(CS_CLOSED), connect_time_(0),
- closing_(false), close_error_(0), sink_(NULL), dns_(NULL) {
-}
+ : socket_(INVALID_SOCKET),
+ error_(0),
+ state_(CS_CLOSED),
+ connect_time_(0),
+ closing_(false),
+ close_error_(0),
+ sink_(nullptr),
+ dns_(nullptr) {}
Win32Socket::~Win32Socket() {
Close();
@@ -238,7 +243,7 @@
bool Win32Socket::CreateT(int family, int type) {
Close();
int proto = (SOCK_DGRAM == type) ? IPPROTO_UDP : IPPROTO_TCP;
- socket_ = ::WSASocket(family, type, proto, NULL, NULL, 0);
+ socket_ = ::WSASocket(family, type, proto, nullptr, 0, 0);
if (socket_ == INVALID_SOCKET) {
UpdateLastError();
return false;
@@ -487,14 +492,14 @@
SOCKET s = ::accept(socket_, reinterpret_cast<sockaddr*>(&saddr), &addr_len);
UpdateLastError();
if (s == INVALID_SOCKET)
- return NULL;
+ return nullptr;
if (out_addr)
SocketAddressFromSockAddrStorage(saddr, out_addr);
Win32Socket* socket = new Win32Socket;
if (0 == socket->Attach(s))
return socket;
delete socket;
- return NULL;
+ return nullptr;
}
int Win32Socket::Close() {
@@ -509,11 +514,11 @@
if (dns_) {
WSACancelAsyncRequest(dns_->handle);
delete dns_;
- dns_ = NULL;
+ dns_ = nullptr;
}
if (sink_) {
sink_->Dispose();
- sink_ = NULL;
+ sink_ = nullptr;
}
addr_.Clear();
state_ = CS_CLOSED;
@@ -552,17 +557,17 @@
}
void Win32Socket::CreateSink() {
- RTC_DCHECK(NULL == sink_);
+ RTC_DCHECK(nullptr == sink_);
// Create window
sink_ = new EventSink(this);
- sink_->Create(NULL, L"EventSink", 0, 0, 0, 0, 10, 10);
+ sink_->Create(nullptr, L"EventSink", 0, 0, 0, 0, 10, 10);
}
bool Win32Socket::SetAsync(int events) {
- if (NULL == sink_) {
+ if (nullptr == sink_) {
CreateSink();
- RTC_DCHECK(NULL != sink_);
+ RTC_DCHECK(nullptr != sink_);
}
// start the async select
@@ -709,7 +714,7 @@
SignalCloseEvent(this, error_);
} else {
delete dns_;
- dns_ = NULL;
+ dns_ = nullptr;
}
}
@@ -725,16 +730,16 @@
: message_queue_(message_queue),
wnd_(this),
posted_(false),
- hdlg_(NULL) {
+ hdlg_(nullptr) {
if (s_wm_wakeup_id == 0)
s_wm_wakeup_id = RegisterWindowMessage(L"WM_WAKEUP");
- if (!wnd_.Create(NULL, kWindowName, 0, 0, 0, 0, 0, 0)) {
+ if (!wnd_.Create(nullptr, kWindowName, 0, 0, 0, 0, 0, 0)) {
LOG_GLE(LS_ERROR) << "Failed to create message window.";
}
}
Win32SocketServer::~Win32SocketServer() {
- if (wnd_.handle() != NULL) {
+ if (wnd_.handle() != nullptr) {
KillTimer(wnd_.handle(), 1);
wnd_.Destroy();
}
@@ -758,7 +763,7 @@
return socket;
}
delete socket;
- return NULL;
+ return nullptr;
}
void Win32SocketServer::SetMessageQueue(MessageQueue* queue) {
@@ -773,12 +778,12 @@
uint32_t start = Time();
do {
MSG msg;
- SetTimer(wnd_.handle(), 0, cms, NULL);
+ SetTimer(wnd_.handle(), 0, cms, nullptr);
// Get the next available message. If we have a modeless dialog, give
// give the message to IsDialogMessage, which will return true if it
// was a message for the dialog that it handled internally.
// Otherwise, dispatch as usual via Translate/DispatchMessage.
- b = GetMessage(&msg, NULL, 0, 0);
+ b = GetMessage(&msg, nullptr, 0, 0);
if (b == -1) {
LOG_GLE(LS_ERROR) << "GetMessage failed.";
return false;
@@ -794,7 +799,7 @@
// Sit and wait forever for a WakeUp. This is the Thread::Send case.
RTC_DCHECK(cms == -1);
MSG msg;
- b = GetMessage(&msg, NULL, s_wm_wakeup_id, s_wm_wakeup_id);
+ b = GetMessage(&msg, nullptr, s_wm_wakeup_id, s_wm_wakeup_id);
{
CritScope scope(&cs_);
posted_ = false;
@@ -844,7 +849,7 @@
if (delay == -1) {
KillTimer(wnd_.handle(), 1);
} else {
- SetTimer(wnd_.handle(), 1, delay, NULL);
+ SetTimer(wnd_.handle(), 1, delay, nullptr);
}
}
diff --git a/base/win32socketserver.h b/base/win32socketserver.h
index 28bee6a..a9a53c3 100644
--- a/base/win32socketserver.h
+++ b/base/win32socketserver.h
@@ -143,7 +143,7 @@
}
virtual ~Win32Thread() {
Stop();
- set_socketserver(NULL);
+ set_socketserver(nullptr);
}
virtual void Run() {
id_ = GetCurrentThreadId();
diff --git a/base/win32socketserver_unittest.cc b/base/win32socketserver_unittest.cc
index f40fd5f..94d96da 100644
--- a/base/win32socketserver_unittest.cc
+++ b/base/win32socketserver_unittest.cc
@@ -16,7 +16,7 @@
// Test that Win32SocketServer::Wait works as expected.
TEST(Win32SocketServerTest, TestWait) {
- Win32SocketServer server(NULL);
+ Win32SocketServer server(nullptr);
uint32_t start = Time();
server.Wait(1000, true);
EXPECT_GE(TimeSince(start), 1000);
@@ -24,12 +24,12 @@
// Test that Win32Socket::Pump does not touch general Windows messages.
TEST(Win32SocketServerTest, TestPump) {
- Win32SocketServer server(NULL);
+ Win32SocketServer server(nullptr);
SocketServerScope scope(&server);
- EXPECT_EQ(TRUE, PostMessage(NULL, WM_USER, 999, 0));
+ EXPECT_EQ(TRUE, PostMessage(nullptr, WM_USER, 999, 0));
server.Pump();
MSG msg;
- EXPECT_EQ(TRUE, PeekMessage(&msg, NULL, WM_USER, 0, PM_REMOVE));
+ EXPECT_EQ(TRUE, PeekMessage(&msg, nullptr, WM_USER, 0, PM_REMOVE));
EXPECT_EQ(static_cast<UINT>(WM_USER), msg.message);
EXPECT_EQ(999u, msg.wParam);
}
@@ -37,7 +37,7 @@
// Test that Win32Socket passes all the generic Socket tests.
class Win32SocketTest : public SocketTest {
protected:
- Win32SocketTest() : server_(NULL), scope_(&server_) {}
+ Win32SocketTest() : server_(nullptr), scope_(&server_) {}
Win32SocketServer server_;
SocketServerScope scope_;
};
diff --git a/base/win32window.cc b/base/win32window.cc
index 9abbc86..0e02eef 100644
--- a/base/win32window.cc
+++ b/base/win32window.cc
@@ -19,14 +19,13 @@
///////////////////////////////////////////////////////////////////////////////
static const wchar_t kWindowBaseClassName[] = L"WindowBaseClass";
-HINSTANCE Win32Window::instance_ = NULL;
+HINSTANCE Win32Window::instance_ = nullptr;
ATOM Win32Window::window_class_ = 0;
-Win32Window::Win32Window() : wnd_(NULL) {
-}
+Win32Window::Win32Window() : wnd_(nullptr) {}
Win32Window::~Win32Window() {
- RTC_DCHECK(NULL == wnd_);
+ RTC_DCHECK(nullptr == wnd_);
}
bool Win32Window::Create(HWND parent, const wchar_t* title, DWORD style,
@@ -58,9 +57,9 @@
return false;
}
}
- wnd_ = ::CreateWindowEx(exstyle, kWindowBaseClassName, title, style,
- x, y, cx, cy, parent, NULL, instance_, this);
- return (NULL != wnd_);
+ wnd_ = ::CreateWindowEx(exstyle, kWindowBaseClassName, title, style, x, y, cx,
+ cy, parent, nullptr, instance_, this);
+ return (nullptr != wnd_);
}
void Win32Window::Destroy() {
@@ -109,7 +108,7 @@
}
if (WM_NCDESTROY == uMsg) {
::SetWindowLongPtr(hwnd, GWLP_USERDATA, NULL);
- that->wnd_ = NULL;
+ that->wnd_ = nullptr;
that->OnNcDestroy();
}
if (handled) {
diff --git a/base/win32window_unittest.cc b/base/win32window_unittest.cc
index 3738a7f..f814752 100644
--- a/base/win32window_unittest.cc
+++ b/base/win32window_unittest.cc
@@ -39,16 +39,16 @@
TEST(Win32WindowTest, Basics) {
TestWindow wnd;
- EXPECT_TRUE(wnd.handle() == NULL);
+ EXPECT_TRUE(wnd.handle() == nullptr);
EXPECT_FALSE(wnd.destroyed());
EXPECT_TRUE(wnd.Create(0, L"Test", 0, 0, 0, 0, 100, 100));
- EXPECT_TRUE(wnd.handle() != NULL);
+ EXPECT_TRUE(wnd.handle() != nullptr);
EXPECT_EQ(kDummyResult, ::SendMessage(wnd.handle(), WM_USER, 1, 2));
EXPECT_EQ(static_cast<UINT>(WM_USER), wnd.msg().message);
EXPECT_EQ(1u, wnd.msg().wParam);
EXPECT_EQ(2l, wnd.msg().lParam);
wnd.Destroy();
- EXPECT_TRUE(wnd.handle() == NULL);
+ EXPECT_TRUE(wnd.handle() == nullptr);
EXPECT_TRUE(wnd.destroyed());
}
@@ -56,10 +56,10 @@
TestWindow wnd1, wnd2;
EXPECT_TRUE(wnd1.Create(0, L"Test", 0, 0, 0, 0, 100, 100));
EXPECT_TRUE(wnd2.Create(0, L"Test", 0, 0, 0, 0, 100, 100));
- EXPECT_TRUE(wnd1.handle() != NULL);
- EXPECT_TRUE(wnd2.handle() != NULL);
+ EXPECT_TRUE(wnd1.handle() != nullptr);
+ EXPECT_TRUE(wnd2.handle() != nullptr);
wnd1.Destroy();
wnd2.Destroy();
- EXPECT_TRUE(wnd2.handle() == NULL);
- EXPECT_TRUE(wnd1.handle() == NULL);
+ EXPECT_TRUE(wnd2.handle() == nullptr);
+ EXPECT_TRUE(wnd1.handle() == nullptr);
}
diff --git a/base/winping.cc b/base/winping.cc
index 5545076..21f4fa3 100644
--- a/base/winping.cc
+++ b/base/winping.cc
@@ -249,7 +249,7 @@
src.sin6_family = AF_INET6;
dst.sin6_family = AF_INET6;
dst.sin6_addr = ip.ipv6_address();
- result = send6_(hping6_, NULL, NULL, NULL, &src, &dst, data_,
+ result = send6_(hping6_, nullptr, nullptr, nullptr, &src, &dst, data_,
int16_t(data_size), &ipopt, reply_, reply_size, timeout);
}
if (result == 0) {
@@ -330,7 +330,7 @@
// RequestSize - The number of bytes in the request data buffer.
//
// RequestOptions - Pointer to the IP header options for the request.
-// May be NULL.
+// May be null.
//
// ReplyBuffer - A buffer to hold any replies to the request.
// On return, the buffer will contain an array of
