Mojo: NULL -> nullptr in mojo/system and mojo/embedder.

mojo/system/raw_channel_win.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "mojo/system/raw_channel.h"
 
 #include <windows.h>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 32 matching lines @@
   typedef BOOL(WINAPI* CancelIoExFunc)(HANDLE, LPOVERLAPPED);
 
   bool is_vista_or_higher_;
   SetFileCompletionNotificationModesFunc
       set_file_completion_notification_modes_;
   CancelIoExFunc cancel_io_ex_;
 };
 
 VistaOrHigherFunctions::VistaOrHigherFunctions()
     : is_vista_or_higher_(base::win::GetVersion() >= base::win::VERSION_VISTA),
-      set_file_completion_notification_modes_(NULL),
-      cancel_io_ex_(NULL) {
+      set_file_completion_notification_modes_(nullptr),
+      cancel_io_ex_(nullptr) {
   if (!is_vista_or_higher_)
     return;
 
   HMODULE module = GetModuleHandleW(L"kernel32.dll");
   set_file_completion_notification_modes_ =
       reinterpret_cast<SetFileCompletionNotificationModesFunc>(
           GetProcAddress(module, "SetFileCompletionNotificationModes"));
   DCHECK(set_file_completion_notification_modes_);
 
   cancel_io_ex_ =
@@ skipping 207 matching lines @@
   DCHECK(owner_);
   DCHECK_EQ(base::MessageLoop::current(), owner_->message_loop_for_io());
   owner_->write_lock().AssertAcquired();
 
   // If read/write is pending, we have to retain the corresponding buffer.
   if (pending_read_)
     preserved_read_buffer_after_detach_ = read_buffer.Pass();
   if (pending_write_)
     preserved_write_buffer_after_detach_ = write_buffer.Pass();
 
-  owner_ = NULL;
+  owner_ = nullptr;
   if (ShouldSelfDestruct())
     delete this;
 }
 
 bool RawChannelWin::RawChannelIOHandler::ShouldSelfDestruct() const {
   if (owner_ || suppress_self_destruct_)
     return false;
 
   // Note: Detached, hence no lock needed for |pending_write_|.
   return !pending_read_ && !pending_write_;
@@ skipping 47 matching lines @@
   } else if (error == ERROR_BROKEN_PIPE) {
     owner_->OnWriteCompleted(IO_FAILED_SHUTDOWN, 0, 0);
   } else {
     LOG(WARNING) << "WriteFile: " << logging::SystemErrorCodeToString(error);
     owner_->OnWriteCompleted(IO_FAILED_UNKNOWN, 0, 0);
   }
 }
 
 RawChannelWin::RawChannelWin(embedder::ScopedPlatformHandle handle)
     : handle_(handle.Pass()),
-      io_handler_(NULL),
+      io_handler_(nullptr),
       skip_completion_port_on_success_(
           g_vista_or_higher_functions.Get().is_vista_or_higher()) {
   DCHECK(handle_.is_valid());
 }
 
 RawChannelWin::~RawChannelWin() {
   DCHECK(!io_handler_);
 }
 
 size_t RawChannelWin::GetSerializedPlatformHandleSize() const {
   // TODO(vtl): Implement.
   return 0;
 }
 
 RawChannel::IOResult RawChannelWin::Read(size_t* bytes_read) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
   DCHECK(io_handler_);
   DCHECK(!io_handler_->pending_read());
 
-  char* buffer = NULL;
+  char* buffer = nullptr;
   size_t bytes_to_read = 0;
   read_buffer()->GetBuffer(&buffer, &bytes_to_read);
 
   DWORD bytes_read_dword = 0;
   BOOL result = ReadFile(io_handler_->handle(),
                          buffer,
                          static_cast<DWORD>(bytes_to_read),
                          &bytes_read_dword,
                          &io_handler_->read_context()->overlapped);
   if (!result) {
@@ skipping 165 matching lines @@
   DCHECK(io_handler_);
 
   write_lock().AssertAcquired();
 
   if (io_handler_->pending_read() || io_handler_->pending_write_no_lock()) {
     // |io_handler_| will be alive until pending read/write (if any) completes.
     // Call |CancelIoEx()| or |CancelIo()| so that resources can be freed up as
     // soon as possible.
     // Note: |CancelIo()| only cancels read/write requests started from this
     // thread.
-    if (g_vista_or_higher_functions.Get().is_vista_or_higher())
-      g_vista_or_higher_functions.Get().CancelIoEx(io_handler_->handle(), NULL);
-    else
+    if (g_vista_or_higher_functions.Get().is_vista_or_higher()) {
+      g_vista_or_higher_functions.Get().CancelIoEx(io_handler_->handle(),
+                                                   nullptr);
+    } else {
       CancelIo(io_handler_->handle());
+    }
   }
 
   io_handler_->DetachFromOwnerNoLock(read_buffer.Pass(), write_buffer.Pass());
-  io_handler_ = NULL;
+  io_handler_ = nullptr;
 }
 
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 // Static factory method declared in raw_channel.h.
 // static
 scoped_ptr<RawChannel> RawChannel::Create(
     embedder::ScopedPlatformHandle handle) {
   return scoped_ptr<RawChannel>(new RawChannelWin(handle.Pass()));
 }
 
 }  // namespace system
 }  // namespace mojo