diff --git a/webrtc/base/asyncinvoker-inl.h b/webrtc/base/asyncinvoker-inl.h
index d172eee0a6..bce68d94d4 100644
--- a/webrtc/base/asyncinvoker-inl.h
+++ b/webrtc/base/asyncinvoker-inl.h
@@ -68,7 +68,7 @@ class NotifyingAsyncClosureBase : public AsyncClosure,
     CritScope cs(&crit_);
     callback_ = callback;
   }
-  bool CallbackCanceled() const { return calling_thread_ == NULL; }
+  bool CallbackCanceled() const { return calling_thread_ == nullptr; }
 
  private:
   Location callback_posted_from_;
diff --git a/webrtc/base/asyncinvoker.cc b/webrtc/base/asyncinvoker.cc
index aa65499c96..a143e25f19 100644
--- a/webrtc/base/asyncinvoker.cc
+++ b/webrtc/base/asyncinvoker.cc
@@ -147,8 +147,8 @@ void NotifyingAsyncClosureBase::CancelCallback() {
   // destructor of the dying object here by waiting until the callback
   // is done triggering.
   CritScope cs(&crit_);
-  // calling_thread_ == NULL means do not trigger the callback.
-  calling_thread_ = NULL;
+  // calling_thread_ == nullptr means do not trigger the callback.
+  calling_thread_ = nullptr;
 }
 
 }  // namespace rtc
