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

mojo/system/core_unittest.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/core.h"
 
 #include <stdint.h>
 
 #include <limits>
 
@@ skipping 1079 matching lines @@
   num_bytes = 1u;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadData(ch,
                              UserPointer<void>(elements),
                              MakeUserPointer(&num_bytes),
                              MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ('A', elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
   // Two-phase write.
-  void* write_ptr = NULL;
+  void* write_ptr = nullptr;
   num_bytes = 0u;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->BeginWriteData(ph,
                                    MakeUserPointer(&write_ptr),
                                    MakeUserPointer(&num_bytes),
                                    MOJO_WRITE_DATA_FLAG_NONE));
   // We count on the default options providing a decent buffer size.
   ASSERT_GE(num_bytes, 3u);
 
   // Trying to do a normal write during a two-phase write should fail.
@@ skipping 32 matching lines @@
   // Discard two characters.
   num_bytes = 2;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadData(
                 ch,
                 NullUserPointer(),
                 MakeUserPointer(&num_bytes),
                 MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
 
   // Read the remaining two characters, in two-phase mode (all-or-none).
-  const void* read_ptr = NULL;
+  const void* read_ptr = nullptr;
   num_bytes = 2;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->BeginReadData(ch,
                                   MakeUserPointer(&read_ptr),
                                   MakeUserPointer(&num_bytes),
                                   MOJO_READ_DATA_FLAG_ALL_OR_NONE));
   // Note: Count on still being able to do the contiguous read here.
   ASSERT_EQ(2u, num_bytes);
 
   // Discarding right now should fail.
@@ skipping 190 matching lines @@
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
 
   ph = ph_received;
   ph_received = MOJO_HANDLE_INVALID;
   ch = ch_received;
   ch_received = MOJO_HANDLE_INVALID;
 
   // Make sure that |ph| can't be sent if it's in a two-phase write.
-  void* write_ptr = NULL;
+  void* write_ptr = nullptr;
   num_bytes = 0;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->BeginWriteData(ph,
                                    MakeUserPointer(&write_ptr),
                                    MakeUserPointer(&num_bytes),
                                    MOJO_WRITE_DATA_FLAG_NONE));
   ASSERT_GE(num_bytes, 1u);
   EXPECT_EQ(MOJO_RESULT_BUSY,
             core()->WriteMessage(h_passing[0],
                                  UserPointer<const void>(kHello),
@@ skipping 38 matching lines @@
   // Wait for |ch| to be readable.
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(
       MOJO_RESULT_OK,
       core()->Wait(
           ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
   // Make sure that |ch| can't be sent if it's in a two-phase read.
-  const void* read_ptr = NULL;
+  const void* read_ptr = nullptr;
   num_bytes = 1;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->BeginReadData(ch,
                                   MakeUserPointer(&read_ptr),
                                   MakeUserPointer(&num_bytes),
                                   MOJO_READ_DATA_FLAG_ALL_OR_NONE));
   EXPECT_EQ(MOJO_RESULT_BUSY,
             core()->WriteMessage(h_passing[0],
                                  UserPointer<const void>(kHello),
                                  kHelloSize,
@@ skipping 43 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
 }
 
 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo