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

mojo/system/message_pipe_perftest.cc

 // Copyright 2014 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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <string>
 #include <vector>
@@ skipping 32 matching lines @@
     payload_ = Pickle();
     payload_.WriteString(std::string(message_size, '*'));
     read_buffer_.resize(message_size * 2);
   }
 
  protected:
   void WriteWaitThenRead(scoped_refptr<MessagePipe> mp) {
     CHECK_EQ(mp->WriteMessage(0,
                               UserPointer<const void>(payload_.data()),
                               static_cast<uint32_t>(payload_.size()),
-                              NULL,
+                              nullptr,
                               MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     HandleSignalsState hss;
     CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
              MOJO_RESULT_OK);
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer_.size());
     CHECK_EQ(mp->ReadMessage(0,
                              UserPointer<void>(&read_buffer_[0]),
                              MakeUserPointer(&read_buffer_size),
-                             NULL,
-                             NULL,
+                             nullptr,
+                             nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     CHECK_EQ(read_buffer_size, static_cast<uint32_t>(payload_.size()));
   }
 
   void SendQuitMessage(scoped_refptr<MessagePipe> mp) {
     CHECK_EQ(mp->WriteMessage(0,
                               UserPointer<const void>(""),
                               0,
-                              NULL,
+                              nullptr,
                               MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   }
 
   void Measure(scoped_refptr<MessagePipe> mp) {
     // Have one ping-pong to ensure channel being established.
     WriteWaitThenRead(mp);
 
     std::string test_name =
         base::StringPrintf("IPC_Perf_%dx_%u",
@@ skipping 38 matching lines @@
         test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss);
     if (result != MOJO_RESULT_OK) {
       rv = result;
       break;
     }
 
     uint32_t read_size = static_cast<uint32_t>(buffer.size());
     CHECK_EQ(mp->ReadMessage(0,
                              UserPointer<void>(&buffer[0]),
                              MakeUserPointer(&read_size),
-                             NULL,
-                             NULL,
+                             nullptr,
+                             nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
 
     // Empty message indicates quitting
     if (0 == read_size)
       break;
 
     CHECK_EQ(mp->WriteMessage(0,
                               UserPointer<const void>(&buffer[0]),
                               static_cast<uint32_t>(read_size),
-                              NULL,
+                              nullptr,
                               MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   }
 
   mp->Close(0);
   return rv;
 }
 
 // Repeatedly sends messages as previous one got replied by the child.
 // Waits for the child to close its end before quitting once specified
@@ skipping 15 matching lines @@
   }
 
   SendQuitMessage(mp);
   mp->Close(0);
   EXPECT_EQ(0, helper()->WaitForChildShutdown());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo