Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/pseudotcp_unittest.cc

 /*
  *  Copyright 2011 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 197 matching lines @@
 class PseudoTcpTest : public PseudoTcpTestBase {
  public:
   void TestTransfer(int size) {
     uint32_t start;
     int32_t elapsed;
     size_t received;
     // Create some dummy data to send.
     send_stream_.ReserveSize(size);
     for (int i = 0; i < size; ++i) {
       char ch = static_cast<char>(i);
-      send_stream_.Write(&ch, 1, NULL, NULL);
+      send_stream_.Write(&ch, 1, nullptr, nullptr);
     }
     send_stream_.Rewind();
     // Prepare the receive stream.
     recv_stream_.ReserveSize(size);
     // Connect and wait until connected.
     start = rtc::Time32();
     EXPECT_EQ(0, Connect());
     EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
     // Sending will start from OnTcpWriteable and complete when all data has
     // been received.
@@ skipping 42 matching lines @@
     }
   }
 
   void ReadData() {
     char block[kBlockSize];
     size_t position;
     int rcvd;
     do {
       rcvd = remote_.Recv(block, sizeof(block));
       if (rcvd != -1) {
-        recv_stream_.Write(block, rcvd, NULL, NULL);
+        recv_stream_.Write(block, rcvd, nullptr, nullptr);
         recv_stream_.GetPosition(&position);
         LOG(LS_VERBOSE) << "Received: " << position;
       }
     } while (rcvd > 0);
   }
   void WriteData(bool* done) {
     size_t position, tosend;
     int sent;
     char block[kBlockSize];
     do {
       send_stream_.GetPosition(&position);
-      if (send_stream_.Read(block, sizeof(block), &tosend, NULL) !=
+      if (send_stream_.Read(block, sizeof(block), &tosend, nullptr) !=
           rtc::SR_EOS) {
         sent = local_.Send(block, tosend);
         UpdateLocalClock();
         if (sent != -1) {
           send_stream_.SetPosition(position + sent);
           LOG(LS_VERBOSE) << "Sent: " << position + sent;
         } else {
           send_stream_.SetPosition(position);
           LOG(LS_VERBOSE) << "Flow Controlled";
         }
       } else {
         sent = static_cast<int>(tosend = 0);
       }
     } while (sent > 0);
     *done = (tosend == 0);
   }
 
  private:
   rtc::MemoryStream send_stream_;
   rtc::MemoryStream recv_stream_;
 };
 
 
 class PseudoTcpTestPingPong : public PseudoTcpTestBase {
  public:
   PseudoTcpTestPingPong()
       : iterations_remaining_(0),
-        sender_(NULL),
-        receiver_(NULL),
-        bytes_per_send_(0) {
-  }
+        sender_(nullptr),
+        receiver_(nullptr),
+        bytes_per_send_(0) {}
   void SetBytesPerSend(int bytes) {
     bytes_per_send_ = bytes;
   }
   void TestPingPong(int size, int iterations) {
     uint32_t start, elapsed;
     iterations_remaining_ = iterations;
     receiver_ = &remote_;
     sender_ = &local_;
     // Create some dummy data to send.
     send_stream_.ReserveSize(size);
     for (int i = 0; i < size; ++i) {
       char ch = static_cast<char>(i);
-      send_stream_.Write(&ch, 1, NULL, NULL);
+      send_stream_.Write(&ch, 1, nullptr, nullptr);
     }
     send_stream_.Rewind();
     // Prepare the receive stream.
     recv_stream_.ReserveSize(size);
     // Connect and wait until connected.
     start = rtc::Time32();
     EXPECT_EQ(0, Connect());
     EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
     // Sending will start from OnTcpWriteable and stop when the required
     // number of iterations have completed.
@@ skipping 42 matching lines @@
     WriteData();
   }
 
   void ReadData() {
     char block[kBlockSize];
     size_t position;
     int rcvd;
     do {
       rcvd = receiver_->Recv(block, sizeof(block));
       if (rcvd != -1) {
-        recv_stream_.Write(block, rcvd, NULL, NULL);
+        recv_stream_.Write(block, rcvd, nullptr, nullptr);
         recv_stream_.GetPosition(&position);
         LOG(LS_VERBOSE) << "Received: " << position;
       }
     } while (rcvd > 0);
   }
   void WriteData() {
     size_t position, tosend;
     int sent;
     char block[kBlockSize];
     do {
       send_stream_.GetPosition(&position);
       tosend = bytes_per_send_ ? bytes_per_send_ : sizeof(block);
-      if (send_stream_.Read(block, tosend, &tosend, NULL) !=
-          rtc::SR_EOS) {
+      if (send_stream_.Read(block, tosend, &tosend, nullptr) != rtc::SR_EOS) {
         sent = sender_->Send(block, tosend);
         UpdateLocalClock();
         if (sent != -1) {
           send_stream_.SetPosition(position + sent);
           LOG(LS_VERBOSE) << "Sent: " << position + sent;
         } else {
           send_stream_.SetPosition(position);
           LOG(LS_VERBOSE) << "Flow Controlled";
         }
       } else {
@@ skipping 14 matching lines @@
 // contracts and enlarges correctly.
 class PseudoTcpTestReceiveWindow : public PseudoTcpTestBase {
  public:
   // Not all the data are transfered, |size| just need to be big enough
   // to fill up the receiver window twice.
   void TestTransfer(int size) {
     // Create some dummy data to send.
     send_stream_.ReserveSize(size);
     for (int i = 0; i < size; ++i) {
       char ch = static_cast<char>(i);
-      send_stream_.Write(&ch, 1, NULL, NULL);
+      send_stream_.Write(&ch, 1, nullptr, nullptr);
     }
     send_stream_.Rewind();
 
     // Prepare the receive stream.
     recv_stream_.ReserveSize(size);
 
     // Connect and wait until connected.
     EXPECT_EQ(0, Connect());
     EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
 
@@ skipping 46 matching lines @@
   }
 
   void ReadUntilIOPending() {
     char block[kBlockSize];
     size_t position;
     int rcvd;
 
     do {
       rcvd = remote_.Recv(block, sizeof(block));
       if (rcvd != -1) {
-        recv_stream_.Write(block, rcvd, NULL, NULL);
+        recv_stream_.Write(block, rcvd, nullptr, nullptr);
         recv_stream_.GetPosition(&position);
         LOG(LS_VERBOSE) << "Received: " << position;
       }
     } while (rcvd > 0);
 
     recv_stream_.GetPosition(&position);
     recv_position_.push_back(position);
 
     // Disconnect if we have done two transfers.
     if (recv_position_.size() == 2u) {
       Close();
       OnTcpClosed(&remote_, 0);
     } else {
       WriteData();
     }
   }
 
   void WriteData() {
     size_t position, tosend;
     int sent;
     char block[kBlockSize];
     do {
       send_stream_.GetPosition(&position);
-      if (send_stream_.Read(block, sizeof(block), &tosend, NULL) !=
+      if (send_stream_.Read(block, sizeof(block), &tosend, nullptr) !=
           rtc::SR_EOS) {
         sent = local_.Send(block, tosend);
         UpdateLocalClock();
         if (sent != -1) {
           send_stream_.SetPosition(position + sent);
           LOG(LS_VERBOSE) << "Sent: " << position + sent;
         } else {
           send_stream_.SetPosition(position);
           LOG(LS_VERBOSE) << "Flow Controlled";
         }
@@ skipping 281 matching lines @@
 /* Test sending data with mismatched MTUs. We should detect this and reduce
 // our packet size accordingly.
 // TODO: This doesn't actually work right now. The current code
 // doesn't detect if the MTU is set too high on either side.
 TEST_F(PseudoTcpTest, TestSendWithMismatchedMtus) {
   SetLocalMtu(1500);
   SetRemoteMtu(1280);
   TestTransfer(1000000);
 }
 */