Replace NULL with nullptr or null in webrtc/base/.

webrtc/base/httpbase_unittest.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 36 matching lines @@
 class HttpBaseTest : public testing::Test, public IHttpNotify {
 public:
   enum EventType { E_HEADER_COMPLETE, E_COMPLETE, E_CLOSED };
   struct Event {
     EventType event;
     bool chunked;
     size_t data_size;
     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() {
     delete http_stream;
     // Avoid an ASSERT, in case a test doesn't clean up properly
     base.abort(HE_NONE);
   }
 
   virtual HttpError onHttpHeaderComplete(bool chunked, size_t& data_size) {
     LOG_F(LS_VERBOSE) << "chunked: " << chunked << " size: " << data_size;
@@ skipping 114 matching lines @@
   mem->GetSize(&length);
   EXPECT_EQ(expected_length, length);
   EXPECT_TRUE(0 == memcmp(expected_data, mem->GetBuffer(), length));
   LOG_F(LS_VERBOSE) << "Exit";
 }
 
 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());
 
   // HTTP headers haven't arrived yet
   EXPECT_EQ(0U, events.size());
   EXPECT_EQ(static_cast<uint32_t>(HC_INTERNAL_SERVER_ERROR), data.scode);
   LOG_F(LS_VERBOSE) << "Exit";
 }
 
 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.
   size_t verified_length = 0;
   const size_t expected_length = strlen(expected_data);
   while (verified_length < expected_length) {
     size_t read = 0;
     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;
   }
   LOG_F(LS_VERBOSE) << "Exit";
 }
 
 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
   EXPECT_EQ(0, sink.Events(http_stream));
   LOG_F(LS_VERBOSE) << "Exit";
 }
 
 void HttpBaseTest::SetupDocument(const char* document_data) {
   LOG_F(LS_VERBOSE) << "Enter";
   src.SetState(SS_OPEN);
@@ skipping 52 matching lines @@
   // Begin send
   base.send(&data);
 
   // Send completed successfully
   VerifyTransferComplete(HM_SEND, HE_NONE);
   VerifySourceContents(kHttpResponse);
 }
 
 TEST_F(HttpBaseTest, SupportsSendNoDocument) {
   // Queue response document
-  SetupDocument(NULL);
+  SetupDocument(nullptr);
 
   // Begin send
   base.send(&data);
 
   // Send completed successfully
   VerifyTransferComplete(HM_SEND, HE_NONE);
   VerifySourceContents(kHttpEmptyResponse);
 }
 
 TEST_F(HttpBaseTest, SignalsCompleteOnInterruptedSend) {
@@ skipping 134 matching lines @@
   obtain_stream = true;
 
   // Begin receive
   base.recv(&data);
 
   // We've already seen the header, but not data has arrived
   VerifyHeaderComplete(1, true);
   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
   VerifyDocumentStreamIsEOS();
 
   // Document completed successfully
   VerifyTransferComplete(HM_RECV, HE_NONE);
   VerifyDocumentContents("");
 }
 
@@ skipping 15 matching lines @@
 
   // Simulate unexpected close
   src.SetState(SS_CLOSED);
 
   // Observe error event on document stream
   EXPECT_EQ(testing::SSE_ERROR, sink.Events(http_stream));
 
   // 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
   VerifyHeaderComplete(2, false);
   VerifyTransferComplete(HM_RECV, HE_DISCONNECTED);
   VerifyDocumentContents("");
 }
 
 } // namespace rtc