diff --git a/webrtc/base/asyncpacketsocket.h b/webrtc/base/asyncpacketsocket.h
index f18839ed37..a540947951 100644
--- a/webrtc/base/asyncpacketsocket.h
+++ b/webrtc/base/asyncpacketsocket.h
@@ -78,7 +78,7 @@ class AsyncPacketSocket : public sigslot::has_slots<> {
   AsyncPacketSocket();
   ~AsyncPacketSocket() override;
 
-  // Returns current local address. Address may be set to NULL if the
+  // Returns current local address. Address may be set to null if the
   // socket is not bound yet (GetState() returns STATE_BINDING).
   virtual SocketAddress GetLocalAddress() const = 0;
 
diff --git a/webrtc/base/asyncsocket.cc b/webrtc/base/asyncsocket.cc
index 873badc818..6c41596499 100644
--- a/webrtc/base/asyncsocket.cc
+++ b/webrtc/base/asyncsocket.cc
@@ -19,7 +19,7 @@ AsyncSocket::AsyncSocket() {
 AsyncSocket::~AsyncSocket() {
 }
 
-AsyncSocketAdapter::AsyncSocketAdapter(AsyncSocket* socket) : socket_(NULL) {
+AsyncSocketAdapter::AsyncSocketAdapter(AsyncSocket* socket) : socket_(nullptr) {
   Attach(socket);
 }
 
diff --git a/webrtc/base/asyncsocket.h b/webrtc/base/asyncsocket.h
index bf6c88aa39..40cf1b5bd1 100644
--- a/webrtc/base/asyncsocket.h
+++ b/webrtc/base/asyncsocket.h
@@ -42,7 +42,7 @@ class AsyncSocket : public Socket {
 
 class AsyncSocketAdapter : public AsyncSocket, public sigslot::has_slots<> {
  public:
-  // The adapted socket may explicitly be NULL, and later assigned using Attach.
+  // The adapted socket may explicitly be null, and later assigned using Attach.
   // However, subclasses which support detached mode must override any methods
   // that will be called during the detached period (usually GetState()), to
   // avoid dereferencing a null pointer.
diff --git a/webrtc/base/asynctcpsocket.cc b/webrtc/base/asynctcpsocket.cc
index 0b92b388e9..658541cdde 100644
--- a/webrtc/base/asynctcpsocket.cc
+++ b/webrtc/base/asynctcpsocket.cc
@@ -47,11 +47,11 @@ AsyncSocket* AsyncTCPSocketBase::ConnectSocket(
   std::unique_ptr<rtc::AsyncSocket> owned_socket(socket);
   if (socket->Bind(bind_address) < 0) {
     LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
-    return NULL;
+    return nullptr;
   }
   if (socket->Connect(remote_address) < 0) {
     LOG(LS_ERROR) << "Connect() failed with error " << socket->GetError();
-    return NULL;
+    return nullptr;
   }
   return owned_socket.release();
 }
@@ -67,7 +67,7 @@ AsyncTCPSocketBase::AsyncTCPSocketBase(AsyncSocket* socket, bool listen,
     inbuf_.EnsureCapacity(kMinimumRecvSize);
   }
 
-  RTC_DCHECK(socket_.get() != NULL);
+  RTC_DCHECK(socket_.get() != nullptr);
   socket_->SignalConnectEvent.connect(
       this, &AsyncTCPSocketBase::OnConnectEvent);
   socket_->SignalReadEvent.connect(this, &AsyncTCPSocketBase::OnReadEvent);
@@ -260,7 +260,7 @@ void AsyncTCPSocketBase::OnCloseEvent(AsyncSocket* socket, int error) {
 
 // AsyncTCPSocket
 // Binds and connects |socket| and creates AsyncTCPSocket for
-// it. Takes ownership of |socket|. Returns NULL if bind() or
+// it. Takes ownership of |socket|. Returns null if bind() or
 // connect() fail (|socket| is destroyed in that case).
 AsyncTCPSocket* AsyncTCPSocket::Create(
     AsyncSocket* socket,
diff --git a/webrtc/base/asynctcpsocket.h b/webrtc/base/asynctcpsocket.h
index cd5c104d88..2e4ff9aaa7 100644
--- a/webrtc/base/asynctcpsocket.h
+++ b/webrtc/base/asynctcpsocket.h
@@ -51,7 +51,7 @@ class AsyncTCPSocketBase : public AsyncPacketSocket {
 
  protected:
   // Binds and connects |socket| and creates AsyncTCPSocket for
-  // it. Takes ownership of |socket|. Returns NULL if bind() or
+  // it. Takes ownership of |socket|. Returns null if bind() or
   // connect() fail (|socket| is destroyed in that case).
   static AsyncSocket* ConnectSocket(AsyncSocket* socket,
                                     const SocketAddress& bind_address,
@@ -85,7 +85,7 @@ class AsyncTCPSocketBase : public AsyncPacketSocket {
 class AsyncTCPSocket : public AsyncTCPSocketBase {
  public:
   // Binds and connects |socket| and creates AsyncTCPSocket for
-  // it. Takes ownership of |socket|. Returns NULL if bind() or
+  // it. Takes ownership of |socket|. Returns null if bind() or
   // connect() fail (|socket| is destroyed in that case).
   static AsyncTCPSocket* Create(AsyncSocket* socket,
                                 const SocketAddress& bind_address,
diff --git a/webrtc/base/asyncudpsocket.cc b/webrtc/base/asyncudpsocket.cc
index 3ce629cc0f..0bccb73836 100644
--- a/webrtc/base/asyncudpsocket.cc
+++ b/webrtc/base/asyncudpsocket.cc
@@ -22,7 +22,7 @@ AsyncUDPSocket* AsyncUDPSocket::Create(
   std::unique_ptr<AsyncSocket> owned_socket(socket);
   if (socket->Bind(bind_address) < 0) {
     LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
-    return NULL;
+    return nullptr;
   }
   return new AsyncUDPSocket(owned_socket.release());
 }
@@ -32,7 +32,7 @@ AsyncUDPSocket* AsyncUDPSocket::Create(SocketFactory* factory,
   AsyncSocket* socket =
       factory->CreateAsyncSocket(bind_address.family(), SOCK_DGRAM);
   if (!socket)
-    return NULL;
+    return nullptr;
   return Create(socket, bind_address);
 }
 
diff --git a/webrtc/base/asyncudpsocket.h b/webrtc/base/asyncudpsocket.h
index aa6a9042b4..e5535e0273 100644
--- a/webrtc/base/asyncudpsocket.h
+++ b/webrtc/base/asyncudpsocket.h
@@ -23,7 +23,7 @@ namespace rtc {
 class AsyncUDPSocket : public AsyncPacketSocket {
  public:
   // Binds |socket| and creates AsyncUDPSocket for it. Takes ownership
-  // of |socket|. Returns NULL if bind() fails (|socket| is destroyed
+  // of |socket|. Returns null if bind() fails (|socket| is destroyed
   // in that case).
   static AsyncUDPSocket* Create(AsyncSocket* socket,
                                 const SocketAddress& bind_address);
diff --git a/webrtc/base/base64.cc b/webrtc/base/base64.cc
index 8fa1c818fa..43b63257a6 100644
--- a/webrtc/base/base64.cc
+++ b/webrtc/base/base64.cc
@@ -74,7 +74,7 @@ bool Base64::IsBase64Char(char ch) {
 }
 
 bool Base64::GetNextBase64Char(char ch, char* next_ch) {
-  if (next_ch == NULL) {
+  if (next_ch == nullptr) {
     return false;
   }
   const char* p = strchr(Base64Table, ch);
@@ -96,7 +96,7 @@ bool Base64::IsBase64Encoded(const std::string& str) {
 void Base64::EncodeFromArray(const void* data,
                              size_t len,
                              std::string* result) {
-  RTC_DCHECK(NULL != result);
+  RTC_DCHECK(nullptr != result);
   result->clear();
   result->resize(((len + 2) / 3) * 4);
   const unsigned char* byte_data = static_cast<const unsigned char*>(data);
@@ -224,7 +224,7 @@ bool Base64::DecodeFromArrayTemplate(const char* data,
                                      DecodeFlags flags,
                                      T* result,
                                      size_t* data_used) {
-  RTC_DCHECK(NULL != result);
+  RTC_DCHECK(nullptr != result);
   RTC_DCHECK(flags <= (DO_PARSE_MASK | DO_PAD_MASK | DO_TERM_MASK));
 
   const DecodeFlags parse_flags = flags & DO_PARSE_MASK;
diff --git a/webrtc/base/base64.h b/webrtc/base/base64.h
index 903e77e5f9..eba3cc0d1d 100644
--- a/webrtc/base/base64.h
+++ b/webrtc/base/base64.h
@@ -83,7 +83,7 @@ class Base64 {
   }
   static inline std::string Decode(const std::string& data, DecodeFlags flags) {
     std::string result;
-    DecodeFromArray(data.data(), data.size(), flags, &result, NULL);
+    DecodeFromArray(data.data(), data.size(), flags, &result, nullptr);
     return result;
   }
   static inline bool Decode(const std::string& data,
diff --git a/webrtc/base/base64_unittest.cc b/webrtc/base/base64_unittest.cc
index 96bc69582e..6bfba7949a 100644
--- a/webrtc/base/base64_unittest.cc
+++ b/webrtc/base/base64_unittest.cc
@@ -339,14 +339,14 @@ size_t Base64Escape(const unsigned char *src, size_t szsrc, char *dest,
 size_t Base64Unescape(const char *src, size_t szsrc, char *dest,
                       size_t szdest) {
   std::string unescaped;
-  EXPECT_TRUE(Base64::DecodeFromArray(src, szsrc, Base64::DO_LAX, &unescaped,
-                                      NULL));
+  EXPECT_TRUE(
+      Base64::DecodeFromArray(src, szsrc, Base64::DO_LAX, &unescaped, nullptr));
   memcpy(dest, unescaped.data(), min(unescaped.size(), szdest));
   return unescaped.size();
 }
 
 size_t Base64Unescape(const char *src, size_t szsrc, std::string *s) {
-  EXPECT_TRUE(Base64::DecodeFromArray(src, szsrc, Base64::DO_LAX, s, NULL));
+  EXPECT_TRUE(Base64::DecodeFromArray(src, szsrc, Base64::DO_LAX, s, nullptr));
   return s->size();
 }
 
@@ -995,5 +995,5 @@ TEST(Base64, GetNextBase64Char) {
   EXPECT_TRUE(Base64::GetNextBase64Char('/', &next_char));
   EXPECT_EQ('A', next_char);
   EXPECT_FALSE(Base64::GetNextBase64Char('&', &next_char));
-  EXPECT_FALSE(Base64::GetNextBase64Char('Z', NULL));
+  EXPECT_FALSE(Base64::GetNextBase64Char('Z', nullptr));
 }
diff --git a/webrtc/base/bitbuffer.cc b/webrtc/base/bitbuffer.cc
index fc8a899ad6..4ea2b155a1 100644
--- a/webrtc/base/bitbuffer.cc
+++ b/webrtc/base/bitbuffer.cc
@@ -202,8 +202,8 @@ bool BitBuffer::ReadSignedExponentialGolomb(int32_t* val) {
 
 void BitBuffer::GetCurrentOffset(
     size_t* out_byte_offset, size_t* out_bit_offset) {
-  RTC_CHECK(out_byte_offset != NULL);
-  RTC_CHECK(out_bit_offset != NULL);
+  RTC_CHECK(out_byte_offset != nullptr);
+  RTC_CHECK(out_bit_offset != nullptr);
   *out_byte_offset = byte_offset_;
   *out_bit_offset = bit_offset_;
 }
diff --git a/webrtc/base/bitbuffer_unittest.cc b/webrtc/base/bitbuffer_unittest.cc
index aa9a1e741c..16142995f2 100644
--- a/webrtc/base/bitbuffer_unittest.cc
+++ b/webrtc/base/bitbuffer_unittest.cc
@@ -169,8 +169,8 @@ TEST(BitBufferTest, SetOffsetValues) {
   // nicely.
 #if GTEST_HAS_DEATH_TEST
 #if !defined(WEBRTC_ANDROID)
-  // Passing a NULL out parameter is death.
-  EXPECT_DEATH(buffer.GetCurrentOffset(&byte_offset, NULL), "");
+  // Passing a null out parameter is death.
+  EXPECT_DEATH(buffer.GetCurrentOffset(&byte_offset, nullptr), "");
 #endif
 #endif
 }
diff --git a/webrtc/base/bytebuffer.cc b/webrtc/base/bytebuffer.cc
index 317b6f383a..859c123f02 100644
--- a/webrtc/base/bytebuffer.cc
+++ b/webrtc/base/bytebuffer.cc
@@ -23,12 +23,12 @@ static const int DEFAULT_SIZE = 4096;
 
 ByteBufferWriter::ByteBufferWriter()
     : ByteBuffer(ORDER_NETWORK) {
-  Construct(NULL, DEFAULT_SIZE);
+  Construct(nullptr, DEFAULT_SIZE);
 }
 
 ByteBufferWriter::ByteBufferWriter(ByteOrder byte_order)
     : ByteBuffer(byte_order) {
-  Construct(NULL, DEFAULT_SIZE);
+  Construct(nullptr, DEFAULT_SIZE);
 }
 
 ByteBufferWriter::ByteBufferWriter(const char* bytes, size_t len)
diff --git a/webrtc/base/checks.cc b/webrtc/base/checks.cc
index 6aaaf9ff83..32c2f58373 100644
--- a/webrtc/base/checks.cc
+++ b/webrtc/base/checks.cc
@@ -67,7 +67,7 @@ void DumpBacktrace() {
   PrintError("\n==== C stack trace ===============================\n\n");
   if (size == 0) {
     PrintError("(empty)\n");
-  } else if (symbols == NULL) {
+  } else if (symbols == nullptr) {
     PrintError("(no symbols)\n");
   } else {
     for (int i = 1; i < size; ++i) {
@@ -76,8 +76,9 @@ void DumpBacktrace() {
         PrintError("%2d: ", i);
         int status;
         size_t length;
-        char* demangled = abi::__cxa_demangle(mangled, NULL, &length, &status);
-        PrintError("%s\n", demangled != NULL ? demangled : mangled);
+        char* demangled =
+            abi::__cxa_demangle(mangled, nullptr, &length, &status);
+        PrintError("%s\n", demangled != nullptr ? demangled : mangled);
         free(demangled);
       } else {
         // If parsing failed, at least print the unparsed symbol.
diff --git a/webrtc/base/checks.h b/webrtc/base/checks.h
index e165741b85..c15a08c2c5 100644
--- a/webrtc/base/checks.h
+++ b/webrtc/base/checks.h
@@ -163,13 +163,13 @@ std::string* MakeCheckOpString<std::string, std::string>(
   inline std::string* Check##name##Impl(const t1& v1, const t2& v2,          \
                                         const char* names) {                 \
     if (rtc::safe_cmp::name(v1, v2))                                         \
-      return NULL;                                                           \
+      return nullptr;                                                        \
     else                                                                     \
       return rtc::MakeCheckOpString(v1, v2, names);                          \
   }                                                                          \
   inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
     if (rtc::safe_cmp::name(v1, v2))                                         \
-      return NULL;                                                           \
+      return nullptr;                                                        \
     else                                                                     \
       return rtc::MakeCheckOpString(v1, v2, names);                          \
   }
diff --git a/webrtc/base/event.cc b/webrtc/base/event.cc
index 4b348f63a1..27506b3269 100644
--- a/webrtc/base/event.cc
+++ b/webrtc/base/event.cc
@@ -27,10 +27,9 @@ namespace rtc {
 #if defined(WEBRTC_WIN)
 
 Event::Event(bool manual_reset, bool initially_signaled) {
-  event_handle_ = ::CreateEvent(NULL,                 // Security attributes.
-                                manual_reset,
-                                initially_signaled,
-                                NULL);                // Name.
+  event_handle_ = ::CreateEvent(nullptr,  // Security attributes.
+                                manual_reset, initially_signaled,
+                                nullptr);  // Name.
   RTC_CHECK(event_handle_);
 }
 
@@ -56,8 +55,8 @@ bool Event::Wait(int milliseconds) {
 Event::Event(bool manual_reset, bool initially_signaled)
     : is_manual_reset_(manual_reset),
       event_status_(initially_signaled) {
-  RTC_CHECK(pthread_mutex_init(&event_mutex_, NULL) == 0);
-  RTC_CHECK(pthread_cond_init(&event_cond_, NULL) == 0);
+  RTC_CHECK(pthread_mutex_init(&event_mutex_, nullptr) == 0);
+  RTC_CHECK(pthread_cond_init(&event_cond_, nullptr) == 0);
 }
 
 Event::~Event() {
@@ -93,7 +92,7 @@ bool Event::Wait(int milliseconds) {
     ts.tv_nsec = (milliseconds % 1000) * 1000000;
 #else
     struct timeval tv;
-    gettimeofday(&tv, NULL);
+    gettimeofday(&tv, nullptr);
 
     ts.tv_sec = tv.tv_sec + (milliseconds / 1000);
     ts.tv_nsec = tv.tv_usec * 1000 + (milliseconds % 1000) * 1000000;
diff --git a/webrtc/base/event_tracer_unittest.cc b/webrtc/base/event_tracer_unittest.cc
index ec474bdd72..a16c0ef692 100644
--- a/webrtc/base/event_tracer_unittest.cc
+++ b/webrtc/base/event_tracer_unittest.cc
@@ -32,7 +32,7 @@ class TestStatistics {
   int Count() const { return events_logged_; }
 
   static TestStatistics* Get() {
-    static TestStatistics* test_stats = NULL;
+    static TestStatistics* test_stats = nullptr;
     if (!test_stats)
       test_stats = new TestStatistics();
     return test_stats;
diff --git a/webrtc/base/fileutils.cc b/webrtc/base/fileutils.cc
index a883995054..ac21c18bcd 100644
--- a/webrtc/base/fileutils.cc
+++ b/webrtc/base/fileutils.cc
@@ -40,7 +40,8 @@ DirectoryIterator::DirectoryIterator()
 #ifdef WEBRTC_WIN
     : handle_(INVALID_HANDLE_VALUE) {
 #else
-    : dir_(NULL), dirent_(NULL) {
+    : dir_(nullptr),
+      dirent_(nullptr){
 #endif
 }
 
@@ -68,13 +69,13 @@ bool DirectoryIterator::Iterate(const Pathname &dir) {
   if (handle_ == INVALID_HANDLE_VALUE)
     return false;
 #else
-  if (dir_ != NULL)
+  if (dir_ != nullptr)
     closedir(dir_);
   dir_ = ::opendir(directory_.c_str());
-  if (dir_ == NULL)
+  if (dir_ == nullptr)
     return false;
   dirent_ = readdir(dir_);
-  if (dirent_ == NULL)
+  if (dirent_ == nullptr)
     return false;
 
   if (::stat(std::string(directory_ + Name()).c_str(), &stat_) != 0)
@@ -90,7 +91,7 @@ bool DirectoryIterator::Next() {
   return ::FindNextFile(handle_, &data_) == TRUE;
 #else
   dirent_ = ::readdir(dir_);
-  if (dirent_ == NULL)
+  if (dirent_ == nullptr)
     return false;
 
   return ::stat(std::string(directory_ + Name()).c_str(), &stat_) == 0;
@@ -116,7 +117,7 @@ std::string DirectoryIterator::Name() const {
 #endif
 }
 
-FilesystemInterface* Filesystem::default_filesystem_ = NULL;
+FilesystemInterface* Filesystem::default_filesystem_ = nullptr;
 
 FilesystemInterface *Filesystem::EnsureDefaultFilesystem() {
   if (!default_filesystem_) {
diff --git a/webrtc/base/fileutils.h b/webrtc/base/fileutils.h
index 8b090990e1..8f6ec521b2 100644
--- a/webrtc/base/fileutils.h
+++ b/webrtc/base/fileutils.h
@@ -85,7 +85,7 @@ class FilesystemInterface {
   virtual DirectoryIterator* IterateDirectory();
 
   // Opens a file. Returns an open StreamInterface if function succeeds.
-  // Otherwise, returns NULL.
+  // Otherwise, returns null.
   // TODO: Add an error param to indicate failure reason, similar to
   // FileStream::Open
   virtual FileStream *OpenFile(const Pathname &filename,
diff --git a/webrtc/base/fileutils_unittest.cc b/webrtc/base/fileutils_unittest.cc
index 068d60e3ac..a4e28507b8 100644
--- a/webrtc/base/fileutils_unittest.cc
+++ b/webrtc/base/fileutils_unittest.cc
@@ -27,13 +27,13 @@ namespace rtc {
 // Make sure we can get a temp folder for the later tests.
 TEST(MAYBE_FilesystemTest, GetTemporaryFolder) {
   Pathname path;
-  EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, NULL));
+  EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, nullptr));
 }
 
 // Test creating a temp file, reading it back in, and deleting it.
 TEST(MAYBE_FilesystemTest, TestOpenFile) {
   Pathname path;
-  EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, NULL));
+  EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, nullptr));
   path.SetPathname(Filesystem::TempFilename(path, "ut"));
 
   FileStream* fs;
@@ -41,16 +41,16 @@ TEST(MAYBE_FilesystemTest, TestOpenFile) {
   size_t bytes;
 
   fs = Filesystem::OpenFile(path, "wb");
-  ASSERT_TRUE(fs != NULL);
-  EXPECT_EQ(SR_SUCCESS, fs->Write("test", 4, &bytes, NULL));
+  ASSERT_TRUE(fs != nullptr);
+  EXPECT_EQ(SR_SUCCESS, fs->Write("test", 4, &bytes, nullptr));
   EXPECT_EQ(4U, bytes);
   delete fs;
 
   EXPECT_TRUE(Filesystem::IsFile(path));
 
   fs = Filesystem::OpenFile(path, "rb");
-  ASSERT_TRUE(fs != NULL);
-  EXPECT_EQ(SR_SUCCESS, fs->Read(buf, sizeof(buf), &bytes, NULL));
+  ASSERT_TRUE(fs != nullptr);
+  EXPECT_EQ(SR_SUCCESS, fs->Read(buf, sizeof(buf), &bytes, nullptr));
   EXPECT_EQ(4U, bytes);
   delete fs;
 
@@ -61,13 +61,13 @@ TEST(MAYBE_FilesystemTest, TestOpenFile) {
 // Test opening a non-existent file.
 TEST(MAYBE_FilesystemTest, TestOpenBadFile) {
   Pathname path;
-  EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, NULL));
+  EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, nullptr));
   path.SetFilename("not an actual file");
 
   EXPECT_FALSE(Filesystem::IsFile(path));
 
   FileStream* fs = Filesystem::OpenFile(path, "rb");
-  EXPECT_FALSE(fs != NULL);
+  EXPECT_FALSE(fs != nullptr);
 }
 
 }  // namespace rtc
diff --git a/webrtc/base/firewallsocketserver.cc b/webrtc/base/firewallsocketserver.cc
index 92ac88f97d..30e5c3bfaa 100644
--- a/webrtc/base/firewallsocketserver.cc
+++ b/webrtc/base/firewallsocketserver.cc
@@ -121,7 +121,7 @@ FirewallSocketServer::~FirewallSocketServer() {
 
   if (server_ && should_delete_server_) {
     delete server_;
-    server_ = NULL;
+    server_ = nullptr;
   }
 }
 
@@ -210,7 +210,7 @@ AsyncSocket* FirewallSocketServer::WrapSocket(AsyncSocket* sock, int type) {
       (type == SOCK_DGRAM && !udp_sockets_enabled_)) {
     LOG(LS_VERBOSE) << "FirewallSocketServer socket creation denied";
     delete sock;
-    return NULL;
+    return nullptr;
   }
   return new FirewallSocket(this, sock, type);
 }
diff --git a/webrtc/base/firewallsocketserver.h b/webrtc/base/firewallsocketserver.h
index 26fc75ec93..95ff039623 100644
--- a/webrtc/base/firewallsocketserver.h
+++ b/webrtc/base/firewallsocketserver.h
@@ -26,8 +26,8 @@ enum FirewallDirection { FD_IN, FD_OUT, FD_ANY };
 
 class FirewallSocketServer : public SocketServer {
  public:
-  FirewallSocketServer(SocketServer * server,
-                       FirewallManager * manager = NULL,
+  FirewallSocketServer(SocketServer* server,
+                       FirewallManager* manager = nullptr,
                        bool should_delete_server = false);
   ~FirewallSocketServer() override;
 
@@ -35,7 +35,7 @@ class FirewallSocketServer : public SocketServer {
   void set_socketserver(SocketServer* server) {
     if (server_ && should_delete_server_) {
       delete server_;
-      server_ = NULL;
+      server_ = nullptr;
       should_delete_server_ = false;
     }
     server_ = server;
diff --git a/webrtc/base/flags.cc b/webrtc/base/flags.cc
index 4fcd4acc11..9b7177c22c 100644
--- a/webrtc/base/flags.cc
+++ b/webrtc/base/flags.cc
@@ -106,19 +106,18 @@ void Flag::Print(bool print_current_value) {
 // -----------------------------------------------------------------------------
 // Implementation of FlagList
 
-Flag* FlagList::list_ = NULL;
-
+Flag* FlagList::list_ = nullptr;
 
 FlagList::FlagList() {
-  list_ = NULL;
+  list_ = nullptr;
 }
 
 void FlagList::Print(const char* file, bool print_current_value) {
   // Since flag registration is likely by file (= C++ file),
   // we don't need to sort by file and still get grouped output.
-  const char* current = NULL;
-  for (Flag* f = list_; f != NULL; f = f->next()) {
-    if (file == NULL || file == f->file()) {
+  const char* current = nullptr;
+  for (Flag* f = list_; f != nullptr; f = f->next()) {
+    if (file == nullptr || file == f->file()) {
       if (current != f->file()) {
         printf("Flags from %s:\n", f->file());
         current = f->file();
@@ -131,7 +130,7 @@ void FlagList::Print(const char* file, bool print_current_value) {
 
 Flag* FlagList::Lookup(const char* name) {
   Flag* f = list_;
-  while (f != NULL && strcmp(name, f->name()) != 0)
+  while (f != nullptr && strcmp(name, f->name()) != 0)
     f = f->next();
   return f;
 }
@@ -141,8 +140,8 @@ void FlagList::SplitArgument(const char* arg,
                              char* buffer, int buffer_size,
                              const char** name, const char** value,
                              bool* is_bool) {
-  *name = NULL;
-  *value = NULL;
+  *name = nullptr;
+  *value = nullptr;
   *is_bool = false;
 
   if (*arg == '-') {
@@ -189,16 +188,16 @@ int FlagList::SetFlagsFromCommandLine(int* argc, const char** argv,
     bool is_bool;
     SplitArgument(arg, buffer, sizeof buffer, &name, &value, &is_bool);
 
-    if (name != NULL) {
+    if (name != nullptr) {
       // lookup the flag
       Flag* flag = Lookup(name);
-      if (flag == NULL) {
+      if (flag == nullptr) {
         fprintf(stderr, "Error: unrecognized flag %s\n", arg);
         return j;
       }
 
       // if we still need a flag value, use the next argument if available
-      if (flag->type() != Flag::BOOL && value == NULL) {
+      if (flag->type() != Flag::BOOL && value == nullptr) {
         if (i < *argc) {
           value = argv[i++];
         } else {
@@ -227,9 +226,8 @@ int FlagList::SetFlagsFromCommandLine(int* argc, const char** argv,
       }
 
       // handle errors
-      if ((flag->type() == Flag::BOOL && value != NULL) ||
-          (flag->type() != Flag::BOOL && is_bool) ||
-          *endp != '\0') {
+      if ((flag->type() == Flag::BOOL && value != nullptr) ||
+          (flag->type() != Flag::BOOL && is_bool) || *endp != '\0') {
         fprintf(stderr, "Error: illegal value for flag %s of type %s\n",
           arg, Type2String(flag->type()));
         return j;
@@ -238,7 +236,7 @@ int FlagList::SetFlagsFromCommandLine(int* argc, const char** argv,
       // remove the flag & value from the command
       if (remove_flags)
         while (j < i)
-          argv[j++] = NULL;
+          argv[j++] = nullptr;
     }
   }
 
@@ -246,7 +244,7 @@ int FlagList::SetFlagsFromCommandLine(int* argc, const char** argv,
   if (remove_flags) {
     int j = 1;
     for (int i = 1; i < *argc; i++) {
-      if (argv[i] != NULL)
+      if (argv[i] != nullptr)
         argv[j++] = argv[i];
     }
     *argc = j;
diff --git a/webrtc/base/flags.h b/webrtc/base/flags.h
index 7a7148732e..d6a871ed52 100644
--- a/webrtc/base/flags.h
+++ b/webrtc/base/flags.h
@@ -189,19 +189,19 @@ class FlagList {
  public:
   FlagList();
 
-  // The NULL-terminated list of all flags. Traverse with Flag::next().
+  // The null-terminated list of all flags. Traverse with Flag::next().
   static Flag* list()  { return list_; }
 
-  // If file != NULL, prints information for all flags defined in file;
-  // otherwise prints information for all flags in all files. The current
-  // flag value is only printed if print_current_value is set.
+  // If file != nullptr, prints information for all flags defined in file;
+  // otherwise prints information for all flags in all files. The current flag
+  // value is only printed if print_current_value is set.
   static void Print(const char* file, bool print_current_value);
 
-  // Lookup a flag by name. Returns the matching flag or NULL.
+  // Lookup a flag by name. Returns the matching flag or null.
   static Flag* Lookup(const char* name);
 
   // Helper function to parse flags: Takes an argument arg and splits it into
-  // a flag name and flag value (or NULL if they are missing). is_bool is set
+  // a flag name and flag value (or null if they are missing). is_bool is set
   // if the arg started with "-no" or "--no". The buffer may be used to NUL-
   // terminate the name, it must be large enough to hold any possible name.
   static void SplitArgument(const char* arg,
diff --git a/webrtc/base/httpbase.cc b/webrtc/base/httpbase.cc
index 6364554b93..bc8ac64c71 100644
--- a/webrtc/base/httpbase.cc
+++ b/webrtc/base/httpbase.cc
@@ -176,7 +176,7 @@ HttpParser::ProcessLine(const char* line, size_t len, HttpError* error) {
 
   case ST_CHUNKSIZE:
     if (len > 0) {
-      char* ptr = NULL;
+      char* ptr = nullptr;
       data_size_ = strtoul(line, &ptr, 16);
       if (ptr != line + len) {
         *error = HE_PROTOCOL;
@@ -245,7 +245,7 @@ public:
   DocumentStream(HttpBase* base) : base_(base), error_(HE_DEFAULT) { }
 
   StreamState GetState() const override {
-    if (NULL == base_)
+    if (nullptr == base_)
       return SS_CLOSED;
     if (HM_RECV == base_->mode_)
       return SS_OPEN;
@@ -342,11 +342,11 @@ public:
   }
 
   HttpBase* Disconnect(HttpError error) {
-    RTC_DCHECK(NULL != base_);
-    RTC_DCHECK(NULL != base_->doc_stream_);
+    RTC_DCHECK(nullptr != base_);
+    RTC_DCHECK(nullptr != base_->doc_stream_);
     HttpBase* base = base_;
-    base_->doc_stream_ = NULL;
-    base_ = NULL;
+    base_->doc_stream_ = nullptr;
+    base_ = nullptr;
     error_ = error;
     return base;
   }
@@ -360,9 +360,12 @@ private:
 // HttpBase
 //////////////////////////////////////////////////////////////////////
 
-HttpBase::HttpBase() : mode_(HM_NONE), data_(NULL), notify_(NULL),
-                       http_stream_(NULL), doc_stream_(NULL) {
-}
+HttpBase::HttpBase()
+    : mode_(HM_NONE),
+      data_(nullptr),
+      notify_(nullptr),
+      http_stream_(nullptr),
+      doc_stream_(nullptr) {}
 
 HttpBase::~HttpBase() {
   RTC_DCHECK(HM_NONE == mode_);
@@ -370,12 +373,12 @@ HttpBase::~HttpBase() {
 
 bool
 HttpBase::isConnected() const {
-  return (http_stream_ != NULL) && (http_stream_->GetState() == SS_OPEN);
+  return (http_stream_ != nullptr) && (http_stream_->GetState() == SS_OPEN);
 }
 
 bool
 HttpBase::attach(StreamInterface* stream) {
-  if ((mode_ != HM_NONE) || (http_stream_ != NULL) || (stream == NULL)) {
+  if ((mode_ != HM_NONE) || (http_stream_ != nullptr) || (stream == nullptr)) {
     RTC_NOTREACHED();
     return false;
   }
@@ -389,10 +392,10 @@ StreamInterface*
 HttpBase::detach() {
   RTC_DCHECK(HM_NONE == mode_);
   if (mode_ != HM_NONE) {
-    return NULL;
+    return nullptr;
   }
   StreamInterface* stream = http_stream_;
-  http_stream_ = NULL;
+  http_stream_ = nullptr;
   if (stream) {
     stream->SignalEvent.disconnect(this);
   }
@@ -462,7 +465,7 @@ HttpBase::recv(HttpData* data) {
 void
 HttpBase::abort(HttpError err) {
   if (mode_ != HM_NONE) {
-    if (http_stream_ != NULL) {
+    if (http_stream_ != nullptr) {
       http_stream_->Close();
     }
     do_complete(err);
@@ -471,13 +474,13 @@ HttpBase::abort(HttpError err) {
 
 StreamInterface* HttpBase::GetDocumentStream() {
   if (doc_stream_)
-    return NULL;
+    return nullptr;
   doc_stream_ = new DocumentStream(this);
   return doc_stream_;
 }
 
 HttpError HttpBase::HandleStreamClose(int error) {
-  if (http_stream_ != NULL) {
+  if (http_stream_ != nullptr) {
     http_stream_->Close();
   }
   if (error == 0) {
@@ -497,7 +500,7 @@ HttpError HttpBase::HandleStreamClose(int error) {
 
 bool HttpBase::DoReceiveLoop(HttpError* error) {
   RTC_DCHECK(HM_RECV == mode_);
-  RTC_DCHECK(NULL != error);
+  RTC_DCHECK(nullptr != error);
 
   // Do to the latency between receiving read notifications from
   // pseudotcpchannel, we rely on repeated calls to read in order to acheive
@@ -737,7 +740,7 @@ HttpBase::do_complete(HttpError err) {
   if (data_ && data_->document) {
     data_->document->SignalEvent.disconnect(this);
   }
-  data_ = NULL;
+  data_ = nullptr;
   if ((HM_RECV == mode) && doc_stream_) {
     RTC_DCHECK(HE_NONE !=
                err);  // We should have Disconnected doc_stream_ already.
@@ -834,7 +837,7 @@ HttpBase::ProcessHeaderComplete(bool chunked, size_t& data_size,
   if (notify_) {
     *error = notify_->onHttpHeaderComplete(chunked, data_size);
     // The request must not be aborted as a result of this callback.
-    RTC_DCHECK(NULL != data_);
+    RTC_DCHECK(nullptr != data_);
   }
   if ((HE_NONE == *error) && data_->document) {
     data_->document->SignalEvent.connect(this, &HttpBase::OnDocumentEvent);
diff --git a/webrtc/base/httpbase.h b/webrtc/base/httpbase.h
index 7f368f8e68..4b834a4e5b 100644
--- a/webrtc/base/httpbase.h
+++ b/webrtc/base/httpbase.h
@@ -113,7 +113,7 @@ public:
 
   // Obtaining this stream puts HttpBase into stream mode until the stream
   // is closed.  HttpBase can only expose one open stream interface at a time.
-  // Further calls will return NULL.
+  // Further calls will return null.
   StreamInterface* GetDocumentStream();
 
 protected:
diff --git a/webrtc/base/httpbase_unittest.cc b/webrtc/base/httpbase_unittest.cc
index 8d8e09715f..52c1c53fb1 100644
--- a/webrtc/base/httpbase_unittest.cc
+++ b/webrtc/base/httpbase_unittest.cc
@@ -54,7 +54,7 @@ public:
     HttpMode mode;
     HttpError err;
   };
-  HttpBaseTest() : mem(NULL), obtain_stream(false), http_stream(NULL) { }
+  HttpBaseTest() : mem(nullptr), obtain_stream(false), http_stream(nullptr) {}
 
   virtual void SetUp() { }
   virtual void TearDown() {
@@ -189,27 +189,28 @@ void HttpBaseTest::ObtainDocumentStream() {
   LOG_F(LS_VERBOSE) << "Enter";
   EXPECT_FALSE(http_stream);
   http_stream = base.GetDocumentStream();
-  ASSERT_TRUE(NULL != http_stream);
+  ASSERT_TRUE(nullptr != http_stream);
   sink.Monitor(http_stream);
   LOG_F(LS_VERBOSE) << "Exit";
 }
 
 void HttpBaseTest::VerifyDocumentStreamIsOpening() {
   LOG_F(LS_VERBOSE) << "Enter";
-  ASSERT_TRUE(NULL != http_stream);
+  ASSERT_TRUE(nullptr != http_stream);
   EXPECT_EQ(0, sink.Events(http_stream));
   EXPECT_EQ(SS_OPENING, http_stream->GetState());
 
   size_t read = 0;
   char buffer[5] = { 0 };
-  EXPECT_EQ(SR_BLOCK, http_stream->Read(buffer, sizeof(buffer), &read, NULL));
+  EXPECT_EQ(SR_BLOCK,
+            http_stream->Read(buffer, sizeof(buffer), &read, nullptr));
   LOG_F(LS_VERBOSE) << "Exit";
 }
 
 void HttpBaseTest::VerifyDocumentStreamOpenEvent() {
   LOG_F(LS_VERBOSE) << "Enter";
 
-  ASSERT_TRUE(NULL != http_stream);
+  ASSERT_TRUE(nullptr != http_stream);
   EXPECT_EQ(SE_OPEN | SE_READ, sink.Events(http_stream));
   EXPECT_EQ(SS_OPEN, http_stream->GetState());
 
@@ -222,7 +223,7 @@ void HttpBaseTest::VerifyDocumentStreamOpenEvent() {
 void HttpBaseTest::ReadDocumentStreamData(const char* expected_data) {
   LOG_F(LS_VERBOSE) << "Enter";
 
-  ASSERT_TRUE(NULL != http_stream);
+  ASSERT_TRUE(nullptr != http_stream);
   EXPECT_EQ(SS_OPEN, http_stream->GetState());
 
   // Pump the HTTP I/O using Read, and verify the results.
@@ -233,7 +234,8 @@ void HttpBaseTest::ReadDocumentStreamData(const char* expected_data) {
     char buffer[5] = { 0 };
     size_t amt_to_read =
         std::min(expected_length - verified_length, sizeof(buffer));
-    EXPECT_EQ(SR_SUCCESS, http_stream->Read(buffer, amt_to_read, &read, NULL));
+    EXPECT_EQ(SR_SUCCESS,
+              http_stream->Read(buffer, amt_to_read, &read, nullptr));
     EXPECT_EQ(amt_to_read, read);
     EXPECT_TRUE(0 == memcmp(expected_data + verified_length, buffer, read));
     verified_length += read;
@@ -244,10 +246,10 @@ void HttpBaseTest::ReadDocumentStreamData(const char* expected_data) {
 void HttpBaseTest::VerifyDocumentStreamIsEOS() {
   LOG_F(LS_VERBOSE) << "Enter";
 
-  ASSERT_TRUE(NULL != http_stream);
+  ASSERT_TRUE(nullptr != http_stream);
   size_t read = 0;
   char buffer[5] = { 0 };
-  EXPECT_EQ(SR_EOS, http_stream->Read(buffer, sizeof(buffer), &read, NULL));
+  EXPECT_EQ(SR_EOS, http_stream->Read(buffer, sizeof(buffer), &read, nullptr));
   EXPECT_EQ(SS_CLOSED, http_stream->GetState());
 
   // When EOS is caused by Read, we don't expect SE_CLOSE
@@ -320,7 +322,7 @@ TEST_F(HttpBaseTest, SupportsSend) {
 
 TEST_F(HttpBaseTest, SupportsSendNoDocument) {
   // Queue response document
-  SetupDocument(NULL);
+  SetupDocument(nullptr);
 
   // Begin send
   base.send(&data);
@@ -475,7 +477,7 @@ TEST_F(HttpBaseTest, AllowsGetDocumentStreamWithEmptyDocumentBody) {
   VerifyDocumentContents("");
 
   // The document is still open, until we attempt to read
-  ASSERT_TRUE(NULL != http_stream);
+  ASSERT_TRUE(nullptr != http_stream);
   EXPECT_EQ(SS_OPEN, http_stream->GetState());
 
   // Attempt to read data, and discover EOS
@@ -511,7 +513,8 @@ TEST_F(HttpBaseTest, SignalsDocumentStreamCloseOnUnexpectedClose) {
   // Future reads give an error
   int error = 0;
   char buffer[5] = { 0 };
-  EXPECT_EQ(SR_ERROR, http_stream->Read(buffer, sizeof(buffer), NULL, &error));
+  EXPECT_EQ(SR_ERROR,
+            http_stream->Read(buffer, sizeof(buffer), nullptr, &error));
   EXPECT_EQ(HE_DISCONNECTED, error);
 
   // Document completed with error
diff --git a/webrtc/base/httpcommon-inl.h b/webrtc/base/httpcommon-inl.h
index 75ede29f0f..f29f075998 100644
--- a/webrtc/base/httpcommon-inl.h
+++ b/webrtc/base/httpcommon-inl.h
@@ -53,7 +53,7 @@ void Url<CTYPE>::do_set_address(const CTYPE* val, size_t len) {
     host_.assign(val, colon - val);
     // Note: In every case, we're guaranteed that colon is followed by a null,
     // or non-numeric character.
-    port_ = static_cast<uint16_t>(::strtoul(colon + 1, NULL, 10));
+    port_ = static_cast<uint16_t>(::strtoul(colon + 1, nullptr, 10));
     // TODO: Consider checking for invalid data following port number.
   } else {
     host_.assign(val, len);
diff --git a/webrtc/base/httpcommon.cc b/webrtc/base/httpcommon.cc
index 3d46ab2770..031505b7f9 100644
--- a/webrtc/base/httpcommon.cc
+++ b/webrtc/base/httpcommon.cc
@@ -341,7 +341,7 @@ bool HttpDateToSeconds(const std::string& date, time_t* seconds) {
      1,  2,  3,  4,  5,  6,  7,  8,  9,  10,  11,  12
   };
 
-  RTC_DCHECK(NULL != seconds);
+  RTC_DCHECK(nullptr != seconds);
   struct tm tval;
   memset(&tval, 0, sizeof(tval));
   char month[4], zone[6];
@@ -481,9 +481,9 @@ void HttpData::setContent(const std::string& content_type,
 
 void HttpData::setDocumentAndLength(StreamInterface* document) {
   // TODO: Consider calling Rewind() here?
-  RTC_DCHECK(!hasHeader(HH_CONTENT_LENGTH, NULL));
-  RTC_DCHECK(!hasHeader(HH_TRANSFER_ENCODING, NULL));
-  RTC_DCHECK(document != NULL);
+  RTC_DCHECK(!hasHeader(HH_CONTENT_LENGTH, nullptr));
+  RTC_DCHECK(!hasHeader(HH_TRANSFER_ENCODING, nullptr));
+  RTC_DCHECK(document != nullptr);
   this->document.reset(document);
   size_t content_length = 0;
   if (this->document->GetAvailable(&content_length)) {
@@ -719,7 +719,7 @@ HttpAuthResult HttpAuthenticate(
 {
   HttpAttributeList args;
   HttpParseAttributes(challenge, len, args);
-  HttpHasNthAttribute(args, 0, &auth_method, NULL);
+  HttpHasNthAttribute(args, 0, &auth_method, nullptr);
 
   if (context && (context->auth_method != auth_method))
     return HAR_IGNORE;
@@ -825,7 +825,7 @@ HttpAuthResult HttpAuthenticate(
 
 #if 0 // Requires funky windows versions
     DWORD len = MAX_SPN;
-    if (DsMakeSpn("HTTP", server.HostAsURIString().c_str(), NULL,
+    if (DsMakeSpn("HTTP", server.HostAsURIString().c_str(), nullptr,
                   server.port(),
                   0, &len, spn) != ERROR_SUCCESS) {
       LOG_F(WARNING) << "(Negotiate) - DsMakeSpn failed";
@@ -875,9 +875,9 @@ HttpAuthResult HttpAuthenticate(
       steps = neg->steps;
 
       std::string challenge, decoded_challenge;
-      if (HttpHasNthAttribute(args, 1, &challenge, NULL)
-          && Base64::Decode(challenge, Base64::DO_STRICT,
-                            &decoded_challenge, NULL)) {
+      if (HttpHasNthAttribute(args, 1, &challenge, nullptr) &&
+          Base64::Decode(challenge, Base64::DO_STRICT, &decoded_challenge,
+                         nullptr)) {
         SecBuffer in_sec;
         in_sec.pvBuffer   = const_cast<char *>(decoded_challenge.data());
         in_sec.cbBuffer   = static_cast<unsigned long>(decoded_challenge.size());
diff --git a/webrtc/base/httpserver.cc b/webrtc/base/httpserver.cc
index 083fc0751a..b19069123b 100644
--- a/webrtc/base/httpserver.cc
+++ b/webrtc/base/httpserver.cc
@@ -92,7 +92,7 @@ HttpServer::Connection*
 HttpServer::Find(int connection_id) {
   ConnectionMap::iterator it = connections_.find(connection_id);
   if (it == connections_.end())
-    return NULL;
+    return nullptr;
   return it->second;
 }
 
@@ -118,9 +118,11 @@ HttpServer::Remove(int connection_id) {
 ///////////////////////////////////////////////////////////////////////////////
 
 HttpServer::Connection::Connection(int connection_id, HttpServer* server)
-  : connection_id_(connection_id), server_(server),
-    current_(NULL), signalling_(false), close_(false) {
-}
+    : connection_id_(connection_id),
+      server_(server),
+      current_(nullptr),
+      signalling_(false),
+      close_(false) {}
 
 HttpServer::Connection::~Connection() {
   // It's possible that an object hosted inside this transaction signalled
@@ -139,14 +141,14 @@ HttpServer::Connection::BeginProcess(StreamInterface* stream) {
 
 StreamInterface*
 HttpServer::Connection::EndProcess() {
-  base_.notify(NULL);
+  base_.notify(nullptr);
   base_.abort(HE_DISCONNECTED);
   return base_.detach();
 }
 
 void
 HttpServer::Connection::Respond(HttpServerTransaction* transaction) {
-  RTC_DCHECK(current_ == NULL);
+  RTC_DCHECK(current_ == nullptr);
   current_ = transaction;
   if (current_->response.begin() == current_->response.end()) {
     current_->response.set_error(HC_INTERNAL_SERVER_ERROR);
@@ -161,7 +163,7 @@ HttpServer::Connection::Respond(HttpServerTransaction* transaction) {
 
 void
 HttpServer::Connection::InitiateClose(bool force) {
-  bool request_in_progress = (HM_SEND == base_.mode()) || (NULL == current_);
+  bool request_in_progress = (HM_SEND == base_.mode()) || (nullptr == current_);
   if (!signalling_ && (force || !request_in_progress)) {
     server_->Remove(connection_id_);
   } else {
@@ -178,7 +180,7 @@ HttpServer::Connection::onHttpHeaderComplete(bool chunked, size_t& data_size) {
   if (data_size == SIZE_UNKNOWN) {
     data_size = 0;
   }
-  RTC_DCHECK(current_ != NULL);
+  RTC_DCHECK(current_ != nullptr);
   bool custom_document = false;
   server_->SignalHttpRequestHeader(server_, current_, &custom_document);
   if (!custom_document) {
@@ -190,7 +192,7 @@ HttpServer::Connection::onHttpHeaderComplete(bool chunked, size_t& data_size) {
 void
 HttpServer::Connection::onHttpComplete(HttpMode mode, HttpError err) {
   if (mode == HM_SEND) {
-    RTC_DCHECK(current_ != NULL);
+    RTC_DCHECK(current_ != nullptr);
     signalling_ = true;
     server_->SignalHttpRequestComplete(server_, current_, err);
     signalling_ = false;
@@ -204,11 +206,11 @@ HttpServer::Connection::onHttpComplete(HttpMode mode, HttpError err) {
   } else if (mode == HM_CONNECT) {
     base_.recv(&current_->request);
   } else if (mode == HM_RECV) {
-    RTC_DCHECK(current_ != NULL);
+    RTC_DCHECK(current_ != nullptr);
     // TODO: do we need this?
     //request_.document_->rewind();
     HttpServerTransaction* transaction = current_;
-    current_ = NULL;
+    current_ = nullptr;
     server_->SignalHttpRequest(server_, transaction);
   } else if (mode == HM_SEND) {
     Thread::Current()->Dispose(current_->response.document.release());
@@ -267,7 +269,7 @@ void HttpListenServer::StopListening() {
 
 void HttpListenServer::OnReadEvent(AsyncSocket* socket) {
   RTC_DCHECK(socket == listener_.get());
-  AsyncSocket* incoming = listener_->Accept(NULL);
+  AsyncSocket* incoming = listener_->Accept(nullptr);
   if (incoming) {
     StreamInterface* stream = new SocketStream(incoming);
     //stream = new LoggingAdapter(stream, LS_VERBOSE, "HttpServer", false);
diff --git a/webrtc/base/httpserver.h b/webrtc/base/httpserver.h
index c322e81790..cbee734873 100644
--- a/webrtc/base/httpserver.h
+++ b/webrtc/base/httpserver.h
@@ -51,8 +51,8 @@ public:
   // the request document is a MemoryStream.  By handling this signal, the
   // document can be overridden, in which case the third signal argument should
   // be set to true.  In the case where the request body should be ignored,
-  // the document can be set to NULL.  Note that the transaction object is still
-  // owened by the HttpServer at this point.  
+  // the document can be set to null.  Note that the transaction object is still
+  // owened by the HttpServer at this point.
   sigslot::signal3<HttpServer*, HttpServerTransaction*, bool*>
     SignalHttpRequestHeader;
 
diff --git a/webrtc/base/httpserver_unittest.cc b/webrtc/base/httpserver_unittest.cc
index 0c653cbb9e..96d5fb64b4 100644
--- a/webrtc/base/httpserver_unittest.cc
+++ b/webrtc/base/httpserver_unittest.cc
@@ -27,7 +27,7 @@ namespace {
     bool server_closed, connection_closed;
 
     HttpServerMonitor(HttpServer* server)
-    : transaction(NULL), server_closed(false), connection_closed(false) {
+        : transaction(nullptr), server_closed(false), connection_closed(false) {
       server->SignalCloseAllComplete.connect(this,
         &HttpServerMonitor::OnClosed);
       server->SignalHttpRequest.connect(this, &HttpServerMonitor::OnRequest);
@@ -44,7 +44,7 @@ namespace {
     }
     void OnRequestComplete(HttpServer*, HttpServerTransaction* t, int) {
       ASSERT_EQ(transaction, t);
-      transaction = NULL;
+      transaction = nullptr;
     }
     void OnClosed(HttpServer*) {
       server_closed = true;
@@ -78,7 +78,7 @@ TEST(HttpServer, DoesNotSignalCloseUnlessCloseAllIsCalled) {
   // Add an active client connection
   CreateClientConnection(server, monitor, true);
   // Simulate a response
-  ASSERT_TRUE(NULL != monitor.transaction);
+  ASSERT_TRUE(nullptr != monitor.transaction);
   server.Respond(monitor.transaction);
   EXPECT_FALSE(monitor.transaction);
   // Connection has closed, but no server close signal
@@ -107,7 +107,7 @@ TEST(HttpServer, SignalsCloseAfterGracefulCloseAll) {
   server.CloseAll(false);
   EXPECT_FALSE(monitor.server_closed);
   // Simulate a response
-  ASSERT_TRUE(NULL != monitor.transaction);
+  ASSERT_TRUE(nullptr != monitor.transaction);
   server.Respond(monitor.transaction);
   EXPECT_FALSE(monitor.transaction);
   // Connections have all closed
diff --git a/webrtc/base/ifaddrs-android.cc b/webrtc/base/ifaddrs-android.cc
index d8d28a5ba3..f3c783834c 100644
--- a/webrtc/base/ifaddrs-android.cc
+++ b/webrtc/base/ifaddrs-android.cc
@@ -39,7 +39,7 @@ namespace rtc {
 int set_ifname(struct ifaddrs* ifaddr, int interface) {
   char buf[IFNAMSIZ] = {0};
   char* name = if_indextoname(interface, buf);
-  if (name == NULL) {
+  if (name == nullptr) {
     return -1;
   }
   ifaddr->ifa_name = new char[strlen(name) + 1];
@@ -84,7 +84,7 @@ int set_addresses(struct ifaddrs* ifaddr, ifaddrmsg* msg, void* data,
 }
 
 int make_prefixes(struct ifaddrs* ifaddr, int family, int prefixlen) {
-  char* prefix = NULL;
+  char* prefix = nullptr;
   if (family == AF_INET) {
     sockaddr_in* mask = new sockaddr_in;
     mask->sin_family = AF_INET;
@@ -149,8 +149,8 @@ int getifaddrs(struct ifaddrs** result) {
     close(fd);
     return -1;
   }
-  struct ifaddrs* start = NULL;
-  struct ifaddrs* current = NULL;
+  struct ifaddrs* start = nullptr;
+  struct ifaddrs* current = nullptr;
   char buf[kMaxReadSize];
   ssize_t amount_read = recv(fd, &buf, kMaxReadSize, 0);
   while (amount_read > 0) {
@@ -187,7 +187,7 @@ int getifaddrs(struct ifaddrs** result) {
                 if (populate_ifaddrs(newest, address_msg, RTA_DATA(rta),
                                      RTA_PAYLOAD(rta)) != 0) {
                   freeifaddrs(start);
-                  *result = NULL;
+                  *result = nullptr;
                   return -1;
                 }
                 current = newest;
@@ -207,7 +207,7 @@ int getifaddrs(struct ifaddrs** result) {
 }
 
 void freeifaddrs(struct ifaddrs* addrs) {
-  struct ifaddrs* last = NULL;
+  struct ifaddrs* last = nullptr;
   struct ifaddrs* cursor = addrs;
   while (cursor) {
     delete[] cursor->ifa_name;
diff --git a/webrtc/base/logging.cc b/webrtc/base/logging.cc
index 3624a40bc9..25f85c96a7 100644
--- a/webrtc/base/logging.cc
+++ b/webrtc/base/logging.cc
@@ -110,7 +110,7 @@ CriticalSection g_log_crit;
 // The list of logging streams currently configured.
 // Note: we explicitly do not clean this up, because of the uncertain ordering
 // of destructors at program exit.  Let the person who sets the stream trigger
-// cleanup by setting to NULL, or let it leak (safe at program exit).
+// cleanup by setting to null, or let it leak (safe at program exit).
 LogMessage::StreamList LogMessage::streams_ GUARDED_BY(g_log_crit);
 
 // Boolean options default to false (0)
@@ -140,7 +140,7 @@ LogMessage::LogMessage(const char* file,
     print_stream_ << "[" << std::dec << id << "] ";
   }
 
-  if (file != NULL)
+  if (file != nullptr)
     print_stream_ << "(" << FilenameFromPath(file)  << ":" << line << "): ";
 
   if (err_ctx != ERRCTX_NONE) {
@@ -158,9 +158,8 @@ LogMessage::LogMessage(const char* file,
         if (hmod)
           flags |= FORMAT_MESSAGE_FROM_HMODULE;
         if (DWORD len = FormatMessageA(
-            flags, hmod, err,
-            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-            msgbuf, sizeof(msgbuf) / sizeof(msgbuf[0]), NULL)) {
+                flags, hmod, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                msgbuf, sizeof(msgbuf) / sizeof(msgbuf[0]), nullptr)) {
           while ((len > 0) &&
               isspace(static_cast<unsigned char>(msgbuf[len-1]))) {
             msgbuf[--len] = 0;
@@ -188,7 +187,12 @@ LogMessage::LogMessage(const char* file,
                        int line,
                        LoggingSeverity sev,
                        const std::string& tag)
-    : LogMessage(file, line, sev, ERRCTX_NONE, 0 /* err */, NULL /* module */) {
+    : LogMessage(file,
+                 line,
+                 sev,
+                 ERRCTX_NONE,
+                 0 /* err */,
+                 nullptr /* module */) {
   tag_ = tag;
   print_stream_ << tag << ": ";
 }
@@ -217,7 +221,7 @@ int64_t LogMessage::LogStartTime() {
 }
 
 uint32_t LogMessage::WallClockStartTime() {
-  static const uint32_t g_start_wallclock = time(NULL);
+  static const uint32_t g_start_wallclock = time(nullptr);
   return g_start_wallclock;
 }
 
@@ -349,7 +353,7 @@ void LogMessage::OutputToDebug(const std::string& str,
                                               "logToStdErr",
                                               kCFStringEncodingUTF8);
   CFStringRef domain = CFBundleGetIdentifier(CFBundleGetMainBundle());
-  if (key != NULL && domain != NULL) {
+  if (key != nullptr && domain != nullptr) {
     Boolean exists_and_is_valid;
     Boolean should_log =
         CFPreferencesGetAppBooleanValue(key, domain, &exists_and_is_valid);
@@ -357,7 +361,7 @@ void LogMessage::OutputToDebug(const std::string& str,
     // stderr.
     log_to_stderr = exists_and_is_valid && should_log;
   }
-  if (key != NULL) {
+  if (key != nullptr) {
     CFRelease(key);
   }
 #endif
@@ -443,7 +447,7 @@ void LogMultiline(LoggingSeverity level, const char* label, bool input,
 
   const char * direction = (input ? " << " : " >> ");
 
-  // NULL data means to flush our count of unprintable characters.
+  // null data means to flush our count of unprintable characters.
   if (!data) {
     if (state && state->unprintable_count_[input]) {
       LOG_V(level) << label << direction << "## "
diff --git a/webrtc/base/logging.h b/webrtc/base/logging.h
index 13f0b782b4..8f476a0215 100644
--- a/webrtc/base/logging.h
+++ b/webrtc/base/logging.h
@@ -139,9 +139,12 @@ class LogSink {
 
 class LogMessage {
  public:
-  LogMessage(const char* file, int line, LoggingSeverity sev,
-             LogErrorContext err_ctx = ERRCTX_NONE, int err = 0,
-             const char* module = NULL);
+  LogMessage(const char* file,
+             int line,
+             LoggingSeverity sev,
+             LogErrorContext err_ctx = ERRCTX_NONE,
+             int err = 0,
+             const char* module = nullptr);
 
   LogMessage(const char* file,
              int line,
@@ -185,7 +188,7 @@ class LogMessage {
   //   GetLogToStream gets the severity for the specified stream, of if none
   //   is specified, the minimum stream severity.
   //   RemoveLogToStream removes the specified stream, without destroying it.
-  static int GetLogToStream(LogSink* stream = NULL);
+  static int GetLogToStream(LogSink* stream = nullptr);
   static void AddLogToStream(LogSink* stream, LoggingSeverity min_sev);
   static void RemoveLogToStream(LogSink* stream);
 
@@ -254,7 +257,7 @@ class LogMultilineState {
 };
 
 // When possible, pass optional state variable to track various data across
-// multiple calls to LogMultiline.  Otherwise, pass NULL.
+// multiple calls to LogMultiline.  Otherwise, pass null.
 void LogMultiline(LoggingSeverity level, const char* label, bool input,
                   const void* data, size_t len, bool hex_mode,
                   LogMultilineState* state);
@@ -351,9 +354,9 @@ inline bool LogCheckLevel(LoggingSeverity sev) {
   (errno)
 #endif  // WEBRTC_WIN
 
-#define LOG_TAG(sev, tag) \
+#define LOG_TAG(sev, tag)        \
   LOG_SEVERITY_PRECONDITION(sev) \
-    rtc::LogMessage(NULL, 0, sev, tag).stream()
+  rtc::LogMessage(nullptr, 0, sev, tag).stream()
 
 #define PLOG(sev, err) \
   LOG_ERR_EX(sev, err)
diff --git a/webrtc/base/logging_unittest.cc b/webrtc/base/logging_unittest.cc
index 5035035369..3d9fc9ee5b 100644
--- a/webrtc/base/logging_unittest.cc
+++ b/webrtc/base/logging_unittest.cc
@@ -37,7 +37,7 @@ class LogSinkImpl
 // Test basic logging operation. We should get the INFO log but not the VERBOSE.
 // We should restore the correct global state at the end.
 TEST(LogTest, SingleStream) {
-  int sev = LogMessage::GetLogToStream(NULL);
+  int sev = LogMessage::GetLogToStream(nullptr);
 
   std::string str;
   LogSinkImpl<StringStream> stream(&str);
@@ -52,14 +52,14 @@ TEST(LogTest, SingleStream) {
   LogMessage::RemoveLogToStream(&stream);
   EXPECT_EQ(LS_NONE, LogMessage::GetLogToStream(&stream));
 
-  EXPECT_EQ(sev, LogMessage::GetLogToStream(NULL));
+  EXPECT_EQ(sev, LogMessage::GetLogToStream(nullptr));
 }
 
 // Test using multiple log streams. The INFO stream should get the INFO message,
 // the VERBOSE stream should get the INFO and the VERBOSE.
 // We should restore the correct global state at the end.
 TEST(LogTest, MultipleStreams) {
-  int sev = LogMessage::GetLogToStream(NULL);
+  int sev = LogMessage::GetLogToStream(nullptr);
 
   std::string str1, str2;
   LogSinkImpl<StringStream> stream1(&str1), stream2(&str2);
@@ -81,7 +81,7 @@ TEST(LogTest, MultipleStreams) {
   EXPECT_EQ(LS_NONE, LogMessage::GetLogToStream(&stream2));
   EXPECT_EQ(LS_NONE, LogMessage::GetLogToStream(&stream1));
 
-  EXPECT_EQ(sev, LogMessage::GetLogToStream(NULL));
+  EXPECT_EQ(sev, LogMessage::GetLogToStream(nullptr));
 }
 
 // Ensure we don't crash when adding/removing streams while threads are going.
@@ -100,7 +100,7 @@ class LogThread : public Thread {
 };
 
 TEST(LogTest, MultipleThreads) {
-  int sev = LogMessage::GetLogToStream(NULL);
+  int sev = LogMessage::GetLogToStream(nullptr);
 
   LogThread thread1, thread2, thread3;
   thread1.Start();
@@ -117,7 +117,7 @@ TEST(LogTest, MultipleThreads) {
     LogMessage::RemoveLogToStream(&stream3);
   }
 
-  EXPECT_EQ(sev, LogMessage::GetLogToStream(NULL));
+  EXPECT_EQ(sev, LogMessage::GetLogToStream(nullptr));
 }
 
 
@@ -137,11 +137,11 @@ TEST(LogTest, WallClockStartTime) {
 
 TEST(LogTest, MAYBE_Perf) {
   Pathname path;
-  EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, NULL));
+  EXPECT_TRUE(Filesystem::GetTemporaryFolder(path, true, nullptr));
   path.SetPathname(Filesystem::TempFilename(path, "ut"));
 
   LogSinkImpl<FileStream> stream;
-  EXPECT_TRUE(stream.Open(path.pathname(), "wb", NULL));
+  EXPECT_TRUE(stream.Open(path.pathname(), "wb", nullptr));
   stream.DisableBuffering();
   LogMessage::AddLogToStream(&stream, LS_SENSITIVE);
 
diff --git a/webrtc/base/macutils.cc b/webrtc/base/macutils.cc
index 0d9cae2104..6e90722cf2 100644
--- a/webrtc/base/macutils.cc
+++ b/webrtc/base/macutils.cc
@@ -24,7 +24,7 @@ namespace rtc {
 ///////////////////////////////////////////////////////////////////////////////
 
 bool ToUtf8(const CFStringRef str16, std::string* str8) {
-  if ((NULL == str16) || (NULL == str8)) {
+  if ((nullptr == str16) || (nullptr == str8)) {
     return false;
   }
   size_t maxlen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str16),
@@ -39,14 +39,14 @@ bool ToUtf8(const CFStringRef str16, std::string* str8) {
 }
 
 bool ToUtf16(const std::string& str8, CFStringRef* str16) {
-  if (NULL == str16) {
+  if (nullptr == str16) {
     return false;
   }
   *str16 = CFStringCreateWithBytes(kCFAllocatorDefault,
                                    reinterpret_cast<const UInt8*>(str8.data()),
                                    str8.length(), kCFStringEncodingUTF8,
                                    false);
-  return NULL != *str16;
+  return nullptr != *str16;
 }
 
 void DecodeFourChar(UInt32 fc, std::string* out) {
diff --git a/webrtc/base/messagedigest.cc b/webrtc/base/messagedigest.cc
index 5e8621c770..05c8c4f3da 100644
--- a/webrtc/base/messagedigest.cc
+++ b/webrtc/base/messagedigest.cc
@@ -34,7 +34,7 @@ MessageDigest* MessageDigestFactory::Create(const std::string& alg) {
   MessageDigest* digest = new OpenSSLDigest(alg);
   if (digest->Size() == 0) {  // invalid algorithm
     delete digest;
-    digest = NULL;
+    digest = nullptr;
   }
   return digest;
 }
diff --git a/webrtc/base/messagequeue.cc b/webrtc/base/messagequeue.cc
index 4a30ad17cc..efe618851a 100644
--- a/webrtc/base/messagequeue.cc
+++ b/webrtc/base/messagequeue.cc
@@ -49,7 +49,7 @@ class SCOPED_LOCKABLE DebugNonReentrantCritScope {
 //------------------------------------------------------------------
 // MessageQueueManager
 
-MessageQueueManager* MessageQueueManager::instance_ = NULL;
+MessageQueueManager* MessageQueueManager::instance_ = nullptr;
 
 MessageQueueManager* MessageQueueManager::Instance() {
   // Note: This is not thread safe, but it is first called before threads are
@@ -60,7 +60,7 @@ MessageQueueManager* MessageQueueManager::Instance() {
 }
 
 bool MessageQueueManager::IsInitialized() {
-  return instance_ != NULL;
+  return instance_ != nullptr;
 }
 
 MessageQueueManager::MessageQueueManager() : locked_(false) {}
@@ -99,7 +99,7 @@ void MessageQueueManager::RemoveInternal(MessageQueue *message_queue) {
     destroy = message_queues_.empty();
   }
   if (destroy) {
-    instance_ = NULL;
+    instance_ = nullptr;
     delete this;
   }
 }
@@ -214,11 +214,11 @@ void MessageQueue::DoDestroy() {
   // is going away.
   SignalQueueDestroyed();
   MessageQueueManager::Remove(this);
-  Clear(NULL);
+  Clear(nullptr);
 
   SharedScope ss(&ss_lock_);
   if (ss_) {
-    ss_->SetMessageQueue(NULL);
+    ss_->SetMessageQueue(nullptr);
   }
 }
 
@@ -333,7 +333,7 @@ bool MessageQueue::Get(Message *pmsg, int cmsWait, bool process_io) {
       }
       // If this was a dispose message, delete it and skip it.
       if (MQID_DISPOSE == pmsg->message_id) {
-        RTC_DCHECK(NULL == pmsg->phandler);
+        RTC_DCHECK(nullptr == pmsg->phandler);
         delete pmsg->pdata;
         *pmsg = Message();
         continue;
diff --git a/webrtc/base/messagequeue.h b/webrtc/base/messagequeue.h
index df50f54868..20e2e13bc5 100644
--- a/webrtc/base/messagequeue.h
+++ b/webrtc/base/messagequeue.h
@@ -157,8 +157,8 @@ struct Message {
   Message()
       : phandler(nullptr), message_id(0), pdata(nullptr), ts_sensitive(0) {}
   inline bool Match(MessageHandler* handler, uint32_t id) const {
-    return (handler == NULL || handler == phandler)
-           && (id == MQID_ANY || id == message_id);
+    return (handler == nullptr || handler == phandler) &&
+           (id == MQID_ANY || id == message_id);
   }
   Location posted_from;
   MessageHandler *phandler;
@@ -236,27 +236,27 @@ class MessageQueue {
   virtual void Post(const Location& posted_from,
                     MessageHandler* phandler,
                     uint32_t id = 0,
-                    MessageData* pdata = NULL,
+                    MessageData* pdata = nullptr,
                     bool time_sensitive = false);
   virtual void PostDelayed(const Location& posted_from,
                            int cmsDelay,
                            MessageHandler* phandler,
                            uint32_t id = 0,
-                           MessageData* pdata = NULL);
+                           MessageData* pdata = nullptr);
   virtual void PostAt(const Location& posted_from,
                       int64_t tstamp,
                       MessageHandler* phandler,
                       uint32_t id = 0,
-                      MessageData* pdata = NULL);
+                      MessageData* pdata = nullptr);
   // TODO(honghaiz): Remove this when all the dependencies are removed.
   virtual void PostAt(const Location& posted_from,
                       uint32_t tstamp,
                       MessageHandler* phandler,
                       uint32_t id = 0,
-                      MessageData* pdata = NULL);
+                      MessageData* pdata = nullptr);
   virtual void Clear(MessageHandler* phandler,
                      uint32_t id = MQID_ANY,
-                     MessageList* removed = NULL);
+                     MessageList* removed = nullptr);
   virtual void Dispatch(Message *pmsg);
   virtual void ReceiveSends();
 
@@ -272,7 +272,7 @@ class MessageQueue {
   // Internally posts a message which causes the doomed object to be deleted
   template<class T> void Dispose(T* doomed) {
     if (doomed) {
-      Post(RTC_FROM_HERE, NULL, MQID_DISPOSE, new DisposeData<T>(doomed));
+      Post(RTC_FROM_HERE, nullptr, MQID_DISPOSE, new DisposeData<T>(doomed));
     }
   }
 
diff --git a/webrtc/base/messagequeue_unittest.cc b/webrtc/base/messagequeue_unittest.cc
index 8834ab57ef..9652bb38d5 100644
--- a/webrtc/base/messagequeue_unittest.cc
+++ b/webrtc/base/messagequeue_unittest.cc
@@ -57,13 +57,13 @@ struct DeletedLockChecker {
 
 static void DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(
     MessageQueue* q) {
-  EXPECT_TRUE(q != NULL);
+  EXPECT_TRUE(q != nullptr);
   int64_t now = TimeMillis();
-  q->PostAt(RTC_FROM_HERE, now, NULL, 3);
-  q->PostAt(RTC_FROM_HERE, now - 2, NULL, 0);
-  q->PostAt(RTC_FROM_HERE, now - 1, NULL, 1);
-  q->PostAt(RTC_FROM_HERE, now, NULL, 4);
-  q->PostAt(RTC_FROM_HERE, now - 1, NULL, 2);
+  q->PostAt(RTC_FROM_HERE, now, nullptr, 3);
+  q->PostAt(RTC_FROM_HERE, now - 2, nullptr, 0);
+  q->PostAt(RTC_FROM_HERE, now - 1, nullptr, 1);
+  q->PostAt(RTC_FROM_HERE, now, nullptr, 4);
+  q->PostAt(RTC_FROM_HERE, now - 1, nullptr, 2);
 
   Message msg;
   for (size_t i=0; i<5; ++i) {
@@ -120,7 +120,7 @@ TEST_F(MessageQueueTest, DiposeHandlerWithPostedMessagePending) {
 }
 
 struct UnwrapMainThreadScope {
-  UnwrapMainThreadScope() : rewrap_(Thread::Current() != NULL) {
+  UnwrapMainThreadScope() : rewrap_(Thread::Current() != nullptr) {
     if (rewrap_) ThreadManager::Instance()->UnwrapCurrentThread();
   }
   ~UnwrapMainThreadScope() {
diff --git a/webrtc/base/nat_unittest.cc b/webrtc/base/nat_unittest.cc
index bd630b306e..f585effdd9 100644
--- a/webrtc/base/nat_unittest.cc
+++ b/webrtc/base/nat_unittest.cc
@@ -336,7 +336,7 @@ class NatTcpTest : public testing::Test, public sigslot::has_slots<> {
   }
 
   void OnAcceptEvent(AsyncSocket* socket) {
-    accepted_.reset(server_->Accept(NULL));
+    accepted_.reset(server_->Accept(nullptr));
   }
 
   void OnCloseEvent(AsyncSocket* socket, int error) {
diff --git a/webrtc/base/natsocketfactory.cc b/webrtc/base/natsocketfactory.cc
index 37586fe3c9..7aa6838e17 100644
--- a/webrtc/base/natsocketfactory.cc
+++ b/webrtc/base/natsocketfactory.cc
@@ -71,9 +71,13 @@ size_t UnpackAddressFromNAT(const char* buf, size_t buf_size,
 class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
  public:
   explicit NATSocket(NATInternalSocketFactory* sf, int family, int type)
-      : sf_(sf), family_(family), type_(type), connected_(false),
-        socket_(NULL), buf_(NULL), size_(0) {
-  }
+      : sf_(sf),
+        family_(family),
+        type_(type),
+        connected_(false),
+        socket_(nullptr),
+        buf_(nullptr),
+        size_(0) {}
 
   ~NATSocket() override {
     delete socket_;
@@ -104,7 +108,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
     } else {
       server_addr_.Clear();
       delete socket_;
-      socket_ = NULL;
+      socket_ = nullptr;
     }
 
     return result;
@@ -211,7 +215,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
         connected_ = false;
         remote_addr_ = SocketAddress();
         delete socket_;
-        socket_ = NULL;
+        socket_ = nullptr;
       }
     }
     return result;
@@ -339,8 +343,7 @@ AsyncSocket* NATSocketFactory::CreateInternalSocket(int family, int type,
 
 // NATSocketServer
 NATSocketServer::NATSocketServer(SocketServer* server)
-    : server_(server), msg_queue_(NULL) {
-}
+    : server_(server), msg_queue_(nullptr) {}
 
 NATSocketServer::Translator* NATSocketServer::GetTranslator(
     const SocketAddress& ext_ip) {
@@ -351,7 +354,7 @@ NATSocketServer::Translator* NATSocketServer::AddTranslator(
     const SocketAddress& ext_ip, const SocketAddress& int_ip, NATType type) {
   // Fail if a translator already exists with this extternal address.
   if (nats_.Get(ext_ip))
-    return NULL;
+    return nullptr;
 
   return nats_.Add(ext_ip, new Translator(this, type, int_ip, server_, ext_ip));
 }
@@ -392,7 +395,7 @@ void NATSocketServer::WakeUp() {
 
 AsyncSocket* NATSocketServer::CreateInternalSocket(int family, int type,
     const SocketAddress& local_addr, SocketAddress* nat_addr) {
-  AsyncSocket* socket = NULL;
+  AsyncSocket* socket = nullptr;
   Translator* nat = nats_.FindClient(local_addr);
   if (nat) {
     socket = nat->internal_factory()->CreateAsyncSocket(family, type);
@@ -430,7 +433,7 @@ NATSocketServer::Translator* NATSocketServer::Translator::AddTranslator(
     const SocketAddress& ext_ip, const SocketAddress& int_ip, NATType type) {
   // Fail if a translator already exists with this extternal address.
   if (nats_.Get(ext_ip))
-    return NULL;
+    return nullptr;
 
   AddClient(ext_ip);
   return nats_.Add(ext_ip,
@@ -477,7 +480,7 @@ NATSocketServer::TranslatorMap::~TranslatorMap() {
 NATSocketServer::Translator* NATSocketServer::TranslatorMap::Get(
     const SocketAddress& ext_ip) {
   TranslatorMap::iterator it = find(ext_ip);
-  return (it != end()) ? it->second : NULL;
+  return (it != end()) ? it->second : nullptr;
 }
 
 NATSocketServer::Translator* NATSocketServer::TranslatorMap::Add(
@@ -497,7 +500,7 @@ void NATSocketServer::TranslatorMap::Remove(
 
 NATSocketServer::Translator* NATSocketServer::TranslatorMap::FindClient(
     const SocketAddress& int_ip) {
-  Translator* nat = NULL;
+  Translator* nat = nullptr;
   for (TranslatorMap::iterator it = begin(); it != end() && !nat; ++it) {
     nat = it->second->FindClient(int_ip);
   }
diff --git a/webrtc/base/nethelpers.cc b/webrtc/base/nethelpers.cc
index 7ca654949c..6c2ef9c5f6 100644
--- a/webrtc/base/nethelpers.cc
+++ b/webrtc/base/nethelpers.cc
@@ -43,7 +43,7 @@ int ResolveHostname(const std::string& hostname, int family,
     return -1;
   }
   addresses->clear();
-  struct addrinfo* result = NULL;
+  struct addrinfo* result = nullptr;
   struct addrinfo hints = {0};
   hints.ai_family = family;
   // |family| here will almost always be AF_UNSPEC, because |family| comes from
@@ -64,7 +64,7 @@ int ResolveHostname(const std::string& hostname, int family,
   // https://android.googlesource.com/platform/bionic/+/
   // 7e0bfb511e85834d7c6cb9631206b62f82701d60/libc/netbsd/net/getaddrinfo.c#1657
   hints.ai_flags = AI_ADDRCONFIG;
-  int ret = getaddrinfo(hostname.c_str(), NULL, &hints, &result);
+  int ret = getaddrinfo(hostname.c_str(), nullptr, &hints, &result);
   if (ret != 0) {
     return ret;
   }
@@ -151,7 +151,7 @@ bool HasIPv6Enabled() {
   }
   DWORD protbuff_size = 4096;
   std::unique_ptr<char[]> protocols;
-  LPWSAPROTOCOL_INFOW protocol_infos = NULL;
+  LPWSAPROTOCOL_INFOW protocol_infos = nullptr;
   int requested_protocols[2] = {AF_INET6, 0};
 
   int err = 0;
diff --git a/webrtc/base/network.cc b/webrtc/base/network.cc
index 1092a04ca2..69dc28ccd2 100644
--- a/webrtc/base/network.cc
+++ b/webrtc/base/network.cc
@@ -392,9 +392,10 @@ Network* NetworkManagerBase::GetNetworkFromAddress(
 }
 
 BasicNetworkManager::BasicNetworkManager()
-    : thread_(NULL), sent_first_update_(false), start_count_(0),
-      ignore_non_default_routes_(false) {
-}
+    : thread_(nullptr),
+      sent_first_update_(false),
+      start_count_(0),
+      ignore_non_default_routes_(false) {}
 
 BasicNetworkManager::~BasicNetworkManager() {
 }
@@ -420,8 +421,8 @@ void BasicNetworkManager::ConvertIfAddrs(struct ifaddrs* interfaces,
                                          NetworkList* networks) const {
   NetworkMap current_networks;
 
-  for (struct ifaddrs* cursor = interfaces;
-       cursor != NULL; cursor = cursor->ifa_next) {
+  for (struct ifaddrs* cursor = interfaces; cursor != nullptr;
+       cursor = cursor->ifa_next) {
     IPAddress prefix;
     IPAddress mask;
     InterfaceAddress ip;
@@ -518,7 +519,7 @@ unsigned int GetPrefix(PIP_ADAPTER_PREFIX prefixlist,
   unsigned int best_length = 0;
   while (prefixlist) {
     // Look for the longest matching prefix in the prefixlist.
-    if (prefixlist->Address.lpSockaddr == NULL ||
+    if (prefixlist->Address.lpSockaddr == nullptr ||
         prefixlist->Address.lpSockaddr->sa_family != ip.family()) {
       prefixlist = prefixlist->Next;
       continue;
@@ -660,7 +661,7 @@ bool BasicNetworkManager::CreateNetworks(bool include_ignored,
 #if defined(WEBRTC_LINUX)
 bool IsDefaultRoute(const std::string& network_name) {
   FileStream fs;
-  if (!fs.Open("/proc/net/route", "r", NULL)) {
+  if (!fs.Open("/proc/net/route", "r", nullptr)) {
     LOG(LS_WARNING) << "Couldn't read /proc/net/route, skipping default "
                     << "route check (assuming everything is a default route).";
     return true;
@@ -711,7 +712,7 @@ bool BasicNetworkManager::IsIgnoredNetwork(const Network& network) const {
   // VMware Virtual Ethernet Adapter for VMnet1
   // but don't ignore any GUEST side adapters with a description like:
   // VMware Accelerated AMD PCNet Adapter #2
-  if (strstr(network.description().c_str(), "VMnet") != NULL) {
+  if (strstr(network.description().c_str(), "VMnet") != nullptr) {
     return true;
   }
 #endif
diff --git a/webrtc/base/openssladapter.cc b/webrtc/base/openssladapter.cc
index 6f9049d10b..bc7b99b97a 100644
--- a/webrtc/base/openssladapter.cc
+++ b/webrtc/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 @@ static int socket_free(BIO* data);
 
 // TODO(davidben): This should be const once BoringSSL is assumed.
 static BIO_METHOD methods_socket = {
-  BIO_TYPE_BIO,
-  "socket",
-  socket_write,
-  socket_read,
-  socket_puts,
-  0,
-  socket_ctrl,
-  socket_new,
-  socket_free,
-  NULL,
+    BIO_TYPE_BIO, "socket",   socket_write, socket_read, socket_puts, 0,
+    socket_ctrl,  socket_new, socket_free,  nullptr,
 };
 
 static BIO_METHOD* BIO_s_socket2() { return(&methods_socket); }
 
 static BIO* BIO_new_socket(rtc::AsyncSocket* socket) {
   BIO* ret = BIO_new(BIO_s_socket2());
-  if (ret == NULL) {
-          return NULL;
+  if (ret == nullptr) {
+    return nullptr;
   }
   ret->ptr = socket;
   return ret;
@@ -107,7 +99,7 @@ static int socket_new(BIO* b) {
 }
 
 static int socket_free(BIO* b) {
-  if (b == NULL)
+  if (b == nullptr)
     return 0;
   return 1;
 }
@@ -171,7 +163,7 @@ namespace rtc {
 #ifndef OPENSSL_IS_BORINGSSL
 
 // This array will store all of the mutexes available to OpenSSL.
-static MUTEX_TYPE* mutex_buf = NULL;
+static MUTEX_TYPE* mutex_buf = nullptr;
 
 static void locking_function(int mode, int n, const char * file, int line) {
   if (mode & CRYPTO_LOCK) {
@@ -191,7 +183,7 @@ static unsigned long id_function() {  // NOLINT
 static CRYPTO_dynlock_value* dyn_create_function(const char* file, int line) {
   CRYPTO_dynlock_value* value = new CRYPTO_dynlock_value;
   if (!value)
-    return NULL;
+    return nullptr;
   MUTEX_SETUP(value->mutex);
   return value;
 }
@@ -213,7 +205,7 @@ static void dyn_destroy_function(CRYPTO_dynlock_value* l,
 
 #endif  // #ifndef OPENSSL_IS_BORINGSSL
 
-VerificationCallback OpenSSLAdapter::custom_verify_callback_ = NULL;
+VerificationCallback OpenSSLAdapter::custom_verify_callback_ = nullptr;
 
 bool OpenSSLAdapter::InitializeSSL(VerificationCallback callback) {
   if (!InitializeSSLThread() || !SSL_library_init())
@@ -254,29 +246,29 @@ bool OpenSSLAdapter::CleanupSSL() {
 #ifndef OPENSSL_IS_BORINGSSL
   if (!mutex_buf)
     return false;
-  CRYPTO_set_id_callback(NULL);
-  CRYPTO_set_locking_callback(NULL);
-  CRYPTO_set_dynlock_create_callback(NULL);
-  CRYPTO_set_dynlock_lock_callback(NULL);
-  CRYPTO_set_dynlock_destroy_callback(NULL);
+  CRYPTO_set_id_callback(nullptr);
+  CRYPTO_set_locking_callback(nullptr);
+  CRYPTO_set_dynlock_create_callback(nullptr);
+  CRYPTO_set_dynlock_lock_callback(nullptr);
+  CRYPTO_set_dynlock_destroy_callback(nullptr);
   for (int i = 0; i < CRYPTO_num_locks(); ++i)
     MUTEX_CLEANUP(mutex_buf[i]);
   delete [] mutex_buf;
-  mutex_buf = NULL;
+  mutex_buf = nullptr;
 #endif  // #ifndef OPENSSL_IS_BORINGSSL
   return true;
 }
 
 OpenSSLAdapter::OpenSSLAdapter(AsyncSocket* socket)
-  : SSLAdapter(socket),
-    state_(SSL_NONE),
-    ssl_read_needs_write_(false),
-    ssl_write_needs_read_(false),
-    restartable_(false),
-    ssl_(NULL), ssl_ctx_(NULL),
-    ssl_mode_(SSL_MODE_TLS),
-    custom_verification_succeeded_(false) {
-}
+    : SSLAdapter(socket),
+      state_(SSL_NONE),
+      ssl_read_needs_write_(false),
+      ssl_write_needs_read_(false),
+      restartable_(false),
+      ssl_(nullptr),
+      ssl_ctx_(nullptr),
+      ssl_mode_(SSL_MODE_TLS),
+      custom_verification_succeeded_(false) {}
 
 OpenSSLAdapter::~OpenSSLAdapter() {
   Cleanup();
@@ -316,7 +308,7 @@ OpenSSLAdapter::BeginSSL() {
   RTC_DCHECK(state_ == SSL_CONNECTING);
 
   int err = 0;
-  BIO* bio = NULL;
+  BIO* bio = nullptr;
 
   // First set up the context
   if (!ssl_ctx_)
@@ -346,7 +338,7 @@ OpenSSLAdapter::BeginSSL() {
                      SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
 
   // the SSL object owns the bio now
-  bio = NULL;
+  bio = nullptr;
 
   // Do the connect
   err = ContinueSSL();
@@ -437,12 +429,12 @@ OpenSSLAdapter::Cleanup() {
 
   if (ssl_) {
     SSL_free(ssl_);
-    ssl_ = NULL;
+    ssl_ = nullptr;
   }
 
   if (ssl_ctx_) {
     SSL_CTX_free(ssl_ctx_);
-    ssl_ctx_ = NULL;
+    ssl_ctx_ = nullptr;
   }
 
   // Clear the DTLS timer
@@ -707,7 +699,7 @@ bool OpenSSLAdapter::VerifyServerName(SSL* ssl, const char* host,
 
   // Checking the return from SSL_get_peer_certificate here is not strictly
   // necessary.  With our setup, it is not possible for it to return
-  // NULL.  However, it is good form to check the return.
+  // null.  However, it is good form to check the return.
   X509* certificate = SSL_get_peer_certificate(ssl);
   if (!certificate)
     return false;
@@ -725,7 +717,7 @@ bool OpenSSLAdapter::VerifyServerName(SSL* ssl, const char* host,
     BIO_free(mem);
 
     char* cipher_description =
-      SSL_CIPHER_description(SSL_get_current_cipher(ssl), NULL, 128);
+        SSL_CIPHER_description(SSL_get_current_cipher(ssl), nullptr, 128);
     LOG(LS_INFO) << "Cipher: " << cipher_description;
     OPENSSL_free(cipher_description);
   }
@@ -755,10 +747,9 @@ bool OpenSSLAdapter::VerifyServerName(SSL* ssl, const char* host,
 
   char data[256];
   X509_NAME* subject;
-  if (!ok
-      && ((subject = X509_get_subject_name(certificate)) != NULL)
-      && (X509_NAME_get_text_by_NID(subject, NID_commonName,
-                                    data, sizeof(data)) > 0)) {
+  if (!ok && ((subject = X509_get_subject_name(certificate)) != nullptr) &&
+      (X509_NAME_get_text_by_NID(subject, NID_commonName, data, sizeof(data)) >
+       0)) {
     data[sizeof(data)-1] = 0;
     if (_stricmp(data, host) == 0)
       ok = true;
@@ -875,8 +866,8 @@ bool OpenSSLAdapter::ConfigureTrustedRootCertificates(SSL_CTX* ctx) {
   for (size_t i = 0; i < arraysize(kSSLCertCertificateList); i++) {
     const unsigned char* cert_buffer = kSSLCertCertificateList[i];
     size_t cert_buffer_len = kSSLCertCertificateSizeList[i];
-    X509* cert = d2i_X509(NULL, &cert_buffer,
-                          checked_cast<long>(cert_buffer_len));
+    X509* cert =
+        d2i_X509(nullptr, &cert_buffer, checked_cast<long>(cert_buffer_len));
     if (cert) {
       int return_value = X509_STORE_add_cert(SSL_CTX_get_cert_store(ctx), cert);
       if (return_value == 0) {
@@ -894,16 +885,16 @@ SSL_CTX*
 OpenSSLAdapter::SetupSSLContext() {
   SSL_CTX* ctx = SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ?
       DTLSv1_client_method() : TLSv1_client_method());
-  if (ctx == NULL) {
+  if (ctx == nullptr) {
     unsigned long error = ERR_get_error();  // NOLINT: type used by OpenSSL.
     LOG(LS_WARNING) << "SSL_CTX creation failed: "
                     << '"' << ERR_reason_error_string(error) << "\" "
                     << "(error=" << error << ')';
-    return NULL;
+    return nullptr;
   }
   if (!ConfigureTrustedRootCertificates(ctx)) {
     SSL_CTX_free(ctx);
-    return NULL;
+    return nullptr;
   }
 
 #if !defined(NDEBUG)
diff --git a/webrtc/base/openssldigest.cc b/webrtc/base/openssldigest.cc
index 37f2d0e86b..3115074eb6 100644
--- a/webrtc/base/openssldigest.cc
+++ b/webrtc/base/openssldigest.cc
@@ -18,9 +18,9 @@ namespace rtc {
 OpenSSLDigest::OpenSSLDigest(const std::string& algorithm) {
   EVP_MD_CTX_init(&ctx_);
   if (GetDigestEVP(algorithm, &md_)) {
-    EVP_DigestInit_ex(&ctx_, md_, NULL);
+    EVP_DigestInit_ex(&ctx_, md_, nullptr);
   } else {
-    md_ = NULL;
+    md_ = nullptr;
   }
 }
 
@@ -48,7 +48,7 @@ size_t OpenSSLDigest::Finish(void* buf, size_t len) {
   }
   unsigned int md_len;
   EVP_DigestFinal_ex(&ctx_, static_cast<unsigned char*>(buf), &md_len);
-  EVP_DigestInit_ex(&ctx_, md_, NULL);  // prepare for future Update()s
+  EVP_DigestInit_ex(&ctx_, md_, nullptr);  // prepare for future Update()s
   RTC_DCHECK(md_len == Size());
   return md_len;
 }
@@ -80,8 +80,8 @@ bool OpenSSLDigest::GetDigestEVP(const std::string& algorithm,
 
 bool OpenSSLDigest::GetDigestName(const EVP_MD* md,
                                   std::string* algorithm) {
-  RTC_DCHECK(md != NULL);
-  RTC_DCHECK(algorithm != NULL);
+  RTC_DCHECK(md != nullptr);
+  RTC_DCHECK(algorithm != nullptr);
 
   int md_type = EVP_MD_type(md);
   if (md_type == NID_md5) {
diff --git a/webrtc/base/opensslidentity.cc b/webrtc/base/opensslidentity.cc
index 7b96f6a206..9495496ffe 100644
--- a/webrtc/base/opensslidentity.cc
+++ b/webrtc/base/opensslidentity.cc
@@ -46,13 +46,13 @@ static EVP_PKEY* MakeKey(const KeyParams& key_params) {
     RSA* rsa = RSA_new();
     if (!pkey || !exponent || !rsa ||
         !BN_set_word(exponent, key_params.rsa_params().pub_exp) ||
-        !RSA_generate_key_ex(rsa, key_length, exponent, NULL) ||
+        !RSA_generate_key_ex(rsa, key_length, exponent, nullptr) ||
         !EVP_PKEY_assign_RSA(pkey, rsa)) {
       EVP_PKEY_free(pkey);
       BN_free(exponent);
       RSA_free(rsa);
       LOG(LS_ERROR) << "Failed to make RSA key pair";
-      return NULL;
+      return nullptr;
     }
     // ownership of rsa struct was assigned, don't free it.
     BN_free(exponent);
@@ -71,19 +71,19 @@ static EVP_PKEY* MakeKey(const KeyParams& key_params) {
         EVP_PKEY_free(pkey);
         EC_KEY_free(ec_key);
         LOG(LS_ERROR) << "Failed to make EC key pair";
-        return NULL;
+        return nullptr;
       }
       // ownership of ec_key struct was assigned, don't free it.
     } else {
       // Add generation of any other curves here.
       EVP_PKEY_free(pkey);
       LOG(LS_ERROR) << "ECDSA key requested for unknown curve";
-      return NULL;
+      return nullptr;
     }
   } else {
     EVP_PKEY_free(pkey);
     LOG(LS_ERROR) << "Key type requested not understood";
-    return NULL;
+    return nullptr;
   }
 
   LOG(LS_INFO) << "Returning key pair";
@@ -94,12 +94,12 @@ static EVP_PKEY* MakeKey(const KeyParams& key_params) {
 // given key pair. Caller is responsible for freeing the returned object.
 static X509* MakeCertificate(EVP_PKEY* pkey, const SSLIdentityParams& params) {
   LOG(LS_INFO) << "Making certificate for " << params.common_name;
-  X509* x509 = NULL;
-  BIGNUM* serial_number = NULL;
-  X509_NAME* name = NULL;
+  X509* x509 = nullptr;
+  BIGNUM* serial_number = nullptr;
+  X509_NAME* name = nullptr;
   time_t epoch_off = 0;  // Time offset since epoch.
 
-  if ((x509=X509_new()) == NULL)
+  if ((x509 = X509_new()) == nullptr)
     goto error;
 
   if (!X509_set_pubkey(x509, pkey))
@@ -108,9 +108,9 @@ static X509* MakeCertificate(EVP_PKEY* pkey, const SSLIdentityParams& params) {
   // serial number
   // temporary reference to serial number inside x509 struct
   ASN1_INTEGER* asn1_serial_number;
-  if ((serial_number = BN_new()) == NULL ||
+  if ((serial_number = BN_new()) == nullptr ||
       !BN_pseudo_rand(serial_number, SERIAL_RAND_BITS, 0, 0) ||
-      (asn1_serial_number = X509_get_serialNumber(x509)) == NULL ||
+      (asn1_serial_number = X509_get_serialNumber(x509)) == nullptr ||
       !BN_to_ASN1_INTEGER(serial_number, asn1_serial_number))
     goto error;
 
@@ -124,12 +124,11 @@ static X509* MakeCertificate(EVP_PKEY* pkey, const SSLIdentityParams& params) {
   // arbitrary common_name. Note that this certificate goes out in
   // clear during SSL negotiation, so there may be a privacy issue in
   // putting anything recognizable here.
-  if ((name = X509_NAME_new()) == NULL ||
-      !X509_NAME_add_entry_by_NID(
-          name, NID_commonName, MBSTRING_UTF8,
-          (unsigned char*)params.common_name.c_str(), -1, -1, 0) ||
-      !X509_set_subject_name(x509, name) ||
-      !X509_set_issuer_name(x509, name))
+  if ((name = X509_NAME_new()) == nullptr ||
+      !X509_NAME_add_entry_by_NID(name, NID_commonName, MBSTRING_UTF8,
+                                  (unsigned char*)params.common_name.c_str(),
+                                  -1, -1, 0) ||
+      !X509_set_subject_name(x509, name) || !X509_set_issuer_name(x509, name))
     goto error;
 
   if (!X509_time_adj(X509_get_notBefore(x509), params.not_before, &epoch_off) ||
@@ -148,7 +147,7 @@ static X509* MakeCertificate(EVP_PKEY* pkey, const SSLIdentityParams& params) {
   BN_free(serial_number);
   X509_NAME_free(name);
   X509_free(x509);
-  return NULL;
+  return nullptr;
 }
 
 // This dumps the SSL error stack to the log.
@@ -166,7 +165,7 @@ OpenSSLKeyPair* OpenSSLKeyPair::Generate(const KeyParams& key_params) {
   EVP_PKEY* pkey = MakeKey(key_params);
   if (!pkey) {
     LogSSLErrors("Generating key pair");
-    return NULL;
+    return nullptr;
   }
   return new OpenSSLKeyPair(pkey);
 }
@@ -289,7 +288,7 @@ OpenSSLCertificate* OpenSSLCertificate::Generate(
   X509* x509 = MakeCertificate(key_pair->pkey(), actual_params);
   if (!x509) {
     LogSSLErrors("Generating certificate");
-    return NULL;
+    return nullptr;
   }
 #if !defined(NDEBUG)
   PrintCert(x509);
@@ -303,13 +302,14 @@ OpenSSLCertificate* OpenSSLCertificate::FromPEMString(
     const std::string& pem_string) {
   BIO* bio = BIO_new_mem_buf(const_cast<char*>(pem_string.c_str()), -1);
   if (!bio)
-    return NULL;
+    return nullptr;
   BIO_set_mem_eof_return(bio, 0);
-  X509* x509 = PEM_read_bio_X509(bio, NULL, NULL, const_cast<char*>("\0"));
+  X509* x509 =
+      PEM_read_bio_X509(bio, nullptr, nullptr, const_cast<char*>("\0"));
   BIO_free(bio);  // Frees the BIO, but not the pointed-to string.
 
   if (!x509)
-    return NULL;
+    return nullptr;
 
   OpenSSLCertificate* ret = new OpenSSLCertificate(x509);
   X509_free(x509);
@@ -441,7 +441,7 @@ void OpenSSLCertificate::ToDER(Buffer* der_buffer) const {
 }
 
 void OpenSSLCertificate::AddReference() const {
-  RTC_DCHECK(x509_ != NULL);
+  RTC_DCHECK(x509_ != nullptr);
 #if defined(OPENSSL_IS_BORINGSSL)
   X509_up_ref(x509_);
 #else
@@ -476,8 +476,8 @@ int64_t OpenSSLCertificate::CertificateExpirationTime() const {
 OpenSSLIdentity::OpenSSLIdentity(OpenSSLKeyPair* key_pair,
                                  OpenSSLCertificate* certificate)
     : key_pair_(key_pair), certificate_(certificate) {
-  RTC_DCHECK(key_pair != NULL);
-  RTC_DCHECK(certificate != NULL);
+  RTC_DCHECK(key_pair != nullptr);
+  RTC_DCHECK(certificate != nullptr);
 }
 
 OpenSSLIdentity::~OpenSSLIdentity() = default;
@@ -493,7 +493,7 @@ OpenSSLIdentity* OpenSSLIdentity::GenerateInternal(
     delete key_pair;
   }
   LOG(LS_INFO) << "Identity generation failed";
-  return NULL;
+  return nullptr;
 }
 
 OpenSSLIdentity* OpenSSLIdentity::GenerateWithExpiration(
@@ -503,7 +503,7 @@ OpenSSLIdentity* OpenSSLIdentity::GenerateWithExpiration(
   SSLIdentityParams params;
   params.key_params = key_params;
   params.common_name = common_name;
-  time_t now = time(NULL);
+  time_t now = time(nullptr);
   params.not_before = now + kCertificateWindowInSeconds;
   params.not_after = now + certificate_lifetime;
   if (params.not_before > params.not_after)
diff --git a/webrtc/base/opensslidentity.h b/webrtc/base/opensslidentity.h
index e00978c92c..84716d1720 100644
--- a/webrtc/base/opensslidentity.h
+++ b/webrtc/base/opensslidentity.h
@@ -30,7 +30,7 @@ namespace rtc {
 class OpenSSLKeyPair {
  public:
   explicit OpenSSLKeyPair(EVP_PKEY* pkey) : pkey_(pkey) {
-    RTC_DCHECK(pkey_ != NULL);
+    RTC_DCHECK(pkey_ != nullptr);
   }
 
   static OpenSSLKeyPair* Generate(const KeyParams& key_params);
diff --git a/webrtc/base/opensslstreamadapter.cc b/webrtc/base/opensslstreamadapter.cc
index 45ff30ae9a..afcf39ffe1 100644
--- a/webrtc/base/opensslstreamadapter.cc
+++ b/webrtc/base/opensslstreamadapter.cc
@@ -86,70 +86,62 @@ struct SslCipherMapEntry {
 // (as available in OpenSSL if compiled with tracing enabled) or a similar
 // method.
 static const SslCipherMapEntry kSslCipherMap[] = {
-  // TLS v1.0 ciphersuites from RFC2246.
-  DEFINE_CIPHER_ENTRY_SSL3(RSA_RC4_128_SHA),
-  {SSL3_CK_RSA_DES_192_CBC3_SHA,
-      "TLS_RSA_WITH_3DES_EDE_CBC_SHA"},
+    // TLS v1.0 ciphersuites from RFC2246.
+    DEFINE_CIPHER_ENTRY_SSL3(RSA_RC4_128_SHA),
+    {SSL3_CK_RSA_DES_192_CBC3_SHA, "TLS_RSA_WITH_3DES_EDE_CBC_SHA"},
 
-  // AES ciphersuites from RFC3268.
-  {TLS1_CK_RSA_WITH_AES_128_SHA,
-      "TLS_RSA_WITH_AES_128_CBC_SHA"},
-  {TLS1_CK_DHE_RSA_WITH_AES_128_SHA,
-      "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"},
-  {TLS1_CK_RSA_WITH_AES_256_SHA,
-      "TLS_RSA_WITH_AES_256_CBC_SHA"},
-  {TLS1_CK_DHE_RSA_WITH_AES_256_SHA,
-      "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"},
+    // AES ciphersuites from RFC3268.
+    {TLS1_CK_RSA_WITH_AES_128_SHA, "TLS_RSA_WITH_AES_128_CBC_SHA"},
+    {TLS1_CK_DHE_RSA_WITH_AES_128_SHA, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"},
+    {TLS1_CK_RSA_WITH_AES_256_SHA, "TLS_RSA_WITH_AES_256_CBC_SHA"},
+    {TLS1_CK_DHE_RSA_WITH_AES_256_SHA, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"},
 
-  // ECC ciphersuites from RFC4492.
-  DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_RC4_128_SHA),
-  {TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA,
-      "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"},
-  DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_128_CBC_SHA),
-  DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_256_CBC_SHA),
+    // ECC ciphersuites from RFC4492.
+    DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_RC4_128_SHA),
+    {TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA,
+     "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"},
+    DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_128_CBC_SHA),
+    DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_256_CBC_SHA),
 
-  DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_RC4_128_SHA),
-  {TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA,
-      "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"},
-  DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_128_CBC_SHA),
-  DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_256_CBC_SHA),
+    DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_RC4_128_SHA),
+    {TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA,
+     "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"},
+    DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_128_CBC_SHA),
+    DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_256_CBC_SHA),
 
-  // TLS v1.2 ciphersuites.
-  {TLS1_CK_RSA_WITH_AES_128_SHA256,
-      "TLS_RSA_WITH_AES_128_CBC_SHA256"},
-  {TLS1_CK_RSA_WITH_AES_256_SHA256,
-      "TLS_RSA_WITH_AES_256_CBC_SHA256"},
-  {TLS1_CK_DHE_RSA_WITH_AES_128_SHA256,
-      "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"},
-  {TLS1_CK_DHE_RSA_WITH_AES_256_SHA256,
-      "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"},
+    // TLS v1.2 ciphersuites.
+    {TLS1_CK_RSA_WITH_AES_128_SHA256, "TLS_RSA_WITH_AES_128_CBC_SHA256"},
+    {TLS1_CK_RSA_WITH_AES_256_SHA256, "TLS_RSA_WITH_AES_256_CBC_SHA256"},
+    {TLS1_CK_DHE_RSA_WITH_AES_128_SHA256,
+     "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"},
+    {TLS1_CK_DHE_RSA_WITH_AES_256_SHA256,
+     "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"},
 
-  // TLS v1.2 GCM ciphersuites from RFC5288.
-  DEFINE_CIPHER_ENTRY_TLS1(RSA_WITH_AES_128_GCM_SHA256),
-  DEFINE_CIPHER_ENTRY_TLS1(RSA_WITH_AES_256_GCM_SHA384),
-  DEFINE_CIPHER_ENTRY_TLS1(DHE_RSA_WITH_AES_128_GCM_SHA256),
-  DEFINE_CIPHER_ENTRY_TLS1(DHE_RSA_WITH_AES_256_GCM_SHA384),
-  DEFINE_CIPHER_ENTRY_TLS1(DH_RSA_WITH_AES_128_GCM_SHA256),
-  DEFINE_CIPHER_ENTRY_TLS1(DH_RSA_WITH_AES_256_GCM_SHA384),
+    // TLS v1.2 GCM ciphersuites from RFC5288.
+    DEFINE_CIPHER_ENTRY_TLS1(RSA_WITH_AES_128_GCM_SHA256),
+    DEFINE_CIPHER_ENTRY_TLS1(RSA_WITH_AES_256_GCM_SHA384),
+    DEFINE_CIPHER_ENTRY_TLS1(DHE_RSA_WITH_AES_128_GCM_SHA256),
+    DEFINE_CIPHER_ENTRY_TLS1(DHE_RSA_WITH_AES_256_GCM_SHA384),
+    DEFINE_CIPHER_ENTRY_TLS1(DH_RSA_WITH_AES_128_GCM_SHA256),
+    DEFINE_CIPHER_ENTRY_TLS1(DH_RSA_WITH_AES_256_GCM_SHA384),
 
-  // ECDH HMAC based ciphersuites from RFC5289.
-  {TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256,
-      "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"},
-  {TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384,
-      "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"},
-  {TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256,
-      "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"},
-  {TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384,
-      "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"},
+    // ECDH HMAC based ciphersuites from RFC5289.
+    {TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256,
+     "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"},
+    {TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384,
+     "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"},
+    {TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256,
+     "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"},
+    {TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384,
+     "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"},
 
-  // ECDH GCM based ciphersuites from RFC5289.
-  DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_128_GCM_SHA256),
-  DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_256_GCM_SHA384),
-  DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_128_GCM_SHA256),
-  DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_256_GCM_SHA384),
+    // ECDH GCM based ciphersuites from RFC5289.
+    DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_128_GCM_SHA256),
+    DEFINE_CIPHER_ENTRY_TLS1(ECDHE_ECDSA_WITH_AES_256_GCM_SHA384),
+    DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_128_GCM_SHA256),
+    DEFINE_CIPHER_ENTRY_TLS1(ECDHE_RSA_WITH_AES_256_GCM_SHA384),
 
-  {0, NULL}
-};
+    {0, nullptr}};
 #endif  // #ifndef OPENSSL_IS_BORINGSSL
 
 #if defined(_MSC_VER)
@@ -175,24 +167,16 @@ static int stream_free(BIO* data);
 
 // TODO(davidben): This should be const once BoringSSL is assumed.
 static BIO_METHOD methods_stream = {
-  BIO_TYPE_BIO,
-  "stream",
-  stream_write,
-  stream_read,
-  stream_puts,
-  0,
-  stream_ctrl,
-  stream_new,
-  stream_free,
-  NULL,
+    BIO_TYPE_BIO, "stream",   stream_write, stream_read, stream_puts, 0,
+    stream_ctrl,  stream_new, stream_free,  nullptr,
 };
 
 static BIO_METHOD* BIO_s_stream() { return(&methods_stream); }
 
 static BIO* BIO_new_stream(StreamInterface* stream) {
   BIO* ret = BIO_new(BIO_s_stream());
-  if (ret == NULL)
-    return NULL;
+  if (ret == nullptr)
+    return nullptr;
   ret->ptr = stream;
   return ret;
 }
@@ -208,7 +192,7 @@ static int stream_new(BIO* b) {
 }
 
 static int stream_free(BIO* b) {
-  if (b == NULL)
+  if (b == nullptr)
     return 0;
   return 1;
 }
@@ -283,8 +267,8 @@ OpenSSLStreamAdapter::OpenSSLStreamAdapter(StreamInterface* stream)
       role_(SSL_CLIENT),
       ssl_read_needs_write_(false),
       ssl_write_needs_read_(false),
-      ssl_(NULL),
-      ssl_ctx_(NULL),
+      ssl_(nullptr),
+      ssl_ctx_(nullptr),
       ssl_mode_(SSL_MODE_TLS),
       ssl_max_version_(SSL_PROTOCOL_TLS_12) {}
 
@@ -387,7 +371,7 @@ bool OpenSSLStreamAdapter::GetSslCipherSuite(int* cipher_suite) {
     return false;
 
   const SSL_CIPHER* current_cipher = SSL_get_current_cipher(ssl_);
-  if (current_cipher == NULL) {
+  if (current_cipher == nullptr) {
     return false;
   }
 
@@ -516,13 +500,13 @@ void OpenSSLStreamAdapter::SetMode(SSLMode mode) {
 }
 
 void OpenSSLStreamAdapter::SetMaxProtocolVersion(SSLProtocolVersion version) {
-  RTC_DCHECK(ssl_ctx_ == NULL);
+  RTC_DCHECK(ssl_ctx_ == nullptr);
   ssl_max_version_ = version;
 }
 
 void OpenSSLStreamAdapter::SetInitialRetransmissionTimeout(
     int timeout_ms) {
-  RTC_DCHECK(ssl_ctx_ == NULL);
+  RTC_DCHECK(ssl_ctx_ == nullptr);
   dtls_handshake_timeout_ms_ = timeout_ms;
 }
 
@@ -780,10 +764,10 @@ int OpenSSLStreamAdapter::BeginSSL() {
   // The underlying stream has opened.
   LOG(LS_INFO) << "BeginSSL with peer.";
 
-  BIO* bio = NULL;
+  BIO* bio = nullptr;
 
   // First set up the context.
-  RTC_DCHECK(ssl_ctx_ == NULL);
+  RTC_DCHECK(ssl_ctx_ == nullptr);
   ssl_ctx_ = SetupSSLContext();
   if (!ssl_ctx_)
     return -1;
@@ -820,7 +804,7 @@ int OpenSSLStreamAdapter::BeginSSL() {
   // commonly supported. BoringSSL doesn't need explicit configuration and has
   // a reasonable default set.
   EC_KEY* ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
-  if (ecdh == NULL)
+  if (ecdh == nullptr)
     return -1;
   SSL_set_options(ssl_, SSL_OP_SINGLE_ECDH_USE);
   SSL_set_tmp_ecdh(ssl_, ecdh);
@@ -935,11 +919,11 @@ void OpenSSLStreamAdapter::Cleanup(uint8_t alert) {
     }
 #endif
     SSL_free(ssl_);
-    ssl_ = NULL;
+    ssl_ = nullptr;
   }
   if (ssl_ctx_) {
     SSL_CTX_free(ssl_ctx_);
-    ssl_ctx_ = NULL;
+    ssl_ctx_ = nullptr;
   }
   identity_.reset();
   peer_certificate_.reset();
@@ -961,7 +945,7 @@ void OpenSSLStreamAdapter::OnMessage(Message* msg) {
 }
 
 SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
-  SSL_CTX *ctx = NULL;
+  SSL_CTX* ctx = nullptr;
 
 #ifdef OPENSSL_IS_BORINGSSL
     ctx = SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ?
@@ -1026,8 +1010,8 @@ SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
   ctx = SSL_CTX_new(method);
 #endif  // OPENSSL_IS_BORINGSSL
 
-  if (ctx == NULL)
-    return NULL;
+  if (ctx == nullptr)
+    return nullptr;
 
 #ifdef OPENSSL_IS_BORINGSSL
   SSL_CTX_set_min_proto_version(ctx, ssl_mode_ == SSL_MODE_DTLS ?
@@ -1054,7 +1038,7 @@ SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
 
   if (identity_ && !identity_->ConfigureIdentity(ctx)) {
     SSL_CTX_free(ctx);
-    return NULL;
+    return nullptr;
   }
 
 #if !defined(NDEBUG)
@@ -1075,13 +1059,13 @@ SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
   // remove HMAC-SHA256 and HMAC-SHA384 cipher suites, not GCM cipher suites
   // with SHA256 or SHA384 as the handshake hash.
   // This matches the list of SSLClientSocketOpenSSL in Chromium.
-  SSL_CTX_set_cipher_list(ctx,
-      "DEFAULT:!NULL:!aNULL:!SHA256:!SHA384:!aECDH:!AESGCM+AES256:!aPSK");
+  SSL_CTX_set_cipher_list(
+      ctx, "DEFAULT:!NULL:!aNULL:!SHA256:!SHA384:!aECDH:!AESGCM+AES256:!aPSK");
 
   if (!srtp_ciphers_.empty()) {
     if (SSL_CTX_set_tlsext_use_srtp(ctx, srtp_ciphers_.c_str())) {
       SSL_CTX_free(ctx);
-      return NULL;
+      return nullptr;
     }
   }
 
diff --git a/webrtc/base/optionsfile_unittest.cc b/webrtc/base/optionsfile_unittest.cc
index 4eaf8015f2..69bd719638 100644
--- a/webrtc/base/optionsfile_unittest.cc
+++ b/webrtc/base/optionsfile_unittest.cc
@@ -47,7 +47,7 @@ class MAYBE_OptionsFileTest : public testing::Test {
  public:
   MAYBE_OptionsFileTest() {
     Pathname dir;
-    RTC_CHECK(Filesystem::GetTemporaryFolder(dir, true, NULL));
+    RTC_CHECK(Filesystem::GetTemporaryFolder(dir, true, nullptr));
     test_file_ = Filesystem::TempFilename(dir, ".testfile");
     OpenStore();
   }
diff --git a/webrtc/base/pathutils.cc b/webrtc/base/pathutils.cc
index 80df0ef9e8..f79c2980a4 100644
--- a/webrtc/base/pathutils.cc
+++ b/webrtc/base/pathutils.cc
@@ -43,7 +43,7 @@ const char DEFAULT_FOLDER_DELIM = '/';
 ///////////////////////////////////////////////////////////////////////////////
 
 bool Pathname::IsFolderDelimiter(char ch) {
-  return (NULL != ::strchr(FOLDER_DELIMS, ch));
+  return (nullptr != ::strchr(FOLDER_DELIMS, ch));
 }
 
 char Pathname::DefaultFolderDelimiter() {
diff --git a/webrtc/base/physicalsocketserver.cc b/webrtc/base/physicalsocketserver.cc
index 5b49638bd6..0d6cfa14f7 100644
--- a/webrtc/base/physicalsocketserver.cc
+++ b/webrtc/base/physicalsocketserver.cc
@@ -1118,15 +1118,15 @@ class EventDispatcher : public Dispatcher {
   }
 
   ~EventDispatcher() {
-    if (hev_ != NULL) {
+    if (hev_ != nullptr) {
       ss_->Remove(this);
       WSACloseEvent(hev_);
-      hev_ = NULL;
+      hev_ = nullptr;
     }
   }
 
   virtual void Signal() {
-    if (hev_ != NULL)
+    if (hev_ != nullptr)
       WSASetEvent(hev_);
   }
 
@@ -1268,7 +1268,7 @@ void PhysicalSocketServer::Remove(Dispatcher *pdispatcher) {
 bool PhysicalSocketServer::Wait(int cmsWait, bool process_io) {
   // Calculate timing information
 
-  struct timeval *ptvWait = NULL;
+  struct timeval* ptvWait = nullptr;
   struct timeval tvWait;
   struct timeval tvStop;
   if (cmsWait != kForever) {
@@ -1278,7 +1278,7 @@ bool PhysicalSocketServer::Wait(int cmsWait, bool process_io) {
     ptvWait = &tvWait;
 
     // Calculate when to return in a timeval
-    gettimeofday(&tvStop, NULL);
+    gettimeofday(&tvStop, nullptr);
     tvStop.tv_sec += tvWait.tv_sec;
     tvStop.tv_usec += tvWait.tv_usec;
     if (tvStop.tv_usec >= 1000000) {
@@ -1330,7 +1330,7 @@ bool PhysicalSocketServer::Wait(int cmsWait, bool process_io) {
     // < 0 means error
     // 0 means timeout
     // > 0 means count of descriptors ready
-    int n = select(fdmax + 1, &fdsRead, &fdsWrite, NULL, ptvWait);
+    int n = select(fdmax + 1, &fdsRead, &fdsWrite, nullptr, ptvWait);
 
     // If error, return error.
     if (n < 0) {
@@ -1405,7 +1405,7 @@ bool PhysicalSocketServer::Wait(int cmsWait, bool process_io) {
       ptvWait->tv_sec = 0;
       ptvWait->tv_usec = 0;
       struct timeval tvT;
-      gettimeofday(&tvT, NULL);
+      gettimeofday(&tvT, nullptr);
       if ((tvStop.tv_sec > tvT.tv_sec)
           || ((tvStop.tv_sec == tvT.tv_sec)
               && (tvStop.tv_usec > tvT.tv_usec))) {
@@ -1473,7 +1473,7 @@ bool PhysicalSocketServer::InstallSignal(int signum, void (*handler)(int)) {
 #else
   act.sa_flags = 0;
 #endif
-  if (sigaction(signum, &act, NULL) != 0) {
+  if (sigaction(signum, &act, nullptr) != 0) {
     LOG_ERR(LS_ERROR) << "Couldn't set sigaction";
     return false;
   }
diff --git a/webrtc/base/physicalsocketserver_unittest.cc b/webrtc/base/physicalsocketserver_unittest.cc
index 63d2f0d92c..0eea1d55c1 100644
--- a/webrtc/base/physicalsocketserver_unittest.cc
+++ b/webrtc/base/physicalsocketserver_unittest.cc
@@ -483,9 +483,9 @@ class PosixSignalDeliveryTest : public testing::Test {
   }
 
   void TearDown() {
-    ss_.reset(NULL);
+    ss_.reset(nullptr);
     signals_received_.clear();
-    signaled_thread_ = NULL;
+    signaled_thread_ = nullptr;
   }
 
   bool ExpectSignal(int signum) {
@@ -518,7 +518,7 @@ class PosixSignalDeliveryTest : public testing::Test {
 };
 
 std::vector<int> PosixSignalDeliveryTest::signals_received_;
-Thread *PosixSignalDeliveryTest::signaled_thread_ = NULL;
+Thread* PosixSignalDeliveryTest::signaled_thread_ = nullptr;
 
 // Test receiving a synchronous signal while not in Wait() and then entering
 // Wait() afterwards.
@@ -563,7 +563,7 @@ class RaiseSigTermRunnable : public Runnable {
     // be delivered to us.
     sigset_t mask;
     sigemptyset(&mask);
-    pthread_sigmask(SIG_SETMASK, &mask, NULL);
+    pthread_sigmask(SIG_SETMASK, &mask, nullptr);
 
     // Raise it.
     raise(SIGTERM);
@@ -578,7 +578,7 @@ TEST_F(PosixSignalDeliveryTest, SignalOnDifferentThread) {
   sigset_t mask;
   sigemptyset(&mask);
   sigaddset(&mask, SIGTERM);
-  EXPECT_EQ(0, pthread_sigmask(SIG_SETMASK, &mask, NULL));
+  EXPECT_EQ(0, pthread_sigmask(SIG_SETMASK, &mask, nullptr));
   // Start a new thread that raises it. It will have to be delivered to that
   // thread. Our implementation should safely handle it and dispatch
   // RecordSignal() on this thread.
diff --git a/webrtc/base/platform_file.cc b/webrtc/base/platform_file.cc
index a41324fcf9..a00543cc33 100644
--- a/webrtc/base/platform_file.cc
+++ b/webrtc/base/platform_file.cc
@@ -26,10 +26,10 @@ const PlatformFile kInvalidPlatformFileValue = INVALID_HANDLE_VALUE;
 
 FILE* FdopenPlatformFileForWriting(PlatformFile file) {
   if (file == kInvalidPlatformFileValue)
-    return NULL;
+    return nullptr;
   int fd = _open_osfhandle(reinterpret_cast<intptr_t>(file), 0);
   if (fd < 0)
-    return NULL;
+    return nullptr;
 
   return _fdopen(fd, "w");
 }
diff --git a/webrtc/base/platform_thread.cc b/webrtc/base/platform_thread.cc
index 525f0ddf08..52f88106b7 100644
--- a/webrtc/base/platform_thread.cc
+++ b/webrtc/base/platform_thread.cc
@@ -149,7 +149,7 @@ void PlatformThread::Start() {
   // See bug 2902 for background on STACK_SIZE_PARAM_IS_A_RESERVATION.
   // Set the reserved stack stack size to 1M, which is the default on Windows
   // and Linux.
-  thread_ = ::CreateThread(NULL, 1024 * 1024, &StartThread, this,
+  thread_ = ::CreateThread(nullptr, 1024 * 1024, &StartThread, this,
                            STACK_SIZE_PARAM_IS_A_RESERVATION, &thread_id_);
   RTC_CHECK(thread_) << "CreateThread failed";
   RTC_DCHECK(thread_id_);
diff --git a/webrtc/base/proxy_unittest.cc b/webrtc/base/proxy_unittest.cc
index 5c5a7489f7..b72d228ea0 100644
--- a/webrtc/base/proxy_unittest.cc
+++ b/webrtc/base/proxy_unittest.cc
@@ -31,16 +31,14 @@ static const SocketAddress kBogusProxyIntAddr("1.2.3.4", 999);
 // Sets up a virtual socket server and HTTPS/SOCKS5 proxy servers.
 class ProxyTest : public testing::Test {
  public:
-  ProxyTest() : ss_(new rtc::VirtualSocketServer(NULL)) {
+  ProxyTest() : ss_(new rtc::VirtualSocketServer(nullptr)) {
     Thread::Current()->set_socketserver(ss_.get());
     socks_.reset(new rtc::SocksProxyServer(
         ss_.get(), kSocksProxyIntAddr, ss_.get(), kSocksProxyExtAddr));
     https_.reset(new rtc::HttpListenServer());
     https_->Listen(kHttpsProxyIntAddr);
   }
-  ~ProxyTest() {
-    Thread::Current()->set_socketserver(NULL);
-  }
+  ~ProxyTest() { Thread::Current()->set_socketserver(nullptr); }
 
   rtc::SocketServer* ss() { return ss_.get(); }
 
@@ -65,7 +63,7 @@ TEST_F(ProxyTest, TestSocks5Connect) {
 
   rtc::AsyncTCPSocket* packet_socket = rtc::AsyncTCPSocket::Create(
       proxy_socket, SocketAddress(INADDR_ANY, 0), server.address());
-  EXPECT_TRUE(packet_socket != NULL);
+  EXPECT_TRUE(packet_socket != nullptr);
   rtc::TestClient client(packet_socket);
 
   EXPECT_EQ(Socket::CS_CONNECTING, proxy_socket->GetState());
@@ -73,6 +71,6 @@ TEST_F(ProxyTest, TestSocks5Connect) {
   EXPECT_EQ(Socket::CS_CONNECTED, proxy_socket->GetState());
   EXPECT_EQ(server.address(), client.remote_address());
   client.Send("foo", 3);
-  EXPECT_TRUE(client.CheckNextPacket("foo", 3, NULL));
+  EXPECT_TRUE(client.CheckNextPacket("foo", 3, nullptr));
   EXPECT_TRUE(client.CheckNoPacket());
 }
diff --git a/webrtc/base/proxyserver.cc b/webrtc/base/proxyserver.cc
index 66cf695755..713a98679a 100644
--- a/webrtc/base/proxyserver.cc
+++ b/webrtc/base/proxyserver.cc
@@ -24,7 +24,7 @@ ProxyServer::ProxyServer(
     : ext_factory_(ext_factory), ext_ip_(ext_ip.ipaddr(), 0),  // strip off port
       server_socket_(int_factory->CreateAsyncSocket(int_addr.family(),
                                                     SOCK_STREAM)) {
-  RTC_DCHECK(server_socket_.get() != NULL);
+  RTC_DCHECK(server_socket_.get() != nullptr);
   RTC_DCHECK(int_addr.family() == AF_INET || int_addr.family() == AF_INET6);
   server_socket_->Bind(int_addr);
   server_socket_->Listen(5);
@@ -43,8 +43,8 @@ SocketAddress ProxyServer::GetServerAddress() {
 }
 
 void ProxyServer::OnAcceptEvent(AsyncSocket* socket) {
-  RTC_DCHECK(socket != NULL && socket == server_socket_.get());
-  AsyncSocket* int_socket = socket->Accept(NULL);
+  RTC_DCHECK(socket != nullptr && socket == server_socket_.get());
+  AsyncSocket* int_socket = socket->Accept(nullptr);
   AsyncProxyServerSocket* wrapped_socket = WrapSocket(int_socket);
   AsyncSocket* ext_socket = ext_factory_->CreateAsyncSocket(ext_ip_.family(),
                                                             SOCK_STREAM);
@@ -84,7 +84,7 @@ ProxyBinding::~ProxyBinding() = default;
 
 void ProxyBinding::OnConnectRequest(AsyncProxyServerSocket* socket,
                                    const SocketAddress& addr) {
-  RTC_DCHECK(!connected_ && ext_socket_.get() != NULL);
+  RTC_DCHECK(!connected_ && ext_socket_.get() != nullptr);
   ext_socket_->Connect(addr);
   // TODO: handle errors here
 }
@@ -103,7 +103,7 @@ void ProxyBinding::OnInternalClose(AsyncSocket* socket, int err) {
 }
 
 void ProxyBinding::OnExternalConnect(AsyncSocket* socket) {
-  RTC_DCHECK(socket != NULL);
+  RTC_DCHECK(socket != nullptr);
   connected_ = true;
   int_socket_->SendConnectResult(0, socket->GetRemoteAddress());
 }
@@ -126,7 +126,7 @@ void ProxyBinding::OnExternalClose(AsyncSocket* socket, int err) {
 
 void ProxyBinding::Read(AsyncSocket* socket, FifoBuffer* buffer) {
   // Only read if the buffer is empty.
-  RTC_DCHECK(socket != NULL);
+  RTC_DCHECK(socket != nullptr);
   size_t size;
   int read;
   if (buffer->GetBuffered(&size) && size == 0) {
@@ -137,7 +137,7 @@ void ProxyBinding::Read(AsyncSocket* socket, FifoBuffer* buffer) {
 }
 
 void ProxyBinding::Write(AsyncSocket* socket, FifoBuffer* buffer) {
-  RTC_DCHECK(socket != NULL);
+  RTC_DCHECK(socket != nullptr);
   size_t size;
   int written;
   const void* p = buffer->GetReadData(&size);
diff --git a/webrtc/base/scoped_autorelease_pool.h b/webrtc/base/scoped_autorelease_pool.h
index 14a5c5f8d9..2e0a2042db 100644
--- a/webrtc/base/scoped_autorelease_pool.h
+++ b/webrtc/base/scoped_autorelease_pool.h
@@ -43,9 +43,9 @@ class ScopedAutoreleasePool {
   // as a stack object" discipline.
   //
   // Note: new is declared as "throw()" to get around a gcc warning about new
-  // returning NULL, but this method will never get called and therefore will
+  // returning null, but this method will never get called and therefore will
   // never actually throw any exception.
-  void* operator new(size_t size) throw() { return NULL; }
+  void* operator new(size_t size) throw() { return nullptr; }
   void operator delete (void* ptr) {}
 
   NSAutoreleasePool* pool_;
diff --git a/webrtc/base/scoped_ref_ptr.h b/webrtc/base/scoped_ref_ptr.h
index df669121dc..26aff03504 100644
--- a/webrtc/base/scoped_ref_ptr.h
+++ b/webrtc/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 @@ namespace rtc {
 template <class T>
 class scoped_refptr {
  public:
-  scoped_refptr() : ptr_(NULL) {
-  }
+  scoped_refptr() : ptr_(nullptr) {}
 
   scoped_refptr(T* p) : ptr_(p) {
     if (ptr_)
@@ -106,12 +105,12 @@ class scoped_refptr {
 
   // Release a pointer.
   // The return value is the current pointer held by this object.
-  // If this object holds a NULL pointer, the return value is NULL.
-  // After this operation, this object will hold a NULL pointer,
+  // If this object holds a null pointer, the return value is null.
+  // After this operation, this object will hold a null pointer,
   // and will not own the object any more.
   T* release() {
     T* retVal = ptr_;
-    ptr_ = NULL;
+    ptr_ = nullptr;
     return retVal;
   }
 
diff --git a/webrtc/base/sharedexclusivelock_unittest.cc b/webrtc/base/sharedexclusivelock_unittest.cc
index 132bbd9f29..e0462ffa11 100644
--- a/webrtc/base/sharedexclusivelock_unittest.cc
+++ b/webrtc/base/sharedexclusivelock_unittest.cc
@@ -61,7 +61,7 @@ class ReadTask : public SharedExclusiveTask {
  private:
   virtual void OnMessage(Message* message) {
     RTC_CHECK(rtc::Thread::Current() == worker_thread_.get());
-    RTC_CHECK(message != NULL);
+    RTC_CHECK(message != nullptr);
     RTC_CHECK(message->message_id == kMsgRead);
 
     TypedMessageData<int*>* message_data =
@@ -73,7 +73,7 @@ class ReadTask : public SharedExclusiveTask {
       done_->Set();
     }
     delete message->pdata;
-    message->pdata = NULL;
+    message->pdata = nullptr;
   }
 };
 
@@ -91,7 +91,7 @@ class WriteTask : public SharedExclusiveTask {
  private:
   virtual void OnMessage(Message* message) {
     RTC_CHECK(rtc::Thread::Current() == worker_thread_.get());
-    RTC_CHECK(message != NULL);
+    RTC_CHECK(message != nullptr);
     RTC_CHECK(message->message_id == kMsgWrite);
 
     TypedMessageData<int>* message_data =
@@ -103,7 +103,7 @@ class WriteTask : public SharedExclusiveTask {
       done_->Set();
     }
     delete message->pdata;
-    message->pdata = NULL;
+    message->pdata = nullptr;
   }
 };
 
diff --git a/webrtc/base/signalthread.cc b/webrtc/base/signalthread.cc
index 40df02f7b5..be2741e764 100644
--- a/webrtc/base/signalthread.cc
+++ b/webrtc/base/signalthread.cc
@@ -113,7 +113,7 @@ void SignalThread::OnMessage(Message *msg) {
       // SignalThread this makes an assert in thread.cc fire.
       //
       // Calling Stop() on the worker ensures that the OS thread that underlies
-      // the worker will finish, and will be set to NULL, enabling us to call
+      // the worker will finish, and will be set to null, enabling us to call
       // Start() again.
       worker_.Stop();
       SignalWorkDone(this);
@@ -144,7 +144,7 @@ void SignalThread::Run() {
 
 void SignalThread::OnMainThreadDestroyed() {
   EnterExit ee(this);
-  main_ = NULL;
+  main_ = nullptr;
 }
 
 bool SignalThread::Worker::IsProcessingMessages() {
diff --git a/webrtc/base/signalthread_unittest.cc b/webrtc/base/signalthread_unittest.cc
index 0029acf5d9..15f665a122 100644
--- a/webrtc/base/signalthread_unittest.cc
+++ b/webrtc/base/signalthread_unittest.cc
@@ -36,7 +36,7 @@ class SignalThreadTest : public testing::Test, public sigslot::has_slots<> {
 
    protected:
     virtual void OnWorkStart() {
-      ASSERT_TRUE(harness_ != NULL);
+      ASSERT_TRUE(harness_ != nullptr);
       ++harness_->thread_started_;
       EXPECT_EQ(harness_->main_thread_, Thread::Current());
       EXPECT_FALSE(worker()->RunningForTest());  // not started yet
diff --git a/webrtc/base/sigslot.h b/webrtc/base/sigslot.h
index b1a6e8cba3..4534ec9dae 100644
--- a/webrtc/base/sigslot.h
+++ b/webrtc/base/sigslot.h
@@ -216,13 +216,9 @@ namespace sigslot {
 	class multi_threaded_local
 	{
 	public:
-		multi_threaded_local()
-		{
-			pthread_mutex_init(&m_mutex, NULL);
-		}
-		multi_threaded_local(const multi_threaded_local&)
-		{
-			pthread_mutex_init(&m_mutex, NULL);
+		multi_threaded_local() { pthread_mutex_init(&m_mutex, nullptr); }
+		multi_threaded_local(const multi_threaded_local&) {
+			pthread_mutex_init(&m_mutex, nullptr);
 		}
 		~multi_threaded_local()
 		{
diff --git a/webrtc/base/sigslot_unittest.cc b/webrtc/base/sigslot_unittest.cc
index d7d64b4393..cb77336310 100644
--- a/webrtc/base/sigslot_unittest.cc
+++ b/webrtc/base/sigslot_unittest.cc
@@ -32,8 +32,7 @@ template<class slot_policy = sigslot::single_threaded,
          class signal_policy = sigslot::single_threaded>
 class SigslotReceiver : public sigslot::has_slots<slot_policy> {
  public:
-  SigslotReceiver() : signal_(NULL), signal_count_(0) {
-  }
+  SigslotReceiver() : signal_(nullptr), signal_count_(0) {}
   ~SigslotReceiver() {
   }
 
@@ -47,7 +46,7 @@ class SigslotReceiver : public sigslot::has_slots<slot_policy> {
   void Disconnect() {
     if (!signal_) return;
     signal_->disconnect(this);
-    signal_ = NULL;
+    signal_ = nullptr;
   }
   void OnSignal() {
     ++signal_count_;
diff --git a/webrtc/base/sigslottester_unittest.cc b/webrtc/base/sigslottester_unittest.cc
index 778e352f43..00b2577109 100755
--- a/webrtc/base/sigslottester_unittest.cc
+++ b/webrtc/base/sigslottester_unittest.cc
@@ -68,9 +68,9 @@ TEST(SigslotTester, TestSignalWithPointerToConstArgs) {
   SigslotTester1<const std::string*, const std::string*> slot1(&source1,
                                                                &capture1);
   EXPECT_EQ(0, slot1.callback_count());
-  source1.emit(NULL);
+  source1.emit(nullptr);
   EXPECT_EQ(1, slot1.callback_count());
-  EXPECT_EQ(NULL, capture1);
+  EXPECT_EQ(nullptr, capture1);
 }
 
 TEST(SigslotTester, TestSignalWithConstPointerArgs) {
@@ -78,9 +78,9 @@ TEST(SigslotTester, TestSignalWithConstPointerArgs) {
   std::string* capture1;
   SigslotTester1<std::string* const, std::string*> slot1(&source1, &capture1);
   EXPECT_EQ(0, slot1.callback_count());
-  source1.emit(NULL);
+  source1.emit(nullptr);
   EXPECT_EQ(1, slot1.callback_count());
-  EXPECT_EQ(NULL, capture1);
+  EXPECT_EQ(nullptr, capture1);
 }
 
 }  // namespace rtc
diff --git a/webrtc/base/socket_unittest.cc b/webrtc/base/socket_unittest.cc
index 16edf905e5..4a59a169b8 100644
--- a/webrtc/base/socket_unittest.cc
+++ b/webrtc/base/socket_unittest.cc
@@ -224,7 +224,7 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
 
   // Ensure no pending server connections, since we haven't done anything yet.
   EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
-  EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+  EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
   EXPECT_TRUE(accept_addr.IsNil());
 
   // Attempt connect to listening socket.
@@ -335,7 +335,7 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
 
   // Should be no pending server connections.
   EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
-  EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+  EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
   EXPECT_EQ(IPAddress(), accept_addr.ipaddr());
 }
 
@@ -376,7 +376,7 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
   EXPECT_TRUE(client->GetRemoteAddress().IsNil());
   // Should be no pending server connections.
   EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
-  EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+  EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
   EXPECT_TRUE(accept_addr.IsNil());
 }
 
diff --git a/webrtc/base/socketadapters.cc b/webrtc/base/socketadapters.cc
index 5f01b2f1cc..060029c1c7 100644
--- a/webrtc/base/socketadapters.cc
+++ b/webrtc/base/socketadapters.cc
@@ -281,7 +281,7 @@ int AsyncHttpsProxySocket::Close() {
   state_ = PS_ERROR;
   dest_.Clear();
   delete context_;
-  context_ = NULL;
+  context_ = nullptr;
   return BufferedReadAdapter::Close();
 }
 
diff --git a/webrtc/base/socketaddress.cc b/webrtc/base/socketaddress.cc
index 8cb53c5d57..d931f72b21 100644
--- a/webrtc/base/socketaddress.cc
+++ b/webrtc/base/socketaddress.cc
@@ -184,7 +184,7 @@ bool SocketAddress::FromString(const std::string& str) {
     if (closebracket != std::string::npos) {
       std::string::size_type colon = str.find(':', closebracket);
       if (colon != std::string::npos && colon > closebracket) {
-        SetPort(strtoul(str.substr(colon + 1).c_str(), NULL, 10));
+        SetPort(strtoul(str.substr(colon + 1).c_str(), nullptr, 10));
         SetIP(str.substr(1, closebracket - 1));
       } else {
         return false;
@@ -194,7 +194,7 @@ bool SocketAddress::FromString(const std::string& str) {
     std::string::size_type pos = str.find(':');
     if (std::string::npos == pos)
       return false;
-    SetPort(strtoul(str.substr(pos + 1).c_str(), NULL, 10));
+    SetPort(strtoul(str.substr(pos + 1).c_str(), nullptr, 10));
     SetIP(str.substr(0, pos));
   }
   return true;
diff --git a/webrtc/base/socketaddress_unittest.cc b/webrtc/base/socketaddress_unittest.cc
index e235447dc7..072918e88c 100644
--- a/webrtc/base/socketaddress_unittest.cc
+++ b/webrtc/base/socketaddress_unittest.cc
@@ -237,7 +237,7 @@ TEST(SocketAddressTest, TestToFromSockAddrStorage) {
   EXPECT_FALSE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
   EXPECT_EQ(from, addr);
 
-  EXPECT_FALSE(SocketAddressFromSockAddrStorage(addr_storage, NULL));
+  EXPECT_FALSE(SocketAddressFromSockAddrStorage(addr_storage, nullptr));
 }
 
 bool AreEqual(const SocketAddress& addr1,
diff --git a/webrtc/base/socketstream.cc b/webrtc/base/socketstream.cc
index 9407c96795..a218dd803a 100644
--- a/webrtc/base/socketstream.cc
+++ b/webrtc/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 @@ AsyncSocket* SocketStream::Detach() {
     socket_->SignalReadEvent.disconnect(this);
     socket_->SignalWriteEvent.disconnect(this);
     socket_->SignalCloseEvent.disconnect(this);
-    socket_ = NULL;
+    socket_ = nullptr;
   }
   return socket;
 }
 
 StreamState SocketStream::GetState() const {
-  RTC_DCHECK(socket_ != NULL);
+  RTC_DCHECK(socket_ != nullptr);
   switch (socket_->GetState()) {
     case Socket::CS_CONNECTED:
       return SS_OPEN;
@@ -61,7 +61,7 @@ StreamState SocketStream::GetState() const {
 
 StreamResult SocketStream::Read(void* buffer, size_t buffer_len,
                                 size_t* read, int* error) {
-  RTC_DCHECK(socket_ != NULL);
+  RTC_DCHECK(socket_ != nullptr);
   int result = socket_->Recv(buffer, buffer_len, nullptr);
   if (result < 0) {
     if (socket_->IsBlocking())
@@ -80,7 +80,7 @@ StreamResult SocketStream::Read(void* buffer, size_t buffer_len,
 
 StreamResult SocketStream::Write(const void* data, size_t data_len,
                                  size_t* written, int* error) {
-  RTC_DCHECK(socket_ != NULL);
+  RTC_DCHECK(socket_ != nullptr);
   int result = socket_->Send(data, data_len);
   if (result < 0) {
     if (socket_->IsBlocking())
@@ -95,7 +95,7 @@ StreamResult SocketStream::Write(const void* data, size_t data_len,
 }
 
 void SocketStream::Close() {
-  RTC_DCHECK(socket_ != NULL);
+  RTC_DCHECK(socket_ != nullptr);
   socket_->Close();
 }
 
diff --git a/webrtc/base/ssladapter.h b/webrtc/base/ssladapter.h
index 57e8ee9cc5..0317544f92 100644
--- a/webrtc/base/ssladapter.h
+++ b/webrtc/base/ssladapter.h
@@ -34,7 +34,7 @@ class SSLAdapter : public AsyncSocketAdapter {
   // negotiation will begin as soon as the socket connects.
   virtual int StartSSL(const char* hostname, bool restartable) = 0;
 
-  // Create the default SSL adapter for this platform. On failure, returns NULL
+  // Create the default SSL adapter for this platform. On failure, returns null
   // and deletes |socket|. Otherwise, the returned SSLAdapter takes ownership
   // of |socket|.
   static SSLAdapter* Create(AsyncSocket* socket);
@@ -50,7 +50,7 @@ typedef bool (*VerificationCallback)(void* cert);
 
 // Call this on the main thread, before using SSL.
 // Call CleanupSSLThread when finished with SSL.
-bool InitializeSSL(VerificationCallback callback = NULL);
+bool InitializeSSL(VerificationCallback callback = nullptr);
 
 // Call to initialize additional threads.
 bool InitializeSSLThread();
diff --git a/webrtc/base/ssladapter_unittest.cc b/webrtc/base/ssladapter_unittest.cc
index c591f19658..c8afbe6a75 100644
--- a/webrtc/base/ssladapter_unittest.cc
+++ b/webrtc/base/ssladapter_unittest.cc
@@ -165,8 +165,8 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> {
   }
 
   int Send(const std::string& message) {
-    if (ssl_stream_adapter_ == NULL
-        || ssl_stream_adapter_->GetState() != rtc::SS_OPEN) {
+    if (ssl_stream_adapter_ == nullptr ||
+        ssl_stream_adapter_->GetState() != rtc::SS_OPEN) {
       // No connection yet.
       return -1;
     }
@@ -187,7 +187,7 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> {
 
   void AcceptConnection(const rtc::SocketAddress& address) {
     // Only a single connection is supported.
-    ASSERT_TRUE(ssl_stream_adapter_ == NULL);
+    ASSERT_TRUE(ssl_stream_adapter_ == nullptr);
 
     // This is only for DTLS.
     ASSERT_EQ(rtc::SSL_MODE_DTLS, ssl_mode_);
@@ -202,9 +202,9 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> {
 
   void OnServerSocketReadEvent(rtc::AsyncSocket* socket) {
     // Only a single connection is supported.
-    ASSERT_TRUE(ssl_stream_adapter_ == NULL);
+    ASSERT_TRUE(ssl_stream_adapter_ == nullptr);
 
-    DoHandshake(server_socket_->Accept(NULL));
+    DoHandshake(server_socket_->Accept(nullptr));
   }
 
   void OnSSLStreamAdapterEvent(rtc::StreamInterface* stream, int sig, int err) {
@@ -274,7 +274,7 @@ class SSLAdapterTestBase : public testing::Test,
   explicit SSLAdapterTestBase(const rtc::SSLMode& ssl_mode,
                               const rtc::KeyParams& key_params)
       : ssl_mode_(ssl_mode),
-        ss_scope_(new rtc::VirtualSocketServer(NULL)),
+        ss_scope_(new rtc::VirtualSocketServer(nullptr)),
         server_(new SSLAdapterTestDummyServer(ssl_mode_, key_params)),
         client_(new SSLAdapterTestDummyClient(ssl_mode_)),
         handshake_wait_(kTimeout) {}
diff --git a/webrtc/base/sslfingerprint.cc b/webrtc/base/sslfingerprint.cc
index e172a2c304..bd15743a8e 100644
--- a/webrtc/base/sslfingerprint.cc
+++ b/webrtc/base/sslfingerprint.cc
@@ -23,7 +23,7 @@ namespace rtc {
 SSLFingerprint* SSLFingerprint::Create(
     const std::string& algorithm, const rtc::SSLIdentity* identity) {
   if (!identity) {
-    return NULL;
+    return nullptr;
   }
 
   return Create(algorithm, &(identity->certificate()));
@@ -36,7 +36,7 @@ SSLFingerprint* SSLFingerprint::Create(
   bool ret = cert->ComputeDigest(
       algorithm, digest_val, sizeof(digest_val), &digest_len);
   if (!ret) {
-    return NULL;
+    return nullptr;
   }
 
   return new SSLFingerprint(algorithm, digest_val, digest_len);
@@ -45,10 +45,10 @@ SSLFingerprint* SSLFingerprint::Create(
 SSLFingerprint* SSLFingerprint::CreateFromRfc4572(
     const std::string& algorithm, const std::string& fingerprint) {
   if (algorithm.empty() || !rtc::IsFips180DigestAlgorithm(algorithm))
-    return NULL;
+    return nullptr;
 
   if (fingerprint.empty())
-    return NULL;
+    return nullptr;
 
   size_t value_len;
   char value[rtc::MessageDigest::kMaxSize];
@@ -57,7 +57,7 @@ SSLFingerprint* SSLFingerprint::CreateFromRfc4572(
                                                    fingerprint.length(),
                                                    ':');
   if (!value_len)
-    return NULL;
+    return nullptr;
 
   return new SSLFingerprint(algorithm, reinterpret_cast<uint8_t*>(value),
                             value_len);
diff --git a/webrtc/base/sslidentity.h b/webrtc/base/sslidentity.h
index 181174b265..263d0dcd03 100644
--- a/webrtc/base/sslidentity.h
+++ b/webrtc/base/sslidentity.h
@@ -51,9 +51,9 @@ struct SSLCertificateStats {
 class SSLCertificate {
  public:
   // Parses and builds a certificate from a PEM encoded string.
-  // Returns NULL on failure.
+  // Returns null on failure.
   // The length of the string representation of the certificate is
-  // stored in *pem_length if it is non-NULL, and only if
+  // stored in *pem_length if it is non-null, and only if
   // parsing was successful.
   // Caller is responsible for freeing the returned object.
   static SSLCertificate* FromPEMString(const std::string& pem_string);
@@ -216,7 +216,7 @@ class SSLIdentity {
   // parameters are defined in |key_param|. The certificate's lifetime in
   // seconds from the current time is defined in |certificate_lifetime|; it
   // should be a non-negative number.
-  // Returns NULL on failure.
+  // Returns null on failure.
   // Caller is responsible for freeing the returned object.
   static SSLIdentity* GenerateWithExpiration(const std::string& common_name,
                                              const KeyParams& key_param,
diff --git a/webrtc/base/sslstreamadapter.h b/webrtc/base/sslstreamadapter.h
index e4df77436c..e1d1d85215 100644
--- a/webrtc/base/sslstreamadapter.h
+++ b/webrtc/base/sslstreamadapter.h
@@ -211,7 +211,7 @@ class SSLStreamAdapter : public StreamAdapterInterface {
   //                        part of the RFC defining each exporter
   //                        usage (IN)
   // context/context_len -- a context to bind to for this connection;
-  //                        optional, can be NULL, 0 (IN)
+  //                        optional, can be null, 0 (IN)
   // use_context         -- whether to use the context value
   //                        (needed to distinguish no context from
   //                        zero-length ones).
diff --git a/webrtc/base/sslstreamadapter_unittest.cc b/webrtc/base/sslstreamadapter_unittest.cc
index 737118aa2b..b5184e6d44 100644
--- a/webrtc/base/sslstreamadapter_unittest.cc
+++ b/webrtc/base/sslstreamadapter_unittest.cc
@@ -225,10 +225,10 @@ class SSLStreamAdapterTestBase : public testing::Test,
         client_private_key_pem_(client_private_key_pem),
         client_key_type_(client_key_type),
         server_key_type_(server_key_type),
-        client_stream_(NULL),
-        server_stream_(NULL),
-        client_identity_(NULL),
-        server_identity_(NULL),
+        client_stream_(nullptr),
+        server_stream_(nullptr),
+        client_identity_(nullptr),
+        server_identity_(nullptr),
         delay_(0),
         mtu_(1460),
         loss_(0),
@@ -627,7 +627,7 @@ class SSLStreamAdapterTestTLS
     send_stream_.ReserveSize(size);
     for (int i = 0; i < size; ++i) {
       char ch = static_cast<char>(i);
-      send_stream_.Write(&ch, 1, NULL, NULL);
+      send_stream_.Write(&ch, 1, nullptr, nullptr);
     }
     send_stream_.Rewind();
 
@@ -660,7 +660,7 @@ class SSLStreamAdapterTestTLS
 
     for (;;) {
       send_stream_.GetPosition(&position);
-      if (send_stream_.Read(block, sizeof(block), &tosend, NULL) !=
+      if (send_stream_.Read(block, sizeof(block), &tosend, nullptr) !=
           rtc::SR_EOS) {
         rv = client_ssl_->Write(block, tosend, &sent, 0);
 
@@ -706,7 +706,7 @@ class SSLStreamAdapterTestTLS
       ASSERT_EQ(rtc::SR_SUCCESS, r);
       LOG(LS_VERBOSE) << "Read " << bread;
 
-      recv_stream_.Write(buffer, bread, NULL, NULL);
+      recv_stream_.Write(buffer, bread, nullptr, nullptr);
     }
   }
 
@@ -896,11 +896,11 @@ TEST_P(SSLStreamAdapterTestTLS, ReadWriteAfterClose) {
   size_t dummy;
 
   // It's an error to write after closed.
-  rv = client_ssl_->Write(block, sizeof(block), &dummy, NULL);
+  rv = client_ssl_->Write(block, sizeof(block), &dummy, nullptr);
   ASSERT_EQ(rtc::SR_ERROR, rv);
 
   // But after closed read gives you EOS.
-  rv = client_ssl_->Read(block, sizeof(block), &dummy, NULL);
+  rv = client_ssl_->Read(block, sizeof(block), &dummy, nullptr);
   ASSERT_EQ(rtc::SR_EOS, rv);
 };
 
diff --git a/webrtc/base/stream.cc b/webrtc/base/stream.cc
index f58d3673e9..67ef104044 100644
--- a/webrtc/base/stream.cc
+++ b/webrtc/base/stream.cc
@@ -78,7 +78,7 @@ StreamResult StreamInterface::ReadLine(std::string* line) {
   StreamResult result = SR_SUCCESS;
   while (true) {
     char ch;
-    result = Read(&ch, sizeof(ch), NULL, NULL);
+    result = Read(&ch, sizeof(ch), nullptr, nullptr);
     if (result != SR_SUCCESS) {
       break;
     }
@@ -103,11 +103,11 @@ void StreamInterface::PostEvent(int events, int err) {
 }
 
 const void* StreamInterface::GetReadData(size_t* data_len) {
-  return NULL;
+  return nullptr;
 }
 
 void* StreamInterface::GetWriteBuffer(size_t* buf_len) {
-  return NULL;
+  return nullptr;
 }
 
 bool StreamInterface::SetPosition(size_t position) {
@@ -156,7 +156,7 @@ void StreamInterface::OnMessage(Message* msg) {
 StreamAdapterInterface::StreamAdapterInterface(StreamInterface* stream,
                                                bool owned)
     : stream_(stream), owned_(owned) {
-  if (NULL != stream_)
+  if (nullptr != stream_)
     stream_->SignalEvent.connect(this, &StreamAdapterInterface::OnEvent);
 }
 
@@ -208,21 +208,21 @@ bool StreamAdapterInterface::Flush() {
 }
 
 void StreamAdapterInterface::Attach(StreamInterface* stream, bool owned) {
-  if (NULL != stream_)
+  if (nullptr != stream_)
     stream_->SignalEvent.disconnect(this);
   if (owned_)
     delete stream_;
   stream_ = stream;
   owned_ = owned;
-  if (NULL != stream_)
+  if (nullptr != stream_)
     stream_->SignalEvent.connect(this, &StreamAdapterInterface::OnEvent);
 }
 
 StreamInterface* StreamAdapterInterface::Detach() {
-  if (NULL != stream_)
+  if (nullptr != stream_)
     stream_->SignalEvent.disconnect(this);
   StreamInterface* stream = stream_;
-  stream_ = NULL;
+  stream_ = nullptr;
   return stream;
 }
 
@@ -273,7 +273,7 @@ StreamResult StreamTap::Read(void* buffer, size_t buffer_len,
   StreamResult res = StreamAdapterInterface::Read(buffer, buffer_len,
                                                   read, error);
   if ((res == SR_SUCCESS) && (tap_result_ == SR_SUCCESS)) {
-    tap_result_ = tap_->WriteAll(buffer, *read, NULL, &tap_error_);
+    tap_result_ = tap_->WriteAll(buffer, *read, nullptr, &tap_error_);
   }
   return res;
 }
@@ -287,7 +287,7 @@ StreamResult StreamTap::Write(const void* data, size_t data_len,
   StreamResult res = StreamAdapterInterface::Write(data, data_len,
                                                    written, error);
   if ((res == SR_SUCCESS) && (tap_result_ == SR_SUCCESS)) {
-    tap_result_ = tap_->WriteAll(data, *written, NULL, &tap_error_);
+    tap_result_ = tap_->WriteAll(data, *written, nullptr, &tap_error_);
   }
   return res;
 }
@@ -325,8 +325,7 @@ void NullStream::Close() {
 // FileStream
 ///////////////////////////////////////////////////////////////////////////////
 
-FileStream::FileStream() : file_(NULL) {
-}
+FileStream::FileStream() : file_(nullptr) {}
 
 FileStream::~FileStream() {
   FileStream::Close();
@@ -351,7 +350,7 @@ bool FileStream::Open(const std::string& filename, const char* mode,
   if (!file_ && error) {
     *error = errno;
   }
-  return (file_ != NULL);
+  return (file_ != nullptr);
 }
 
 bool FileStream::OpenShare(const std::string& filename, const char* mode,
@@ -365,7 +364,7 @@ bool FileStream::OpenShare(const std::string& filename, const char* mode,
       *error = errno;
       return false;
     }
-    return file_ != NULL;
+    return file_ != nullptr;
   } else {
     if (error) {
       *error = -1;
@@ -380,11 +379,11 @@ bool FileStream::OpenShare(const std::string& filename, const char* mode,
 bool FileStream::DisableBuffering() {
   if (!file_)
     return false;
-  return (setvbuf(file_, NULL, _IONBF, 0) == 0);
+  return (setvbuf(file_, nullptr, _IONBF, 0) == 0);
 }
 
 StreamState FileStream::GetState() const {
-  return (file_ == NULL) ? SS_CLOSED : SS_OPEN;
+  return (file_ == nullptr) ? SS_CLOSED : SS_OPEN;
 }
 
 StreamResult FileStream::Read(void* buffer, size_t buffer_len,
@@ -422,7 +421,7 @@ StreamResult FileStream::Write(const void* data, size_t data_len,
 void FileStream::Close() {
   if (file_) {
     DoClose();
-    file_ = NULL;
+    file_ = nullptr;
   }
 }
 
@@ -433,7 +432,7 @@ bool FileStream::SetPosition(size_t position) {
 }
 
 bool FileStream::GetPosition(size_t* position) const {
-  RTC_DCHECK(NULL != position);
+  RTC_DCHECK(nullptr != position);
   if (!file_)
     return false;
   long result = ftell(file_);
@@ -445,7 +444,7 @@ bool FileStream::GetPosition(size_t* position) const {
 }
 
 bool FileStream::GetSize(size_t* size) const {
-  RTC_DCHECK(NULL != size);
+  RTC_DCHECK(nullptr != size);
   if (!file_)
     return false;
   struct stat file_stats;
@@ -457,7 +456,7 @@ bool FileStream::GetSize(size_t* size) const {
 }
 
 bool FileStream::GetAvailable(size_t* size) const {
-  RTC_DCHECK(NULL != size);
+  RTC_DCHECK(nullptr != size);
   if (!GetSize(size))
     return false;
   long result = ftell(file_);
@@ -493,7 +492,7 @@ bool FileStream::Flush() {
 #if defined(WEBRTC_POSIX) && !defined(__native_client__)
 
 bool FileStream::TryLock() {
-  if (file_ == NULL) {
+  if (file_ == nullptr) {
     // Stream not open.
     RTC_NOTREACHED();
     return false;
@@ -503,7 +502,7 @@ bool FileStream::TryLock() {
 }
 
 bool FileStream::Unlock() {
-  if (file_ == NULL) {
+  if (file_ == nullptr) {
     // Stream not open.
     RTC_NOTREACHED();
     return false;
@@ -523,9 +522,7 @@ void FileStream::DoClose() {
 ///////////////////////////////////////////////////////////////////////////////
 
 MemoryStreamBase::MemoryStreamBase()
-  : buffer_(NULL), buffer_length_(0), data_length_(0),
-    seek_position_(0) {
-}
+    : buffer_(nullptr), buffer_length_(0), data_length_(0), seek_position_(0) {}
 
 StreamState MemoryStreamBase::GetState() const {
   return SS_OPEN;
@@ -610,7 +607,7 @@ bool MemoryStreamBase::GetAvailable(size_t* size) const {
 }
 
 bool MemoryStreamBase::ReserveSize(size_t size) {
-  return (SR_SUCCESS == DoReserve(size, NULL));
+  return (SR_SUCCESS == DoReserve(size, nullptr));
 }
 
 StreamResult MemoryStreamBase::DoReserve(size_t size, int* error) {
@@ -619,17 +616,14 @@ StreamResult MemoryStreamBase::DoReserve(size_t size, int* error) {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-MemoryStream::MemoryStream()
-  : buffer_alloc_(NULL) {
-}
+MemoryStream::MemoryStream() : buffer_alloc_(nullptr) {}
 
-MemoryStream::MemoryStream(const char* data)
-  : buffer_alloc_(NULL) {
+MemoryStream::MemoryStream(const char* data) : buffer_alloc_(nullptr) {
   SetData(data, strlen(data));
 }
 
 MemoryStream::MemoryStream(const void* data, size_t length)
-  : buffer_alloc_(NULL) {
+    : buffer_alloc_(nullptr) {
   SetData(data, length);
 }
 
@@ -819,7 +813,7 @@ void FifoBuffer::ConsumeReadData(size_t size) {
 void* FifoBuffer::GetWriteBuffer(size_t* size) {
   CritScope cs(&crit_);
   if (state_ == SS_CLOSED) {
-    return NULL;
+    return nullptr;
   }
 
   // if empty, reset the write position to the beginning, so we can get
@@ -943,8 +937,8 @@ StreamResult LoggingAdapter::Write(const void* data, size_t data_len,
 }
 
 void LoggingAdapter::Close() {
-  LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_);
-  LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_);
+  LogMultiline(level_, label_.c_str(), false, nullptr, 0, hex_mode_, &lms_);
+  LogMultiline(level_, label_.c_str(), true, nullptr, 0, hex_mode_, &lms_);
   LOG_V(level_) << label_ << " Closed locally";
   StreamAdapterInterface::Close();
 }
@@ -953,8 +947,8 @@ void LoggingAdapter::OnEvent(StreamInterface* stream, int events, int err) {
   if (events & SE_OPEN) {
     LOG_V(level_) << label_ << " Open";
   } else if (events & SE_CLOSE) {
-    LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_);
-    LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_);
+    LogMultiline(level_, label_.c_str(), false, nullptr, 0, hex_mode_, &lms_);
+    LogMultiline(level_, label_.c_str(), true, nullptr, 0, hex_mode_, &lms_);
     LOG_V(level_) << label_ << " Closed with error: " << err;
   }
   StreamAdapterInterface::OnEvent(stream, events, err);
@@ -1066,9 +1060,10 @@ StreamReference::StreamReference(StreamRefCount* stream_ref_count,
 ///////////////////////////////////////////////////////////////////////////////
 
 StreamResult Flow(StreamInterface* source,
-                  char* buffer, size_t buffer_len,
+                  char* buffer,
+                  size_t buffer_len,
                   StreamInterface* sink,
-                  size_t* data_len /* = NULL */) {
+                  size_t* data_len /* = nullptr */) {
   RTC_DCHECK(buffer_len > 0);
 
   StreamResult result;
@@ -1083,8 +1078,8 @@ StreamResult Flow(StreamInterface* source,
   do {
     // Read until buffer is full, end of stream, or error
     while (!end_of_stream && (read_pos < buffer_len)) {
-      result = source->Read(buffer + read_pos, buffer_len - read_pos,
-                            &count, NULL);
+      result = source->Read(buffer + read_pos, buffer_len - read_pos, &count,
+                            nullptr);
       if (result == SR_EOS) {
         end_of_stream = true;
       } else if (result != SR_SUCCESS) {
@@ -1100,8 +1095,8 @@ StreamResult Flow(StreamInterface* source,
     // Write until buffer is empty, or error (including end of stream)
     write_pos = 0;
     while (write_pos < read_pos) {
-      result = sink->Write(buffer + write_pos, read_pos - write_pos,
-                           &count, NULL);
+      result = sink->Write(buffer + write_pos, read_pos - write_pos, &count,
+                           nullptr);
       if (result != SR_SUCCESS) {
         if (data_len) {
           *data_len = read_pos - write_pos;
diff --git a/webrtc/base/stream.h b/webrtc/base/stream.h
index 33090dfb1e..dbc2ad750a 100644
--- a/webrtc/base/stream.h
+++ b/webrtc/base/stream.h
@@ -125,7 +125,7 @@ class StreamInterface : public MessageHandler {
   // The following four methods are used to avoid copying data multiple times.
 
   // GetReadData returns a pointer to a buffer which is owned by the stream.
-  // The buffer contains data_len bytes.  NULL is returned if no data is
+  // The buffer contains data_len bytes.  null is returned if no data is
   // available, or if the method fails.  If the caller processes the data, it
   // must call ConsumeReadData with the number of processed bytes.  GetReadData
   // does not require a matching call to ConsumeReadData if the data is not
@@ -135,14 +135,14 @@ class StreamInterface : public MessageHandler {
   virtual void ConsumeReadData(size_t used) {}
 
   // GetWriteBuffer returns a pointer to a buffer which is owned by the stream.
-  // The buffer has a capacity of buf_len bytes.  NULL is returned if there is
+  // The buffer has a capacity of buf_len bytes.  null is returned if there is
   // no buffer available, or if the method fails.  The call may write data to
   // the buffer, and then call ConsumeWriteBuffer with the number of bytes
   // written.  GetWriteBuffer does not require a matching call to
   // ConsumeWriteData if no data is written.  Write, ForceWrite, and
   // ConsumeWriteData invalidate the buffer returned by GetWriteBuffer.
   // TODO: Allow the caller to specify a minimum buffer size.  If the specified
-  // amount of buffer is not yet available, return NULL and Signal SE_WRITE
+  // amount of buffer is not yet available, return null and Signal SE_WRITE
   // when it is available.  If the requested amount is too large, return an
   // error.
   virtual void* GetWriteBuffer(size_t* buf_len);
@@ -703,8 +703,10 @@ class StreamReference : public StreamAdapterInterface {
 // this is the data that read from source but can't move to destination.
 // as a pass in parameter, it indicates data in buffer that should move to sink
 StreamResult Flow(StreamInterface* source,
-                  char* buffer, size_t buffer_len,
-                  StreamInterface* sink, size_t* data_len = NULL);
+                  char* buffer,
+                  size_t buffer_len,
+                  StreamInterface* sink,
+                  size_t* data_len = nullptr);
 
 ///////////////////////////////////////////////////////////////////////////////
 
diff --git a/webrtc/base/stream_unittest.cc b/webrtc/base/stream_unittest.cc
index 8cfd052fe5..0fbb6ab835 100644
--- a/webrtc/base/stream_unittest.cc
+++ b/webrtc/base/stream_unittest.cc
@@ -79,7 +79,7 @@ void SeekTest(StreamInterface* stream, const unsigned char value) {
   unsigned char buffer[13] = { 0 };
   const size_t kBufSize = sizeof(buffer);
 
-  EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
+  EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, nullptr), SR_SUCCESS);
   EXPECT_EQ(bytes, kBufSize);
   EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value));
   EXPECT_TRUE(stream->GetPosition(&bytes));
@@ -87,7 +87,7 @@ void SeekTest(StreamInterface* stream, const unsigned char value) {
 
   EXPECT_TRUE(stream->SetPosition(7));
 
-  EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
+  EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, nullptr), SR_SUCCESS);
   EXPECT_EQ(bytes, kBufSize);
   EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value + 7));
   EXPECT_TRUE(stream->GetPosition(&bytes));
@@ -106,52 +106,52 @@ TEST(FifoBufferTest, TestAll) {
 
   // Test assumptions about base state
   EXPECT_EQ(SS_OPEN, stream->GetState());
-  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
-  EXPECT_TRUE(NULL != stream->GetReadData(&bytes));
+  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
+  EXPECT_TRUE(nullptr != stream->GetReadData(&bytes));
   EXPECT_EQ((size_t)0, bytes);
   stream->ConsumeReadData(0);
-  EXPECT_TRUE(NULL != stream->GetWriteBuffer(&bytes));
+  EXPECT_TRUE(nullptr != stream->GetWriteBuffer(&bytes));
   EXPECT_EQ(kSize, bytes);
   stream->ConsumeWriteBuffer(0);
 
   // Try a full write
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
 
   // Try a write that should block
-  EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, nullptr));
 
   // Try a full read
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
   // Try a read that should block
-  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
 
   // Try a too-big write
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 2, &bytes, nullptr));
   EXPECT_EQ(bytes, kSize);
 
   // Try a too-big read
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
   // Try some small writes and reads
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
 
@@ -163,22 +163,22 @@ TEST(FifoBufferTest, TestAll) {
   // XXXXWWWWWWWWXXXX 4567012345670123
   // RRRRXXXXXXXXRRRR ....01234567....
   // ....RRRRRRRR.... ................
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, nullptr));
   EXPECT_EQ(kSize * 3 / 4, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 4, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 4, &bytes, nullptr));
   EXPECT_EQ(kSize / 4 , bytes);
   EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2 , bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2 , bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
 
@@ -187,27 +187,27 @@ TEST(FifoBufferTest, TestAll) {
   stream->ConsumeWriteBuffer(0);
 
   // Try using GetReadData to do a full read
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
   q = stream->GetReadData(&bytes);
-  EXPECT_TRUE(NULL != q);
+  EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(q, in, kSize));
   stream->ConsumeReadData(kSize);
-  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
 
   // Try using GetReadData to do some small reads
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
   q = stream->GetReadData(&bytes);
-  EXPECT_TRUE(NULL != q);
+  EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(q, in, kSize / 2));
   stream->ConsumeReadData(kSize / 2);
   q = stream->GetReadData(&bytes);
-  EXPECT_TRUE(NULL != q);
+  EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(q, in + kSize / 2, kSize / 2));
   stream->ConsumeReadData(kSize / 2);
-  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
 
   // Try using GetReadData in a wraparound case
   // WWWWWWWWWWWWWWWW 0123456789ABCDEF
@@ -215,16 +215,16 @@ TEST(FifoBufferTest, TestAll) {
   // WWWWWWWW....XXXX 01234567....CDEF
   // ............RRRR 01234567........
   // RRRRRRRR........ ................
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL));
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
   q = stream->GetReadData(&bytes);
-  EXPECT_TRUE(NULL != q);
+  EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize / 4, bytes);
   EXPECT_EQ(0, memcmp(q, in + kSize * 3 / 4, kSize / 4));
   stream->ConsumeReadData(kSize / 4);
   q = stream->GetReadData(&bytes);
-  EXPECT_TRUE(NULL != q);
+  EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(q, in, kSize / 2));
   stream->ConsumeReadData(kSize / 2);
@@ -235,26 +235,26 @@ TEST(FifoBufferTest, TestAll) {
 
   // Try using GetWriteBuffer to do a full write
   p = stream->GetWriteBuffer(&bytes);
-  EXPECT_TRUE(NULL != p);
+  EXPECT_TRUE(nullptr != p);
   EXPECT_EQ(kSize, bytes);
   memcpy(p, in, kSize);
   stream->ConsumeWriteBuffer(kSize);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
   // Try using GetWriteBuffer to do some small writes
   p = stream->GetWriteBuffer(&bytes);
-  EXPECT_TRUE(NULL != p);
+  EXPECT_TRUE(nullptr != p);
   EXPECT_EQ(kSize, bytes);
   memcpy(p, in, kSize / 2);
   stream->ConsumeWriteBuffer(kSize / 2);
   p = stream->GetWriteBuffer(&bytes);
-  EXPECT_TRUE(NULL != p);
+  EXPECT_TRUE(nullptr != p);
   EXPECT_EQ(kSize / 2, bytes);
   memcpy(p, in + kSize / 2, kSize / 2);
   stream->ConsumeWriteBuffer(kSize / 2);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
@@ -264,53 +264,53 @@ TEST(FifoBufferTest, TestAll) {
   // ........XXXXWWWW ........89AB0123
   // WWWW....XXXXXXXX 4567....89AB0123
   // RRRR....RRRRRRRR ................
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
   p = stream->GetWriteBuffer(&bytes);
-  EXPECT_TRUE(NULL != p);
+  EXPECT_TRUE(nullptr != p);
   EXPECT_EQ(kSize / 4, bytes);
   memcpy(p, in, kSize / 4);
   stream->ConsumeWriteBuffer(kSize / 4);
   p = stream->GetWriteBuffer(&bytes);
-  EXPECT_TRUE(NULL != p);
+  EXPECT_TRUE(nullptr != p);
   EXPECT_EQ(kSize / 2, bytes);
   memcpy(p, in + kSize / 4, kSize / 4);
   stream->ConsumeWriteBuffer(kSize / 4);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, nullptr));
   EXPECT_EQ(kSize * 3 / 4, bytes);
   EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
   EXPECT_EQ(0, memcmp(in, out + kSize / 4, kSize / 4));
 
   // Check that the stream is now empty
-  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
 
   // Try growing the buffer
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_TRUE(buf.SetCapacity(kSize * 2));
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in + kSize, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in + kSize, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, nullptr));
   EXPECT_EQ(kSize * 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize * 2));
 
   // Try shrinking the buffer
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_TRUE(buf.SetCapacity(kSize));
-  EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
+  EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
   // Write to the stream, close it, read the remaining bytes
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
   stream->Close();
   EXPECT_EQ(SS_CLOSED, stream->GetState());
-  EXPECT_EQ(SR_EOS, stream->Write(in, kSize / 2, &bytes, NULL));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_EOS, stream->Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_EOS, stream->Read(out, kSize / 2, &bytes, NULL));
+  EXPECT_EQ(SR_EOS, stream->Read(out, kSize / 2, &bytes, nullptr));
 }
 
 TEST(FifoBufferTest, FullBufferCheck) {
@@ -318,7 +318,7 @@ TEST(FifoBufferTest, FullBufferCheck) {
   buff.ConsumeWriteBuffer(10);
 
   size_t free;
-  EXPECT_TRUE(buff.GetWriteBuffer(&free) != NULL);
+  EXPECT_TRUE(buff.GetWriteBuffer(&free) != nullptr);
   EXPECT_EQ(0U, free);
 }
 
@@ -329,7 +329,7 @@ TEST(FifoBufferTest, WriteOffsetAndReadOffset) {
   FifoBuffer buf(kSize);
 
   // Write 14 bytes.
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, 14, NULL, NULL));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, 14, nullptr, nullptr));
 
   // Make sure data is in |buf|.
   size_t buffered;
@@ -345,10 +345,10 @@ TEST(FifoBufferTest, WriteOffsetAndReadOffset) {
   EXPECT_EQ(12u, remaining);
 
   // Write at offset 12, this should fail.
-  EXPECT_EQ(SR_BLOCK, buf.WriteOffset(in, 10, 12, NULL));
+  EXPECT_EQ(SR_BLOCK, buf.WriteOffset(in, 10, 12, nullptr));
 
   // Write 8 bytes at offset 4, this wraps around the buffer.
-  EXPECT_EQ(SR_SUCCESS, buf.WriteOffset(in, 8, 4, NULL));
+  EXPECT_EQ(SR_SUCCESS, buf.WriteOffset(in, 8, 4, nullptr));
 
   // Number of available space remains the same until we call
   // ConsumeWriteBuffer().
@@ -368,7 +368,7 @@ TEST(FifoBufferTest, WriteOffsetAndReadOffset) {
   EXPECT_EQ(16u, buffered);
 
   // Read at offset 16, this should fail since we don't have that much data.
-  EXPECT_EQ(SR_BLOCK, buf.ReadOffset(out, 10, 16, NULL));
+  EXPECT_EQ(SR_BLOCK, buf.ReadOffset(out, 10, 16, nullptr));
 }
 
 }  // namespace rtc
diff --git a/webrtc/base/stringencode.cc b/webrtc/base/stringencode.cc
index 7c11a05e3e..c7d206fd93 100644
--- a/webrtc/base/stringencode.cc
+++ b/webrtc/base/stringencode.cc
@@ -141,7 +141,7 @@ const unsigned char ASCII_CLASS[128] = {
 
 size_t url_encode(char * buffer, size_t buflen,
                   const char * source, size_t srclen) {
-  if (NULL == buffer)
+  if (nullptr == buffer)
     return srclen * 3 + 1;
   if (buflen <= 0)
     return 0;
@@ -167,7 +167,7 @@ size_t url_encode(char * buffer, size_t buflen,
 
 size_t url_decode(char * buffer, size_t buflen,
                   const char * source, size_t srclen) {
-  if (NULL == buffer)
+  if (nullptr == buffer)
     return srclen + 1;
   if (buflen <= 0)
     return 0;
@@ -546,7 +546,7 @@ size_t transform(std::string& value, size_t maxlen, const std::string& source,
 
 std::string s_transform(const std::string& source, Transform t) {
   // Ask transformation function to approximate the destination size (returns upper bound)
-  size_t maxlen = t(NULL, 0, source.data(), source.length());
+  size_t maxlen = t(nullptr, 0, source.data(), source.length());
   char * buffer = STACK_ARRAY(char, maxlen);
   size_t len = t(buffer, maxlen, source.data(), source.length());
   std::string result(buffer, len);
diff --git a/webrtc/base/stringencode_unittest.cc b/webrtc/base/stringencode_unittest.cc
index fbd7975a8e..60929f3aed 100644
--- a/webrtc/base/stringencode_unittest.cc
+++ b/webrtc/base/stringencode_unittest.cc
@@ -21,18 +21,18 @@ TEST(Utf8EncodeTest, EncodeDecode) {
     size_t encsize, enclen;
     unsigned long decoded;
   } kTests[] = {
-    { "a    ",             5, 1, 'a' },
-    { "\x7F    ",          5, 1, 0x7F },
-    { "\xC2\x80   ",       5, 2, 0x80 },
-    { "\xDF\xBF   ",       5, 2, 0x7FF },
-    { "\xE0\xA0\x80  ",    5, 3, 0x800 },
-    { "\xEF\xBF\xBF  ",    5, 3, 0xFFFF },
-    { "\xF0\x90\x80\x80 ", 5, 4, 0x10000 },
-    { "\xF0\x90\x80\x80 ", 3, 0, 0x10000 },
-    { "\xF0\xF0\x80\x80 ", 5, 0, 0 },
-    { "\xF0\x90\x80  ",    5, 0, 0 },
-    { "\x90\x80\x80  ",    5, 0, 0 },
-    { NULL, 0, 0 },
+      {"a    ",             5, 1, 'a'},
+      {"\x7F    ",          5, 1, 0x7F},
+      {"\xC2\x80   ",       5, 2, 0x80},
+      {"\xDF\xBF   ",       5, 2, 0x7FF},
+      {"\xE0\xA0\x80  ",    5, 3, 0x800},
+      {"\xEF\xBF\xBF  ",    5, 3, 0xFFFF},
+      {"\xF0\x90\x80\x80 ", 5, 4, 0x10000},
+      {"\xF0\x90\x80\x80 ", 3, 0, 0x10000},
+      {"\xF0\xF0\x80\x80 ", 5, 0, 0},
+      {"\xF0\x90\x80  ",    5, 0, 0},
+      {"\x90\x80\x80  ",    5, 0, 0},
+      {nullptr, 0, 0},
   };
   for (size_t i = 0; kTests[i].encoded; ++i) {
     unsigned long val = 0;
@@ -248,7 +248,7 @@ TEST(TokenizeTest, CompareSubstrings) {
 }
 
 TEST(TokenizeTest, TokenizeAppend) {
-  ASSERT_EQ(0ul, tokenize_append("A B C", ' ', NULL));
+  ASSERT_EQ(0ul, tokenize_append("A B C", ' ', nullptr));
 
   std::vector<std::string> fields;
 
@@ -263,7 +263,7 @@ TEST(TokenizeTest, TokenizeAppend) {
 }
 
 TEST(TokenizeTest, TokenizeWithMarks) {
-  ASSERT_EQ(0ul, tokenize("D \"A B", ' ', '(', ')', NULL));
+  ASSERT_EQ(0ul, tokenize("D \"A B", ' ', '(', ')', nullptr));
 
   std::vector<std::string> fields;
   tokenize("A B C", ' ', '"', '"', &fields);
diff --git a/webrtc/base/stringutils.h b/webrtc/base/stringutils.h
index de256581d7..4c241f02de 100644
--- a/webrtc/base/stringutils.h
+++ b/webrtc/base/stringutils.h
@@ -136,8 +136,8 @@ struct Traits {
 // String utilities which work with char or wchar_t
 ///////////////////////////////////////////////////////////////////////////////
 
-template<class CTYPE>
-inline const CTYPE* nonnull(const CTYPE* str, const CTYPE* def_str = NULL) {
+template <class CTYPE>
+inline const CTYPE* nonnull(const CTYPE* str, const CTYPE* def_str = nullptr) {
   return str ? str : (def_str ? def_str : Traits<CTYPE>::empty_str());
 }
 
diff --git a/webrtc/base/stringutils_unittest.cc b/webrtc/base/stringutils_unittest.cc
index 5e034dd1cd..7d5b8e24c9 100644
--- a/webrtc/base/stringutils_unittest.cc
+++ b/webrtc/base/stringutils_unittest.cc
@@ -33,13 +33,13 @@ TEST(string_matchTest, Matches) {
 
 // Tests for ascii_string_compare().
 
-// Tests NULL input.
+// Tests null input.
 TEST(ascii_string_compareTest, NullInput) {
   // The following results in an access violation in
   // ascii_string_compare.  Is this a bug or by design?  stringutils.h
   // should document the expected behavior in this case.
 
-  // EXPECT_EQ(0, ascii_string_compare(NULL, NULL, 1, identity));
+  // EXPECT_EQ(0, ascii_string_compare(nullptr, nullptr, 1, identity));
 }
 
 // Tests comparing two strings of different lengths.
diff --git a/webrtc/base/task_unittest.cc b/webrtc/base/task_unittest.cc
index 38ceb145fd..b26d6706cf 100644
--- a/webrtc/base/task_unittest.cc
+++ b/webrtc/base/task_unittest.cc
@@ -216,7 +216,7 @@ class TaskTest : public sigslot::has_slots<> {
     for (i = 0; i < STUCK_TASK_COUNT; ++i) {
       if (stuck_[i].xlat_ == id) {
         stuck_[i].timed_out_ = true;
-        stuck_[i].task_ = NULL;
+        stuck_[i].task_ = nullptr;
         break;
       }
     }
@@ -231,7 +231,7 @@ class TaskTest : public sigslot::has_slots<> {
     for (i = 0; i < HAPPY_TASK_COUNT; ++i) {
       if (happy_[i].xlat_ == id) {
         happy_[i].timed_out_ = true;
-        happy_[i].task_ = NULL;
+        happy_[i].task_ = nullptr;
         break;
       }
     }
@@ -245,7 +245,7 @@ class TaskTest : public sigslot::has_slots<> {
     int i;
     for (i = 0; i < HAPPY_TASK_COUNT; ++i) {
       if (happy_[i].xlat_ == id) {
-        happy_[i].task_ = NULL;
+        happy_[i].task_ = nullptr;
         break;
       }
     }
@@ -347,7 +347,7 @@ class SetBoolOnDeleteTask : public Task {
   SetBoolOnDeleteTask(TaskParent *parent, bool *set_when_deleted)
     : Task(parent),
       set_when_deleted_(set_when_deleted) {
-    EXPECT_TRUE(NULL != set_when_deleted);
+    EXPECT_TRUE(nullptr != set_when_deleted);
     EXPECT_FALSE(*set_when_deleted);
   }
 
@@ -466,7 +466,7 @@ class TimeoutChangeTest : public sigslot::has_slots<> {
     for (size_t i = 0; i < arraysize(stuck_tasks_); ++i) {
       if (stuck_tasks_[i] && stuck_tasks_[i]->unique_id() == id) {
         task_count_--;
-        stuck_tasks_[i] = NULL;
+        stuck_tasks_[i] = nullptr;
         break;
       }
     }
diff --git a/webrtc/base/taskparent.cc b/webrtc/base/taskparent.cc
index f923c5a2eb..aee22a8fc4 100644
--- a/webrtc/base/taskparent.cc
+++ b/webrtc/base/taskparent.cc
@@ -20,17 +20,16 @@ namespace rtc {
 
 TaskParent::TaskParent(Task* derived_instance, TaskParent *parent)
     : parent_(parent) {
-  RTC_DCHECK(derived_instance != NULL);
-  RTC_DCHECK(parent != NULL);
+  RTC_DCHECK(derived_instance != nullptr);
+  RTC_DCHECK(parent != nullptr);
   runner_ = parent->GetRunner();
   parent_->AddChild(derived_instance);
   Initialize();
 }
 
-TaskParent::TaskParent(TaskRunner *derived_instance)
-    : parent_(NULL),
-      runner_(derived_instance) {
-  RTC_DCHECK(derived_instance != NULL);
+TaskParent::TaskParent(TaskRunner* derived_instance)
+    : parent_(nullptr), runner_(derived_instance) {
+  RTC_DCHECK(derived_instance != nullptr);
   Initialize();
 }
 
@@ -48,7 +47,7 @@ void TaskParent::AddChild(Task *child) {
 
 #if RTC_DCHECK_IS_ON
 bool TaskParent::IsChildTask(Task *task) {
-  RTC_DCHECK(task != NULL);
+  RTC_DCHECK(task != nullptr);
   return task->parent_ == this && children_->find(task) != children_->end();
 }
 #endif
diff --git a/webrtc/base/taskrunner.cc b/webrtc/base/taskrunner.cc
index 79e48ecddf..0ee5d023b5 100644
--- a/webrtc/base/taskrunner.cc
+++ b/webrtc/base/taskrunner.cc
@@ -77,7 +77,7 @@ void TaskRunner::InternalRunTasks(bool in_destructor) {
       Task* task = tasks_[i];
       if (next_timeout_task_ &&
           task->unique_id() == next_timeout_task_->unique_id()) {
-        next_timeout_task_ = NULL;
+        next_timeout_task_ = nullptr;
         need_timeout_recalc = true;
       }
 
@@ -86,21 +86,19 @@ void TaskRunner::InternalRunTasks(bool in_destructor) {
 #endif
       delete task;
 #if RTC_DCHECK_IS_ON
-      deleting_task_ = NULL;
+      deleting_task_ = nullptr;
 #endif
-      tasks_[i] = NULL;
+      tasks_[i] = nullptr;
     }
   }
-  // Finally, remove nulls
+  // Finally, remove nulls.
   std::vector<Task *>::iterator it;
-  it = std::remove(tasks_.begin(),
-                   tasks_.end(),
-                   reinterpret_cast<Task *>(NULL));
+  it = std::remove(tasks_.begin(), tasks_.end(), nullptr);
 
   tasks_.erase(it, tasks_.end());
 
   if (need_timeout_recalc)
-    RecalcNextTimeout(NULL);
+    RecalcNextTimeout(nullptr);
 
   // Make sure that adjustments are done to account
   // for any timeout changes (but don't call this
@@ -118,7 +116,7 @@ void TaskRunner::PollTasks() {
   // TODO: We need to guard against WakeTasks not updating
   // next_timeout_task_. Maybe also add documentation in the header file once
   // we understand this code better.
-  Task* old_timeout_task = NULL;
+  Task* old_timeout_task = nullptr;
   while (next_timeout_task_ &&
       old_timeout_task != next_timeout_task_ &&
       next_timeout_task_->TimedOut()) {
@@ -144,9 +142,10 @@ int64_t TaskRunner::next_task_timeout() const {
 
 void TaskRunner::UpdateTaskTimeout(Task* task,
                                    int64_t previous_task_timeout_time) {
-  RTC_DCHECK(task != NULL);
+  RTC_DCHECK(task != nullptr);
   int64_t previous_timeout_time = next_task_timeout();
-  bool task_is_timeout_task = next_timeout_task_ != NULL &&
+  bool task_is_timeout_task =
+      next_timeout_task_ != nullptr &&
       task->unique_id() == next_timeout_task_->unique_id();
   if (task_is_timeout_task) {
     previous_timeout_time = previous_task_timeout_time;
@@ -156,7 +155,7 @@ void TaskRunner::UpdateTaskTimeout(Task* task,
   // check to see if it's closer than the current
   // "about to timeout" task
   if (task->timeout_time()) {
-    if (next_timeout_task_ == NULL ||
+    if (next_timeout_task_ == nullptr ||
         (task->timeout_time() <= next_timeout_task_->timeout_time())) {
       next_timeout_task_ = task;
     }
@@ -184,14 +183,14 @@ void TaskRunner::RecalcNextTimeout(Task *exclude_task) {
   //   it has the closest timeout time
 
   int64_t next_timeout_time = 0;
-  next_timeout_task_ = NULL;
+  next_timeout_task_ = nullptr;
 
   for (size_t i = 0; i < tasks_.size(); ++i) {
     Task *task = tasks_[i];
     // if the task isn't complete, and it actually has a timeout time
     if (!task->IsDone() && (task->timeout_time() > 0))
       // if it doesn't match our "exclude" task
-      if (exclude_task == NULL ||
+      if (exclude_task == nullptr ||
           exclude_task->unique_id() != task->unique_id())
         // if its timeout time is sooner than our current timeout time
         if (next_timeout_time == 0 ||
diff --git a/webrtc/base/testclient.cc b/webrtc/base/testclient.cc
index 361bf36261..e797c6fa59 100644
--- a/webrtc/base/testclient.cc
+++ b/webrtc/base/testclient.cc
@@ -76,7 +76,7 @@ TestClient::Packet* TestClient::NextPacket(int timeout_ms) {
   }
 
   // Return the first packet placed in the queue.
-  Packet* packet = NULL;
+  Packet* packet = nullptr;
   CritScope cs(&crit_);
   if (packets_->size() > 0) {
     packet = packets_->front();
@@ -117,7 +117,7 @@ bool TestClient::CheckTimestamp(int64_t packet_timestamp) {
 bool TestClient::CheckNoPacket() {
   bool res;
   Packet* packet = NextPacket(kNoPacketTimeoutMs);
-  res = (packet == NULL);
+  res = (packet == nullptr);
   delete packet;
   return res;
 }
diff --git a/webrtc/base/testclient_unittest.cc b/webrtc/base/testclient_unittest.cc
index bdd06b329a..55078134c3 100644
--- a/webrtc/base/testclient_unittest.cc
+++ b/webrtc/base/testclient_unittest.cc
@@ -39,7 +39,7 @@ void TestTcpInternal(const SocketAddress& loopback) {
       ->CreateAsyncSocket(loopback.family(), SOCK_STREAM);
   AsyncTCPSocket* tcp_socket = AsyncTCPSocket::Create(
       socket, loopback, server.address());
-  ASSERT_TRUE(tcp_socket != NULL);
+  ASSERT_TRUE(tcp_socket != nullptr);
 
   TestClient client(tcp_socket);
   SocketAddress addr = client.address(), from;
diff --git a/webrtc/base/testechoserver.h b/webrtc/base/testechoserver.h
index 76d714b4f4..97606c105c 100644
--- a/webrtc/base/testechoserver.h
+++ b/webrtc/base/testechoserver.h
@@ -43,7 +43,7 @@ class TestEchoServer : public sigslot::has_slots<> {
 
  private:
   void OnAccept(AsyncSocket* socket) {
-    AsyncSocket* raw_socket = socket->Accept(NULL);
+    AsyncSocket* raw_socket = socket->Accept(nullptr);
     if (raw_socket) {
       AsyncTCPSocket* packet_socket = new AsyncTCPSocket(raw_socket, false);
       packet_socket->SignalReadPacket.connect(this, &TestEchoServer::OnPacket);
diff --git a/webrtc/base/testutils.h b/webrtc/base/testutils.h
index ac7fd93626..305d3d0a6b 100644
--- a/webrtc/base/testutils.h
+++ b/webrtc/base/testutils.h
@@ -276,14 +276,12 @@ private:
 
 class SocketTestClient : public sigslot::has_slots<> {
 public:
-  SocketTestClient() {
-    Init(NULL, AF_INET);
-  }
-  SocketTestClient(AsyncSocket* socket) {
-    Init(socket, socket->GetLocalAddress().family());
+ SocketTestClient() { Init(nullptr, AF_INET); }
+ SocketTestClient(AsyncSocket* socket) {
+   Init(socket, socket->GetLocalAddress().family());
   }
   SocketTestClient(const SocketAddress& address) {
-    Init(NULL, address.family());
+    Init(nullptr, address.family());
     socket_->Connect(address);
   }
 
@@ -408,8 +406,7 @@ class SocketTestServer : public sigslot::has_slots<> {
 
  private:
   void OnReadEvent(AsyncSocket* socket) {
-    AsyncSocket* accepted =
-      static_cast<AsyncSocket*>(socket_->Accept(NULL));
+    AsyncSocket* accepted = static_cast<AsyncSocket*>(socket_->Accept(nullptr));
     if (!accepted)
       return;
     clients_.push_back(new SocketTestClient(accepted));
@@ -530,9 +527,9 @@ inline AssertionResult CmpHelperMemEq(const char* expected_expression,
 
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
 struct XDisplay {
-  XDisplay() : display_(XOpenDisplay(NULL)) { }
+  XDisplay() : display_(XOpenDisplay(nullptr)) {}
   ~XDisplay() { if (display_) XCloseDisplay(display_); }
-  bool IsValid() const { return display_ != NULL; }
+  bool IsValid() const { return display_ != nullptr; }
   operator Display*() { return display_; }
  private:
   Display* display_;
diff --git a/webrtc/base/thread.cc b/webrtc/base/thread.cc
index 591253f191..a7db4184c5 100644
--- a/webrtc/base/thread.cc
+++ b/webrtc/base/thread.cc
@@ -43,7 +43,7 @@ Thread* Thread::Current() {
 
 #if defined(WEBRTC_POSIX)
 ThreadManager::ThreadManager() {
-  pthread_key_create(&key_, NULL);
+  pthread_key_create(&key_, nullptr);
 #ifndef NO_MAIN_THREAD_WRAPPING
   WrapCurrentThread();
 #endif
@@ -98,7 +98,7 @@ void ThreadManager::SetCurrentThread(Thread *thread) {
 
 Thread *ThreadManager::WrapCurrentThread() {
   Thread* result = CurrentThread();
-  if (NULL == result) {
+  if (nullptr == result) {
     result = new Thread();
     result->WrapCurrentWithThreadManager(this, true);
   }
@@ -134,7 +134,7 @@ Thread::Thread(SocketServer* ss)
     : MessageQueue(ss, false),
       running_(true, false),
 #if defined(WEBRTC_WIN)
-      thread_(NULL),
+      thread_(nullptr),
       thread_id_(0),
 #endif
       owned_(true),
@@ -147,7 +147,7 @@ Thread::Thread(std::unique_ptr<SocketServer> ss)
     : MessageQueue(std::move(ss), false),
       running_(true, false),
 #if defined(WEBRTC_WIN)
-      thread_(NULL),
+      thread_(nullptr),
       thread_id_(0),
 #endif
       owned_(true),
@@ -182,7 +182,7 @@ bool Thread::SleepMs(int milliseconds) {
   struct timespec ts;
   ts.tv_sec = milliseconds / 1000;
   ts.tv_nsec = (milliseconds % 1000) * 1000000;
-  int ret = nanosleep(&ts, NULL);
+  int ret = nanosleep(&ts, nullptr);
   if (ret != 0) {
     LOG_ERR(LS_WARNING) << "nanosleep() returning early";
     return false;
@@ -218,7 +218,7 @@ bool Thread::Start(Runnable* runnable) {
   init->thread = this;
   init->runnable = runnable;
 #if defined(WEBRTC_WIN)
-  thread_ = CreateThread(NULL, 0, PreRun, init, 0, &thread_id_);
+  thread_ = CreateThread(nullptr, 0, PreRun, init, 0, &thread_id_);
   if (thread_) {
     running_.Set();
   } else {
@@ -244,13 +244,13 @@ bool Thread::WrapCurrent() {
 
 void Thread::UnwrapCurrent() {
   // Clears the platform-specific thread-specific storage.
-  ThreadManager::Instance()->SetCurrentThread(NULL);
+  ThreadManager::Instance()->SetCurrentThread(nullptr);
 #if defined(WEBRTC_WIN)
-  if (thread_ != NULL) {
+  if (thread_ != nullptr) {
     if (!CloseHandle(thread_)) {
       LOG_GLE(LS_ERROR) << "When unwrapping thread, failed to close handle.";
     }
-    thread_ = NULL;
+    thread_ = nullptr;
   }
 #endif
   running_.Reset();
@@ -269,10 +269,10 @@ void Thread::Join() {
     }
 
 #if defined(WEBRTC_WIN)
-    RTC_DCHECK(thread_ != NULL);
+    RTC_DCHECK(thread_ != nullptr);
     WaitForSingleObject(thread_, INFINITE);
     CloseHandle(thread_);
-    thread_ = NULL;
+    thread_ = nullptr;
     thread_id_ = 0;
 #elif defined(WEBRTC_POSIX)
     void *pv;
@@ -360,7 +360,7 @@ void Thread::Send(const Location& posted_from,
 
   AutoThread thread;
   Thread *current_thread = Thread::Current();
-  RTC_DCHECK(current_thread != NULL);  // AutoThread ensures this
+  RTC_DCHECK(current_thread != nullptr);  // AutoThread ensures this
 
   bool ready = false;
   {
@@ -405,7 +405,7 @@ void Thread::Send(const Location& posted_from,
 }
 
 void Thread::ReceiveSends() {
-  ReceiveSendsFromThread(NULL);
+  ReceiveSendsFromThread(nullptr);
 }
 
 void Thread::ReceiveSendsFromThread(const Thread* source) {
@@ -432,7 +432,7 @@ void Thread::ReceiveSendsFromThread(const Thread* source) {
 bool Thread::PopSendMessageFromThread(const Thread* source, _SendMessage* msg) {
   for (std::list<_SendMessage>::iterator it = sendlist_.begin();
        it != sendlist_.end(); ++it) {
-    if (it->thread == source || source == NULL) {
+    if (it->thread == source || source == nullptr) {
       *msg = *it;
       sendlist_.erase(it);
       return true;
@@ -456,7 +456,7 @@ void Thread::Clear(MessageHandler* phandler,
 
   // Remove messages on sendlist_ with phandler
   // Object target cleared: remove from send list, wakeup/set ready
-  // if sender not NULL.
+  // if sender not null.
 
   std::list<_SendMessage>::iterator iter = sendlist_.begin();
   while (iter != sendlist_.end()) {
@@ -538,7 +538,7 @@ AutoThread::AutoThread() {
 AutoThread::~AutoThread() {
   Stop();
   if (ThreadManager::Instance()->CurrentThread() == this) {
-    ThreadManager::Instance()->SetCurrentThread(NULL);
+    ThreadManager::Instance()->SetCurrentThread(nullptr);
   }
 }
 
@@ -548,7 +548,7 @@ ComThread::~ComThread() {
 }
 
 void ComThread::Run() {
-  HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+  HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
   RTC_DCHECK(SUCCEEDED(hr));
   if (SUCCEEDED(hr)) {
     Thread::Run();
diff --git a/webrtc/base/thread.h b/webrtc/base/thread.h
index 58fa3f0d46..5751df385c 100644
--- a/webrtc/base/thread.h
+++ b/webrtc/base/thread.h
@@ -56,7 +56,7 @@ class ThreadManager {
   // unexpected contexts (like inside browser plugins) and it would be a
   // shame to break it.  It is also conceivable on Win32 that we won't even
   // be able to get synchronization privileges, in which case the result
-  // will have a NULL handle.
+  // will have a null handle.
   Thread *WrapCurrentThread();
   void UnwrapCurrentThread();
 
@@ -133,12 +133,12 @@ class LOCKABLE Thread : public MessageQueue {
   static bool SleepMs(int millis);
 
   // Sets the thread's name, for debugging. Must be called before Start().
-  // If |obj| is non-NULL, its value is appended to |name|.
+  // If |obj| is non-null, its value is appended to |name|.
   const std::string& name() const { return name_; }
   bool SetName(const std::string& name, const void* obj);
 
   // Starts the execution of the thread.
-  bool Start(Runnable* runnable = NULL);
+  bool Start(Runnable* runnable = nullptr);
 
   // Tells the thread to stop and waits until it is joined.
   // Never call Stop on the current thread.  Instead use the inherited Quit
@@ -154,7 +154,7 @@ class LOCKABLE Thread : public MessageQueue {
   virtual void Send(const Location& posted_from,
                     MessageHandler* phandler,
                     uint32_t id = 0,
-                    MessageData* pdata = NULL);
+                    MessageData* pdata = nullptr);
 
   // Convenience method to invoke a functor on another thread.  Caller must
   // provide the |ReturnT| template argument, which cannot (easily) be deduced.
@@ -174,7 +174,7 @@ class LOCKABLE Thread : public MessageQueue {
   // From MessageQueue
   void Clear(MessageHandler* phandler,
              uint32_t id = MQID_ANY,
-             MessageList* removed = NULL) override;
+             MessageList* removed = nullptr) override;
   void ReceiveSends() override;
 
   // ProcessMessages will process I/O and dispatch messages until:
@@ -255,11 +255,11 @@ class LOCKABLE Thread : public MessageQueue {
   // Return true if the thread was started and hasn't yet stopped.
   bool running() { return running_.Wait(0); }
 
-  // Processes received "Send" requests. If |source| is not NULL, only requests
+  // Processes received "Send" requests. If |source| is not null, only requests
   // from |source| are processed, otherwise, all requests are processed.
   void ReceiveSendsFromThread(const Thread* source);
 
-  // If |source| is not NULL, pops the first "Send" message from |source| in
+  // If |source| is not null, pops the first "Send" message from |source| in
   // |sendlist_|, otherwise, pops the first "Send" message of |sendlist_|.
   // The caller must lock |crit_| before calling.
   // Returns true if there is such a message.
diff --git a/webrtc/base/thread_checker_unittest.cc b/webrtc/base/thread_checker_unittest.cc
index dee1653578..e995b507e9 100644
--- a/webrtc/base/thread_checker_unittest.cc
+++ b/webrtc/base/thread_checker_unittest.cc
@@ -54,7 +54,7 @@ class CallDoStuffOnThread : public Thread {
   explicit CallDoStuffOnThread(ThreadCheckerClass* thread_checker_class)
       : Thread(),
         thread_checker_class_(thread_checker_class) {
-    SetName("call_do_stuff_on_thread", NULL);
+    SetName("call_do_stuff_on_thread", nullptr);
   }
 
   void Run() override { thread_checker_class_->DoStuff(); }
@@ -78,7 +78,7 @@ class DeleteThreadCheckerClassOnThread : public Thread {
       ThreadCheckerClass* thread_checker_class)
       : Thread(),
         thread_checker_class_(thread_checker_class) {
-    SetName("delete_thread_checker_class_on_thread", NULL);
+    SetName("delete_thread_checker_class_on_thread", nullptr);
   }
 
   void Run() override { thread_checker_class_.reset(); }
diff --git a/webrtc/base/thread_unittest.cc b/webrtc/base/thread_unittest.cc
index e4e74d6db0..39f2b2e2cc 100644
--- a/webrtc/base/thread_unittest.cc
+++ b/webrtc/base/thread_unittest.cc
@@ -243,7 +243,7 @@ TEST(ThreadTest, Names) {
   delete thread;
   thread = new Thread();
   // Name with no object parameter
-  EXPECT_TRUE(thread->SetName("No object", NULL));
+  EXPECT_TRUE(thread->SetName("No object", nullptr));
   EXPECT_TRUE(thread->Start());
   thread->Stop();
   delete thread;
@@ -292,7 +292,7 @@ TEST(ThreadTest, Invoke) {
 TEST(ThreadTest, TwoThreadsInvokeNoDeadlock) {
   AutoThread thread;
   Thread* current_thread = Thread::Current();
-  ASSERT_TRUE(current_thread != NULL);
+  ASSERT_TRUE(current_thread != nullptr);
 
   Thread other_thread;
   other_thread.Start();
@@ -443,7 +443,7 @@ class AsyncInvokeTest : public testing::Test {
   AsyncInvokeTest()
       : int_value_(0),
         invoke_started_(true, false),
-        expected_thread_(NULL) {}
+        expected_thread_(nullptr) {}
 
   int int_value_;
   Event invoke_started_;
@@ -788,7 +788,7 @@ class ComThreadTest : public testing::Test, public MessageHandler {
   ComThreadTest() : done_(false) {}
  protected:
   virtual void OnMessage(Message* message) {
-    HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+    HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
     // S_FALSE means the thread was already inited for a multithread apartment.
     EXPECT_EQ(S_FALSE, hr);
     if (SUCCEEDED(hr)) {
diff --git a/webrtc/base/timeutils.cc b/webrtc/base/timeutils.cc
index 509b6958f5..7fcc2f4149 100644
--- a/webrtc/base/timeutils.cc
+++ b/webrtc/base/timeutils.cc
@@ -189,7 +189,7 @@ int64_t TmToSeconds(const std::tm& tm) {
 int64_t TimeUTCMicros() {
 #if defined(WEBRTC_POSIX)
   struct timeval time;
-  gettimeofday(&time, NULL);
+  gettimeofday(&time, nullptr);
   // Convert from second (1.0) and microsecond (1e-6).
   return (static_cast<int64_t>(time.tv_sec) * rtc::kNumMicrosecsPerSec +
           time.tv_usec);
diff --git a/webrtc/base/trace_event.h b/webrtc/base/trace_event.h
index 3789886a1c..3e9937466c 100644
--- a/webrtc/base/trace_event.h
+++ b/webrtc/base/trace_event.h
@@ -817,10 +817,9 @@ static inline void AddTraceEvent(char phase,
                                 const char* name,
                                 unsigned long long id,
                                 unsigned char flags) {
-  TRACE_EVENT_API_ADD_TRACE_EVENT(
-      phase, category_enabled, name, id,
-      kZeroNumArgs, NULL, NULL, NULL,
-      flags);
+  TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_enabled, name, id,
+                                  kZeroNumArgs, nullptr, nullptr, nullptr,
+                                  flags);
 }
 
 template<class ARG1_TYPE>
@@ -867,7 +866,7 @@ static inline void AddTraceEvent(char phase,
 class TraceEndOnScopeClose {
  public:
   // Note: members of data_ intentionally left uninitialized. See Initialize.
-  TraceEndOnScopeClose() : p_data_(NULL) {}
+  TraceEndOnScopeClose() : p_data_(nullptr) {}
   ~TraceEndOnScopeClose() {
     if (p_data_)
       AddEventIfEnabled();
@@ -885,12 +884,10 @@ class TraceEndOnScopeClose {
   void AddEventIfEnabled() {
     // Only called when p_data_ is non-null.
     if (*p_data_->category_enabled) {
-      TRACE_EVENT_API_ADD_TRACE_EVENT(
-          TRACE_EVENT_PHASE_END,
-          p_data_->category_enabled,
-          p_data_->name, kNoEventId,
-          kZeroNumArgs, NULL, NULL, NULL,
-          TRACE_EVENT_FLAG_NONE);
+      TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_END,
+                                      p_data_->category_enabled, p_data_->name,
+                                      kNoEventId, kZeroNumArgs, nullptr,
+                                      nullptr, nullptr, TRACE_EVENT_FLAG_NONE);
     }
   }
 
diff --git a/webrtc/base/transformadapter.cc b/webrtc/base/transformadapter.cc
index 89444641ac..1f1a2a055c 100644
--- a/webrtc/base/transformadapter.cc
+++ b/webrtc/base/transformadapter.cc
@@ -175,7 +175,7 @@ TransformAdapter::Close() {
   if (!direction_read_ && (state_ == ST_PROCESSING)) {
     state_ = ST_FLUSHING;
     do {
-      Write(0, 0, NULL, NULL);
+      Write(0, 0, nullptr, nullptr);
     } while (state_ == ST_FLUSHING);
   }
   state_ = ST_COMPLETE;
diff --git a/webrtc/base/unittest_main.cc b/webrtc/base/unittest_main.cc
index 3de0528847..1600217916 100644
--- a/webrtc/base/unittest_main.cc
+++ b/webrtc/base/unittest_main.cc
@@ -66,7 +66,7 @@ int main(int argc, char** argv) {
   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/webrtc/base/unixfilesystem.cc b/webrtc/base/unixfilesystem.cc
index a011094710..d0da709810 100644
--- a/webrtc/base/unixfilesystem.cc
+++ b/webrtc/base/unixfilesystem.cc
@@ -63,10 +63,10 @@ void AppleAppName(rtc::Pathname* path);
 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 @@ bool UnixFilesystem::CreateFolder(const Pathname &path) {
 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::DeleteEmptyFolder(const Pathname &folder) {
 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 @@ bool UnixFilesystem::CopyFile(const Pathname &old_path,
     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::CopyFile(const Pathname &old_path,
 
 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::GetFileTime(const Pathname& path, FileTimeType which,
 
 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* UnixFilesystem::CopyString(const std::string& str) {
 
   char* buf = new char[size];
   if (!buf) {
-    return NULL;
+    return nullptr;
   }
 
   strcpyn(buf, size, str.c_str());
diff --git a/webrtc/base/unixfilesystem.h b/webrtc/base/unixfilesystem.h
index 8338e5cd0b..6f90959101 100644
--- a/webrtc/base/unixfilesystem.h
+++ b/webrtc/base/unixfilesystem.h
@@ -35,7 +35,7 @@ class UnixFilesystem : public FilesystemInterface {
 #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/webrtc/base/virtualsocket_unittest.cc b/webrtc/base/virtualsocket_unittest.cc
index 4ee2c75617..b8847489a3 100644
--- a/webrtc/base/virtualsocket_unittest.cc
+++ b/webrtc/base/virtualsocket_unittest.cc
@@ -137,10 +137,10 @@ struct Receiver : public MessageHandler, public sigslot::has_slots<> {
 
 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 @@ class VirtualSocketServerTest : public testing::Test {
 
     // 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 @@ class VirtualSocketServerTest : public testing::Test {
     // 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 @@ class VirtualSocketServerTest : public testing::Test {
 
     // 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 @@ class VirtualSocketServerTest : public testing::Test {
     // 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 @@ class VirtualSocketServerTest : public testing::Test {
   // 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 @@ class VirtualSocketServerTest : public testing::Test {
       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 @@ class VirtualSocketServerTest : public testing::Test {
       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 @@ class VirtualSocketServerTest : public testing::Test {
   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 @@ TEST_F(VirtualSocketServerTest, CreatesStandardDistribution) {
             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/webrtc/base/virtualsocketserver.cc b/webrtc/base/virtualsocketserver.cc
index d9c7eebbc6..57f218e91b 100644
--- a/webrtc/base/virtualsocketserver.cc
+++ b/webrtc/base/virtualsocketserver.cc
@@ -64,7 +64,7 @@ class Packet : public MessageData {
  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 @@ VirtualSocket::VirtualSocket(VirtualSocketServer* server,
       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 @@ int VirtualSocket::Close() {
         listen_queue_->pop_front();
       }
       delete listen_queue_;
-      listen_queue_ = NULL;
+      listen_queue_ = nullptr;
     }
     // Disconnect stream sockets
     if (CS_CONNECTED == state_) {
@@ -210,7 +210,7 @@ int VirtualSocket::Close() {
       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 @@ int VirtualSocket::RecvFrom(void* pv,
     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 @@ int VirtualSocket::Listen(int backlog) {
     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 @@ VirtualSocket* VirtualSocket::Accept(SocketAddress* paddr) {
     return socket;
   }
   error_ = EWOULDBLOCK;
-  return NULL;
+  return nullptr;
 }
 
 int VirtualSocket::GetError() const {
@@ -393,7 +393,7 @@ int VirtualSocket::EstimateMTU(uint16_t* mtu) {
 
 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 @@ void VirtualSocket::OnMessage(Message* pmsg) {
       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 @@ void VirtualSocket::OnSocketServerReadyToSend() {
 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 @@ bool VirtualSocketServer::CloseTcpConnections(
 
 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,
 }
 
 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 @@ VirtualSocket* VirtualSocketServer::LookupConnection(
                                   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 @@ int VirtualSocketServer::Connect(VirtualSocket* socket,
                  << 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/webrtc/base/virtualsocketserver.h b/webrtc/base/virtualsocketserver.h
index 6782d800a0..3d4171b453 100644
--- a/webrtc/base/virtualsocketserver.h
+++ b/webrtc/base/virtualsocketserver.h
@@ -213,10 +213,10 @@ class VirtualSocketServer : public SocketServer, public sigslot::has_slots<> {
                             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/webrtc/base/weak_ptr.cc b/webrtc/base/weak_ptr.cc
index 4eef7eacc5..8a07a87b7d 100644
--- a/webrtc/base/weak_ptr.cc
+++ b/webrtc/base/weak_ptr.cc
@@ -73,7 +73,7 @@ void WeakReferenceOwner::Invalidate() {
   RTC_DCHECK(checker_.CalledSequentially());
   if (flag_.get()) {
     flag_->Invalidate();
-    flag_ = NULL;
+    flag_ = nullptr;
   }
 }
 
diff --git a/webrtc/base/win32.cc b/webrtc/base/win32.cc
index cc942826ed..485f7a6931 100644
--- a/webrtc/base/win32.cc
+++ b/webrtc/base/win32.cc
@@ -35,7 +35,7 @@ static int inet_pton_v6(const char* src, void* dst);
 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 @@ const char* win32_inet_ntop(int af, const void *src,
       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 @@ int win32_inet_pton(int af, const char* src, void* dst) {
 // 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 @@ const char* inet_ntop_v4(const void* src, char* dst, socklen_t size) {
 // 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 @@ int inet_pton_v6(const char* src, void* dst) {
 //
 
 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 FileTimeToUnixTime(const FILETIME& ft, time_t* ut) {
 }
 
 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 @@ bool Utf8ToWindowsFilename(const std::string& utf8, std::wstring* filename) {
   // 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 @@ bool Utf8ToWindowsFilename(const std::string& utf8, std::wstring* filename) {
   // 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 @@ bool GetCurrentProcessIntegrityLevel(int* level) {
   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/webrtc/base/win32.h b/webrtc/base/win32.h
index dba9b773b5..22a17c518b 100644
--- a/webrtc/base/win32.h
+++ b/webrtc/base/win32.h
@@ -48,7 +48,7 @@ int win32_inet_pton(int af, const char* src, void *dst);
 
 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::wstring ToUtf16(const std::string& str) {
 
 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 @@ bool GetOsVersion(int* major, int* minor, int* build);
 
 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/webrtc/base/win32filesystem.cc b/webrtc/base/win32filesystem.cc
index 9e4ef51ffe..4bc2218fa5 100644
--- a/webrtc/base/win32filesystem.cc
+++ b/webrtc/base/win32filesystem.cc
@@ -60,15 +60,15 @@ bool Win32Filesystem::CreateFolder(const Pathname &pathname) {
     }
   }
 
-  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 @@ bool Win32Filesystem::GetTemporaryFolder(Pathname &pathname, bool create,
     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::GetFileTime(const Pathname& path, FileTimeType which,
 
 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/webrtc/base/win32filesystem.h b/webrtc/base/win32filesystem.h
index dd3caed385..3ceaa20b06 100644
--- a/webrtc/base/win32filesystem.h
+++ b/webrtc/base/win32filesystem.h
@@ -17,8 +17,8 @@ namespace rtc {
 
 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 @@ class Win32Filesystem : public FilesystemInterface {
   // 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/webrtc/base/win32socketserver.cc b/webrtc/base/win32socketserver.cc
index adf360b5ff..3ee88dbaf5 100644
--- a/webrtc/base/win32socketserver.cc
+++ b/webrtc/base/win32socketserver.cc
@@ -165,7 +165,7 @@ class Win32Socket::EventSink : public Win32Window {
 };
 
 void Win32Socket::EventSink::Dispose() {
-  parent_ = NULL;
+  parent_ = nullptr;
   if (::IsWindow(handle())) {
     ::DestroyWindow(handle());
   } else {
@@ -227,9 +227,14 @@ void Win32Socket::EventSink::OnNcDestroy() {
 /////////////////////////////////////////////////////////////////////////////
 
 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 @@ Win32Socket::~Win32Socket() {
 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 @@ Win32Socket* Win32Socket::Accept(SocketAddress* out_addr) {
   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 @@ int Win32Socket::Close() {
   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 @@ int Win32Socket::EstimateMTU(uint16_t* mtu) {
 }
 
 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 @@ void Win32Socket::OnDnsNotify(HANDLE task, int error) {
     SignalCloseEvent(this, error_);
   } else {
     delete dns_;
-    dns_ = NULL;
+    dns_ = nullptr;
   }
 }
 
@@ -725,16 +730,16 @@ Win32SocketServer::Win32SocketServer(MessageQueue* message_queue)
     : 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 @@ AsyncSocket* Win32SocketServer::CreateAsyncSocket(int family, int type) {
     return socket;
   }
   delete socket;
-  return NULL;
+  return nullptr;
 }
 
 void Win32SocketServer::SetMessageQueue(MessageQueue* queue) {
@@ -773,12 +778,12 @@ bool Win32SocketServer::Wait(int cms, bool process_io) {
     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 @@ bool Win32SocketServer::Wait(int cms, bool process_io) {
     // 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 @@ void Win32SocketServer::Pump() {
   if (delay == -1) {
     KillTimer(wnd_.handle(), 1);
   } else {
-    SetTimer(wnd_.handle(), 1, delay, NULL);
+    SetTimer(wnd_.handle(), 1, delay, nullptr);
   }
 }
 
diff --git a/webrtc/base/win32socketserver.h b/webrtc/base/win32socketserver.h
index 28bee6af06..a9a53c33c1 100644
--- a/webrtc/base/win32socketserver.h
+++ b/webrtc/base/win32socketserver.h
@@ -143,7 +143,7 @@ class Win32Thread : public Thread {
   }
   virtual ~Win32Thread() {
     Stop();
-    set_socketserver(NULL);
+    set_socketserver(nullptr);
   }
   virtual void Run() {
     id_ = GetCurrentThreadId();
diff --git a/webrtc/base/win32socketserver_unittest.cc b/webrtc/base/win32socketserver_unittest.cc
index f40fd5f530..94d96da428 100644
--- a/webrtc/base/win32socketserver_unittest.cc
+++ b/webrtc/base/win32socketserver_unittest.cc
@@ -16,7 +16,7 @@ namespace rtc {
 
 // 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(Win32SocketServerTest, TestWait) {
 
 // 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(Win32SocketServerTest, TestPump) {
 // 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/webrtc/base/win32window.cc b/webrtc/base/win32window.cc
index 9abbc86807..0e02eef1dc 100644
--- a/webrtc/base/win32window.cc
+++ b/webrtc/base/win32window.cc
@@ -19,14 +19,13 @@ namespace rtc {
 ///////////////////////////////////////////////////////////////////////////////
 
 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 @@ bool Win32Window::Create(HWND parent, const wchar_t* title, DWORD style,
       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 @@ LRESULT Win32Window::WndProc(HWND hwnd, UINT uMsg,
     }
     if (WM_NCDESTROY == uMsg) {
       ::SetWindowLongPtr(hwnd, GWLP_USERDATA, NULL);
-      that->wnd_ = NULL;
+      that->wnd_ = nullptr;
       that->OnNcDestroy();
     }
     if (handled) {
diff --git a/webrtc/base/win32window_unittest.cc b/webrtc/base/win32window_unittest.cc
index 3738a7f4a5..f814752e39 100644
--- a/webrtc/base/win32window_unittest.cc
+++ b/webrtc/base/win32window_unittest.cc
@@ -39,16 +39,16 @@ class TestWindow : public rtc::Win32Window {
 
 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 @@ TEST(Win32WindowTest, MultipleWindows) {
   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/webrtc/base/winping.cc b/webrtc/base/winping.cc
index 5545076f27..21f4fa38a2 100644
--- a/webrtc/base/winping.cc
+++ b/webrtc/base/winping.cc
@@ -249,7 +249,7 @@ WinPing::PingResult WinPing::Ping(IPAddress ip,
     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 @@ WinPing::PingResult WinPing::Ping(IPAddress ip,
 //     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