Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/turnport_unittest.cc

 /*
  *  Copyright 2012 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.
  */
 #if defined(WEBRTC_POSIX)
@@ skipping 75 matching lines @@
 static const cricket::ProtocolAddress kTurnUdpIPv6ProtoAddr(
     kTurnUdpIPv6IntAddr, cricket::PROTO_UDP);
 
 static const unsigned int MSG_TESTFINISH = 0;
 
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
 static int GetFDCount() {
   struct dirent *dp;
   int fd_count = 0;
   DIR *dir = opendir("/proc/self/fd/");
-  while ((dp = readdir(dir)) != NULL) {
+  while ((dp = readdir(dir)) != nullptr) {
     if (dp->d_name[0] == '.')
       continue;
     ++fd_count;
   }
   closedir(dir);
   return fd_count;
 }
 #endif
 
 namespace cricket {
@@ skipping 165 matching lines @@
   }
 
   void CreateSharedTurnPort(const std::string& username,
                             const std::string& password,
                             const ProtocolAddress& server_address) {
     RTC_CHECK(server_address.proto == PROTO_UDP);
 
     if (!socket_) {
       socket_.reset(socket_factory_.CreateUdpSocket(
           rtc::SocketAddress(kLocalAddr1.ipaddr(), 0), 0, 0));
-      ASSERT_TRUE(socket_ != NULL);
+      ASSERT_TRUE(socket_ != nullptr);
       socket_->SignalReadPacket.connect(
           this, &TurnPortTest::OnSocketReadPacket);
     }
 
     RelayCredentials credentials(username, password);
     turn_port_.reset(TurnPort::Create(
         main_, &socket_factory_, &network_, socket_.get(), kIceUfrag1, kIcePwd1,
         server_address, credentials, 0, std::string()));
     // This TURN port will be the controlling.
     turn_port_->SetIceRole(ICEROLE_CONTROLLING);
@@ skipping 206 matching lines @@
     }
   }
 
   void TestTurnConnection(ProtocolType protocol_type) {
     // Create ports and prepare addresses.
     PrepareTurnAndUdpPorts(protocol_type);
 
     // Send ping from UDP to TURN.
     Connection* conn1 = udp_port_->CreateConnection(
                     turn_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
-    ASSERT_TRUE(conn1 != NULL);
+    ASSERT_TRUE(conn1 != nullptr);
     conn1->Ping(0);
     SIMULATED_WAIT(!turn_unknown_address_, kSimulatedRtt * 2, fake_clock_);
     EXPECT_FALSE(turn_unknown_address_);
     EXPECT_FALSE(conn1->receiving());
     EXPECT_EQ(Connection::STATE_WRITE_INIT, conn1->write_state());
 
     // Send ping from TURN to UDP.
     Connection* conn2 = turn_port_->CreateConnection(
                     udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
-    ASSERT_TRUE(conn2 != NULL);
+    ASSERT_TRUE(conn2 != nullptr);
     ASSERT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
                                fake_clock_);
     conn2->Ping(0);
 
     // Two hops from TURN port to UDP port through TURN server, thus two RTTs.
     EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn2->write_state(),
                              kSimulatedRtt * 2, fake_clock_);
     EXPECT_TRUE(conn1->receiving());
     EXPECT_TRUE(conn2->receiving());
     EXPECT_EQ(Connection::STATE_WRITE_INIT, conn1->write_state());
 
     // Send another ping from UDP to TURN.
     conn1->Ping(0);
     EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn1->write_state(),
                              kSimulatedRtt * 2, fake_clock_);
     EXPECT_TRUE(conn2->receiving());
   }
 
   void TestDestroyTurnConnection() {
     PrepareTurnAndUdpPorts(PROTO_UDP);
 
     // Create connections on both ends.
     Connection* conn1 = udp_port_->CreateConnection(turn_port_->Candidates()[0],
                                                     Port::ORIGIN_MESSAGE);
     Connection* conn2 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                      Port::ORIGIN_MESSAGE);
-    ASSERT_TRUE(conn2 != NULL);
+    ASSERT_TRUE(conn2 != nullptr);
     ASSERT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
                                fake_clock_);
     // Make sure turn connection can receive.
     conn1->Ping(0);
     EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn1->write_state(),
                              kSimulatedRtt * 2, fake_clock_);
     EXPECT_FALSE(turn_unknown_address_);
 
     // Destroy the connection on the TURN port. The TurnEntry still exists, so
     // the TURN port should still process a ping from an unknown address.
@@ skipping 19 matching lines @@
   }
 
   void TestTurnSendData(ProtocolType protocol_type) {
     PrepareTurnAndUdpPorts(protocol_type);
 
     // Create connections and send pings.
     Connection* conn1 = turn_port_->CreateConnection(
         udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
     Connection* conn2 = udp_port_->CreateConnection(
         turn_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
-    ASSERT_TRUE(conn1 != NULL);
-    ASSERT_TRUE(conn2 != NULL);
+    ASSERT_TRUE(conn1 != nullptr);
+    ASSERT_TRUE(conn2 != nullptr);
     conn1->SignalReadPacket.connect(static_cast<TurnPortTest*>(this),
                                     &TurnPortTest::OnTurnReadPacket);
     conn2->SignalReadPacket.connect(static_cast<TurnPortTest*>(this),
                                     &TurnPortTest::OnUdpReadPacket);
     conn1->Ping(0);
     EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn1->write_state(),
                              kSimulatedRtt * 2, fake_clock_);
     conn2->Ping(0);
     EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn2->write_state(),
                              kSimulatedRtt * 2, fake_clock_);
@@ skipping 284 matching lines @@
 
 // Test that TurnPort will not handle any incoming packets once it has been
 // closed.
 TEST_F(TurnPortTest, TestStopProcessingPacketsAfterClosed) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   PrepareTurnAndUdpPorts(PROTO_UDP);
   Connection* conn1 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                    Port::ORIGIN_MESSAGE);
   Connection* conn2 = udp_port_->CreateConnection(turn_port_->Candidates()[0],
                                                   Port::ORIGIN_MESSAGE);
