Mojo: NULL -> nullptr in mojo/public/cpp outside of bindings.

mojo/public/cpp/system/tests/core_unittest.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.
 
 // This file tests the C++ Mojo system core wrappers.
 // TODO(vtl): Maybe rename "CoreCppTest" -> "CoreTest" if/when this gets
 // compiled into a different binary from the C API tests.
 
 #include "mojo/public/cpp/system/core.h"
 
@@ skipping 106 matching lines @@
     EXPECT_FALSE(MakeScopedHandle(DataPipeConsumerHandle()).is_valid());
     EXPECT_FALSE(MakeScopedHandle(SharedBufferHandle()).is_valid());
   }
 
   // |MessagePipeHandle|/|ScopedMessagePipeHandle| functions:
   {
     MessagePipeHandle h_invalid;
     EXPECT_FALSE(h_invalid.is_valid());
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               WriteMessageRaw(h_invalid,
-                              NULL, 0,
-                              NULL, 0,
+                              nullptr, 0,
+                              nullptr, 0,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
     char buffer[10] = { 0 };
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               WriteMessageRaw(h_invalid,
                               buffer, sizeof(buffer),
-                              NULL, 0,
+                              nullptr, 0,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               ReadMessageRaw(h_invalid,
-                             NULL, NULL,
-                             NULL, NULL,
+                             nullptr, nullptr,
+                             nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
     uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               ReadMessageRaw(h_invalid,
                              buffer, &buffer_size,
-                             NULL, NULL,
+                             nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
 
     // Basic tests of waiting and closing.
     MojoHandle hv0 = kInvalidHandleValue;
     {
       ScopedMessagePipeHandle h0;
       ScopedMessagePipeHandle h1;
       EXPECT_FALSE(h0.get().is_valid());
       EXPECT_FALSE(h1.get().is_valid());
 
-      CreateMessagePipe(NULL, &h0, &h1);
+      CreateMessagePipe(nullptr, &h0, &h1);
       EXPECT_TRUE(h0.get().is_valid());
       EXPECT_TRUE(h1.get().is_valid());
       EXPECT_NE(h0.get().value(), h1.get().value());
       // Save the handle values, so we can check that things got closed
       // correctly.
       hv0 = h0.get().value();
       MojoHandle hv1 = h1.get().value();
 
       EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
                 Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE, 0));
@@ skipping 19 matching lines @@
                      MOJO_DEADLINE_INDEFINITE));
     }
     // |hv0| should have been closed when |h0| went out of scope, so this close
     // should fail.
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv0));
 
     // Actually test writing/reading messages.
     {
       ScopedMessagePipeHandle h0;
       ScopedMessagePipeHandle h1;
-      CreateMessagePipe(NULL, &h0, &h1);
+      CreateMessagePipe(nullptr, &h0, &h1);
 
       const char kHello[] = "hello";
       const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
       EXPECT_EQ(MOJO_RESULT_OK,
                 WriteMessageRaw(h0.get(),
                                 kHello, kHelloSize,
-                                NULL, 0,
+                                nullptr, 0,
                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
       EXPECT_EQ(MOJO_RESULT_OK,
                 Wait(h1.get(), MOJO_HANDLE_SIGNAL_READABLE,
                      MOJO_DEADLINE_INDEFINITE));
       char buffer[10] = { 0 };
       uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
       EXPECT_EQ(MOJO_RESULT_OK,
                 ReadMessageRaw(h1.get(),
                                buffer, &buffer_size,
-                               NULL, NULL,
+                               nullptr, nullptr,
                                MOJO_READ_MESSAGE_FLAG_NONE));
       EXPECT_EQ(kHelloSize, buffer_size);
       EXPECT_STREQ(kHello, buffer);
 
       // Send a handle over the previously-establish message pipe. Use the
       // |MessagePipe| wrapper (to test it), which automatically creates a
       // message pipe.
       MessagePipe mp;
 
       // Write a message to |mp.handle0|, before we send |mp.handle1|.
       const char kWorld[] = "world!";
       const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
       EXPECT_EQ(MOJO_RESULT_OK,
                 WriteMessageRaw(mp.handle0.get(),
                                 kWorld, kWorldSize,
-                                NULL, 0,
+                                nullptr, 0,
                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
 
       // Send |mp.handle1| over |h1| to |h0|.
       MojoHandle handles[5];
       handles[0] = mp.handle1.release().value();
       EXPECT_NE(kInvalidHandleValue, handles[0]);
       EXPECT_FALSE(mp.handle1.get().is_valid());
       uint32_t handles_count = 1;
       EXPECT_EQ(MOJO_RESULT_OK,
                 WriteMessageRaw(h1.get(),
@@ skipping 49 matching lines @@
   // TODO(vtl): Test |CloseRaw()|.
   // TODO(vtl): Test |reset()| more thoroughly?
 }
 
 TEST(CoreCppTest, TearDownWithMessagesEnqueued) {
   // Tear down a message pipe which still has a message enqueued, with the
   // message also having a valid message pipe handle.
   {
     ScopedMessagePipeHandle h0;
     ScopedMessagePipeHandle h1;
-    CreateMessagePipe(NULL, &h0, &h1);
+    CreateMessagePipe(nullptr, &h0, &h1);
 
     // Send a handle over the previously-establish message pipe.
     ScopedMessagePipeHandle h2;
     ScopedMessagePipeHandle h3;
-    CreateMessagePipe(NULL, &h2, &h3);
+    CreateMessagePipe(nullptr, &h2, &h3);
 
     // Write a message to |h2|, before we send |h3|.
     const char kWorld[] = "world!";
     const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
     EXPECT_EQ(MOJO_RESULT_OK,
               WriteMessageRaw(h2.get(),
                               kWorld, kWorldSize,
-                              NULL, 0,
+                              nullptr, 0,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
     // And also a message to |h3|.
     EXPECT_EQ(MOJO_RESULT_OK,
               WriteMessageRaw(h3.get(),
                               kWorld, kWorldSize,
-                              NULL, 0,
+                              nullptr, 0,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Send |h3| over |h1| to |h0|.
     const char kHello[] = "hello";
     const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
     MojoHandle h3_value;
     h3_value = h3.release().value();
     EXPECT_NE(kInvalidHandleValue, h3_value);
     EXPECT_FALSE(h3.get().is_valid());
     EXPECT_EQ(MOJO_RESULT_OK,
               WriteMessageRaw(h1.get(),
                               kHello, kHelloSize,
                               &h3_value, 1,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
     // |h3_value| should actually be invalid now.
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h3_value));
 
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0.release().value()));
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1.release().value()));
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h2.release().value()));
   }
 
   // Do this in a different order: make the enqueued message pipe handle only
   // half-alive.
   {
     ScopedMessagePipeHandle h0;
     ScopedMessagePipeHandle h1;
-    CreateMessagePipe(NULL, &h0, &h1);
+    CreateMessagePipe(nullptr, &h0, &h1);
 
     // Send a handle over the previously-establish message pipe.
     ScopedMessagePipeHandle h2;
     ScopedMessagePipeHandle h3;
-    CreateMessagePipe(NULL, &h2, &h3);
+    CreateMessagePipe(nullptr, &h2, &h3);
 
     // Write a message to |h2|, before we send |h3|.
     const char kWorld[] = "world!";
     const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
     EXPECT_EQ(MOJO_RESULT_OK,
               WriteMessageRaw(h2.get(),
                               kWorld, kWorldSize,
-                              NULL, 0,
+                              nullptr, 0,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
     // And also a message to |h3|.
     EXPECT_EQ(MOJO_RESULT_OK,
               WriteMessageRaw(h3.get(),
                               kWorld, kWorldSize,
-                              NULL, 0,
+                              nullptr, 0,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Send |h3| over |h1| to |h0|.
     const char kHello[] = "hello";
     const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
     MojoHandle h3_value;
     h3_value = h3.release().value();
     EXPECT_NE(kInvalidHandleValue, h3_value);
     EXPECT_FALSE(h3.get().is_valid());
     EXPECT_EQ(MOJO_RESULT_OK,
               WriteMessageRaw(h1.get(),
                               kHello, kHelloSize,
                               &h3_value, 1,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
     // |h3_value| should actually be invalid now.
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h3_value));
 
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h2.release().value()));
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0.release().value()));
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1.release().value()));
   }
 }
 
 TEST(CoreCppTest, ScopedHandleMoveCtor) {
   ScopedSharedBufferHandle buffer1;
-  EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(NULL, 1024, &buffer1));
+  EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer1));
   EXPECT_TRUE(buffer1.is_valid());
 
   ScopedSharedBufferHandle buffer2;
-  EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(NULL, 1024, &buffer2));
+  EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer2));
   EXPECT_TRUE(buffer2.is_valid());
 
   // If this fails to close buffer1, ScopedHandleBase::CloseIfNecessary() will
   // assert.
   buffer1 = buffer2.Pass();
 
   EXPECT_TRUE(buffer1.is_valid());
   EXPECT_FALSE(buffer2.is_valid());
 }
 
 TEST(CoreCppTest, ScopedHandleMoveCtorSelf) {
   ScopedSharedBufferHandle buffer1;
-  EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(NULL, 1024, &buffer1));
+  EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer1));
   EXPECT_TRUE(buffer1.is_valid());
 
   buffer1 = buffer1.Pass();
 
   EXPECT_TRUE(buffer1.is_valid());
 }
 
 // TODO(vtl): Write data pipe tests.
 
 }  // namespace
 }  // namespace mojo