-  ASSERT_TRUE(conn1 != NULL);
-  ASSERT_TRUE(conn2 != NULL);
+  ASSERT_TRUE(conn1 != nullptr);
+  ASSERT_TRUE(conn2 != nullptr);
   // Make sure conn2 is writable.
   conn2->Ping(0);
   EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn2->write_state(),
                            kSimulatedRtt * 2, fake_clock_);
 
   turn_port_->Close();
   SIMULATED_WAIT(false, kSimulatedRtt, fake_clock_);
   turn_unknown_address_ = false;
   conn2->Ping(0);
   SIMULATED_WAIT(false, kSimulatedRtt, fake_clock_);
   // Since the turn port does not handle packets any more, it should not
   // SignalUnknownAddress.
   EXPECT_FALSE(turn_unknown_address_);
 }
 
 // Test that CreateConnection will return null if port becomes disconnected.
 TEST_F(TurnPortTest, TestCreateConnectionWhenSocketClosed) {
   turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
   PrepareTurnAndUdpPorts(PROTO_TCP);
   // Create a connection.
   Connection* conn1 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                    Port::ORIGIN_MESSAGE);
-  ASSERT_TRUE(conn1 != NULL);
+  ASSERT_TRUE(conn1 != nullptr);
 
   // Close the socket and create a connection again.
   turn_port_->OnSocketClose(turn_port_->socket(), 1);
   conn1 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                        Port::ORIGIN_MESSAGE);
-  ASSERT_TRUE(conn1 == NULL);
+  ASSERT_TRUE(conn1 == nullptr);
 }
 
 // Tests that when a TCP socket is closed, the respective TURN connection will
 // be destroyed.
 TEST_F(TurnPortTest, TestSocketCloseWillDestroyConnection) {
   turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
   PrepareTurnAndUdpPorts(PROTO_TCP);
   Connection* conn = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                   Port::ORIGIN_MESSAGE);
@@ skipping 116 matching lines @@
 
 // Test that CreatePermissionRequest will be scheduled after the success
 // of the first create permission request and the request will get an
 // ErrorResponse if the ufrag and pwd are incorrect.
 TEST_F(TurnPortTest, TestRefreshCreatePermissionRequest) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   PrepareTurnAndUdpPorts(PROTO_UDP);
 
   Connection* conn = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                   Port::ORIGIN_MESSAGE);
-  ASSERT_TRUE(conn != NULL);
+  ASSERT_TRUE(conn != nullptr);
   EXPECT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
                              fake_clock_);
   turn_create_permission_success_ = false;
   // A create-permission-request should be pending.
   // After the next create-permission-response is received, it will schedule
   // another request with bad_ufrag and bad_pwd.
   RelayCredentials bad_credentials("bad_user", "bad_pwd");
   turn_port_->set_credentials(bad_credentials);
   turn_port_->FlushRequests(kAllRequests);
   EXPECT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
@@ skipping 107 matching lines @@
   EXPECT_EQ(nullptr, conn);
 }
 
 TEST_F(TurnPortTest, TestOriginHeader) {
   CreateTurnPortWithOrigin(kLocalAddr1, kTurnUsername, kTurnPassword,
                            kTurnUdpProtoAddr, kTestOrigin);
   turn_port_->PrepareAddress();
   EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
   ASSERT_GT(turn_server_.server()->allocations().size(), 0U);
   SocketAddress local_address = turn_port_->GetLocalAddress();
-  ASSERT_TRUE(turn_server_.FindAllocation(local_address) != NULL);
+  ASSERT_TRUE(turn_server_.FindAllocation(local_address) != nullptr);
   EXPECT_EQ(kTestOrigin, turn_server_.FindAllocation(local_address)->origin());
 }
 
 // Test that a CreatePermission failure will result in the connection being
 // pruned and failed.
 TEST_F(TurnPortTest, TestConnectionFailedAndPrunedOnCreatePermissionFailure) {
   turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   turn_server_.server()->set_reject_private_addresses(true);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
   turn_port_->PrepareAddress();
@@ skipping 60 matching lines @@
   EXPECT_TRUE(turn_port_->Candidates().empty());
   turn_port_.reset();
   rtc::Thread::Current()->Post(RTC_FROM_HERE, this, MSG_TESTFINISH);
   // Waiting for above message to be processed.
   ASSERT_TRUE_SIMULATED_WAIT(test_finish_, 1, fake_clock_);
   EXPECT_EQ(last_fd_count, GetFDCount());
 }
 #endif
 
 }  // namespace cricket