Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/port_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 211 matching lines @@
   int type_preference_ = 0;
 };
 
 class TestChannel : public sigslot::has_slots<> {
  public:
   // Takes ownership of |p1| (but not |p2|).
   TestChannel(Port* p1)
       : ice_mode_(ICEMODE_FULL),
         port_(p1),
         complete_count_(0),
-        conn_(NULL),
+        conn_(nullptr),
         remote_request_(),
         nominated_(false) {
     port_->SignalPortComplete.connect(this, &TestChannel::OnPortComplete);
     port_->SignalUnknownAddress.connect(this, &TestChannel::OnUnknownAddress);
     port_->SignalDestroyed.connect(this, &TestChannel::OnSrcPortDestroyed);
   }
 
   int complete_count() { return complete_count_; }
   Connection* conn() { return conn_; }
   const SocketAddress& remote_address() { return remote_address_; }
@@ skipping 13 matching lines @@
                                      &TestChannel::OnConnectionReadyToSend);
     connection_ready_to_send_ = false;
   }
   void OnConnectionStateChange(Connection* conn) {
     if (conn->write_state() == Connection::STATE_WRITABLE) {
       conn->set_use_candidate_attr(true);
       nominated_ = true;
     }
   }
   void AcceptConnection(const Candidate& remote_candidate) {
-    ASSERT_TRUE(remote_request_.get() != NULL);
+    ASSERT_TRUE(remote_request_.get() != nullptr);
     Candidate c = remote_candidate;
     c.set_address(remote_address_);
     conn_ = port_->CreateConnection(c, Port::ORIGIN_MESSAGE);
     conn_->SignalDestroyed.connect(this, &TestChannel::OnDestroyed);
     port_->SendBindingResponse(remote_request_.get(), remote_address_);
     remote_request_.reset();
   }
   void Ping() {
     Ping(0);
   }
@@ skipping 23 matching lines @@
     ASSERT_EQ(port_.get(), port);
     if (!remote_address_.IsNil()) {
       ASSERT_EQ(remote_address_, addr);
     }
     const cricket::StunUInt32Attribute* priority_attr =
         msg->GetUInt32(STUN_ATTR_PRIORITY);
     const cricket::StunByteStringAttribute* mi_attr =
         msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY);
     const cricket::StunUInt32Attribute* fingerprint_attr =
         msg->GetUInt32(STUN_ATTR_FINGERPRINT);
-    EXPECT_TRUE(priority_attr != NULL);
-    EXPECT_TRUE(mi_attr != NULL);
-    EXPECT_TRUE(fingerprint_attr != NULL);
+    EXPECT_TRUE(priority_attr != nullptr);
+    EXPECT_TRUE(mi_attr != nullptr);
+    EXPECT_TRUE(fingerprint_attr != nullptr);
     remote_address_ = addr;
     remote_request_.reset(CopyStunMessage(msg));
     remote_frag_ = rf;
   }
 
   void OnDestroyed(Connection* conn) {
     ASSERT_EQ(conn_, conn);
     LOG(INFO) << "OnDestroy connection " << conn << " deleted";
-    conn_ = NULL;
+    conn_ = nullptr;
     // When the connection is destroyed, also clear these fields so future
     // connections are possible.
     remote_request_.reset();
     remote_address_.Clear();
   }
 
   void OnSrcPortDestroyed(PortInterface* port) {
     Port* destroyed_src = port_.release();
     ASSERT_EQ(destroyed_src, port);
   }
@@ skipping 315 matching lines @@
 
     // Ensure redundant SignalClose events on TcpConnection won't break tcp
     // reconnection. Chromium will fire SignalClose for all outstanding IPC
     // packets during reconnection.
     tcp_conn1->socket()->SignalClose(tcp_conn1->socket(), 0);
     tcp_conn2->socket()->SignalClose(tcp_conn2->socket(), 0);
 
     // Speed up destroying ch2's connection such that the test is ready to
     // accept a new connection from ch1 before ch1's connection destroys itself.
     ch2->conn()->Destroy();
-    EXPECT_TRUE_WAIT(ch2->conn() == NULL, kDefaultTimeout);
+    EXPECT_TRUE_WAIT(ch2->conn() == nullptr, kDefaultTimeout);
   }
 
   void TestTcpReconnect(bool ping_after_disconnected,
                         bool send_after_disconnected) {
     Port* port1 = CreateTcpPort(kLocalAddr1);
     port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
     Port* port2 = CreateTcpPort(kLocalAddr2);
     port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
 
     port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
@@ skipping 54 matching lines @@
       EXPECT_EQ(ch1.conn()->write_state(), Connection::STATE_WRITABLE);
       // Since the reconnection never happens, the connections should have been
       // destroyed after the timeout.
       EXPECT_TRUE_WAIT(!ch1.conn(), kTcpReconnectTimeout + kDefaultTimeout);
       EXPECT_TRUE(!ch2.conn());
     }
 
     // Tear down and ensure that goes smoothly.
     ch1.Stop();
     ch2.Stop();
-    EXPECT_TRUE_WAIT(ch1.conn() == NULL, kDefaultTimeout);
-    EXPECT_TRUE_WAIT(ch2.conn() == NULL, kDefaultTimeout);
+    EXPECT_TRUE_WAIT(ch1.conn() == nullptr, kDefaultTimeout);
+    EXPECT_TRUE_WAIT(ch2.conn() == nullptr, kDefaultTimeout);
   }
 
   IceMessage* CreateStunMessage(int type) {
     IceMessage* msg = new IceMessage();
     msg->SetType(type);
     msg->SetTransactionID("TESTTESTTEST");
     return msg;
   }
   IceMessage* CreateStunMessageWithUsername(int type,
                                             const std::string& username) {
@@ skipping 77 matching lines @@
   EXPECT_EQ(0, ch2.complete_count());
 
   // Acquire addresses.
   ch1.Start();
   ch2.Start();
   ASSERT_EQ_SIMULATED_WAIT(1, ch1.complete_count(), kDefaultTimeout, clock);
   ASSERT_EQ_SIMULATED_WAIT(1, ch2.complete_count(), kDefaultTimeout, clock);
 
   // Send a ping from src to dst. This may or may not make it.
   ch1.CreateConnection(GetCandidate(port2));
-  ASSERT_TRUE(ch1.conn() != NULL);
+  ASSERT_TRUE(ch1.conn() != nullptr);
   EXPECT_TRUE_SIMULATED_WAIT(ch1.conn()->connected(), kDefaultTimeout,
                              clock);  // for TCP connect
   ch1.Ping();
   SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
 
   if (accept) {
     // We are able to send a ping from src to dst. This is the case when
     // sending to UDP ports and cone NATs.
     EXPECT_TRUE(ch1.remote_address().IsNil());
     EXPECT_EQ(ch2.remote_fragment(), port1->username_fragment());
 
     // Ensure the ping came from the same address used for src.
     // This is the case unless the source NAT was symmetric.
     if (same_addr1) EXPECT_EQ(ch2.remote_address(), GetAddress(port1));
     EXPECT_TRUE(same_addr2);
 
     // Send a ping from dst to src.
     ch2.AcceptConnection(GetCandidate(port1));
-    ASSERT_TRUE(ch2.conn() != NULL);
+    ASSERT_TRUE(ch2.conn() != nullptr);
     ch2.Ping();
     EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE,
                              ch2.conn()->write_state(), kDefaultTimeout, clock);
   } else {
     // We can't send a ping from src to dst, so flip it around. This will happen
     // when the destination NAT is addr/port restricted or symmetric.
     EXPECT_TRUE(ch1.remote_address().IsNil());
     EXPECT_TRUE(ch2.remote_address().IsNil());
 
     // Send a ping from dst to src. Again, this may or may not make it.
     ch2.CreateConnection(GetCandidate(port1));
-    ASSERT_TRUE(ch2.conn() != NULL);
+    ASSERT_TRUE(ch2.conn() != nullptr);
     ch2.Ping();
     SIMULATED_WAIT(ch2.conn()->write_state() == Connection::STATE_WRITABLE,
                    kShortTimeout, clock);
 
     if (same_addr1 && same_addr2) {
       // The new ping got back to the source.
       EXPECT_TRUE(ch1.conn()->receiving());
       EXPECT_EQ(Connection::STATE_WRITABLE, ch2.conn()->write_state());
 
       // First connection may not be writable if the first ping did not get
@@ skipping 13 matching lines @@
       // However, since we have now sent a ping to the source IP, we should be
       // able to get a ping from it. This gives us the real source address.
       ch1.Ping();
       EXPECT_TRUE_SIMULATED_WAIT(!ch2.remote_address().IsNil(), kDefaultTimeout,
                                  clock);
       EXPECT_FALSE(ch2.conn()->receiving());
       EXPECT_TRUE(ch1.remote_address().IsNil());
 
       // Pick up the actual address and establish the connection.
       ch2.AcceptConnection(GetCandidate(port1));
-      ASSERT_TRUE(ch2.conn() != NULL);
+      ASSERT_TRUE(ch2.conn() != nullptr);
       ch2.Ping();
       EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE,
                                ch2.conn()->write_state(), kDefaultTimeout,
                                clock);
     } else if (!same_addr2 && possible) {
       // The new ping came in, but from an unexpected address. This will happen
       // when the destination NAT is symmetric.
       EXPECT_FALSE(ch1.remote_address().IsNil());
       EXPECT_FALSE(ch1.conn()->receiving());
 
       // Update our address and complete the connection.
       ch1.AcceptConnection(GetCandidate(port2));
       ch1.Ping();
       EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE,
                                ch1.conn()->write_state(), kDefaultTimeout,
                                clock);
     } else {  // (!possible)
       // There should be s no way for the pings to reach each other. Check it.
       EXPECT_TRUE(ch1.remote_address().IsNil());
       EXPECT_TRUE(ch2.remote_address().IsNil());
       ch1.Ping();
       SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
       EXPECT_TRUE(ch1.remote_address().IsNil());
       EXPECT_TRUE(ch2.remote_address().IsNil());
     }
   }
 
   // Everything should be good, unless we know the situation is impossible.
-  ASSERT_TRUE(ch1.conn() != NULL);
-  ASSERT_TRUE(ch2.conn() != NULL);
+  ASSERT_TRUE(ch1.conn() != nullptr);
+  ASSERT_TRUE(ch2.conn() != nullptr);
   if (possible) {
     EXPECT_TRUE(ch1.conn()->receiving());
     EXPECT_EQ(Connection::STATE_WRITABLE, ch1.conn()->write_state());
     EXPECT_TRUE(ch2.conn()->receiving());
     EXPECT_EQ(Connection::STATE_WRITABLE, ch2.conn()->write_state());
   } else {
     EXPECT_FALSE(ch1.conn()->receiving());
     EXPECT_NE(Connection::STATE_WRITABLE, ch1.conn()->write_state());
     EXPECT_FALSE(ch2.conn()->receiving());
     EXPECT_NE(Connection::STATE_WRITABLE, ch2.conn()->write_state());
   }
 
   // Tear down and ensure that goes smoothly.
   ch1.Stop();
   ch2.Stop();
-  EXPECT_TRUE_SIMULATED_WAIT(ch1.conn() == NULL, kDefaultTimeout, clock);
-  EXPECT_TRUE_SIMULATED_WAIT(ch2.conn() == NULL, kDefaultTimeout, clock);
+  EXPECT_TRUE_SIMULATED_WAIT(ch1.conn() == nullptr, kDefaultTimeout, clock);
+  EXPECT_TRUE_SIMULATED_WAIT(ch2.conn() == nullptr, kDefaultTimeout, clock);
 }
 
 class FakePacketSocketFactory : public rtc::PacketSocketFactory {
  public:
   FakePacketSocketFactory()
-      : next_udp_socket_(NULL),
-        next_server_tcp_socket_(NULL),
-        next_client_tcp_socket_(NULL) {
-  }
+      : next_udp_socket_(nullptr),
+        next_server_tcp_socket_(nullptr),
+        next_client_tcp_socket_(nullptr) {}
   ~FakePacketSocketFactory() override { }
 
   AsyncPacketSocket* CreateUdpSocket(const SocketAddress& address,
                                      uint16_t min_port,
                                      uint16_t max_port) override {
-    EXPECT_TRUE(next_udp_socket_ != NULL);
+    EXPECT_TRUE(next_udp_socket_ != nullptr);
     AsyncPacketSocket* result = next_udp_socket_;
-    next_udp_socket_ = NULL;
+    next_udp_socket_ = nullptr;
     return result;
   }
 
   AsyncPacketSocket* CreateServerTcpSocket(const SocketAddress& local_address,
                                            uint16_t min_port,
                                            uint16_t max_port,
                                            int opts) override {
-    EXPECT_TRUE(next_server_tcp_socket_ != NULL);
+    EXPECT_TRUE(next_server_tcp_socket_ != nullptr);
     AsyncPacketSocket* result = next_server_tcp_socket_;
-    next_server_tcp_socket_ = NULL;
+    next_server_tcp_socket_ = nullptr;
     return result;
   }
 
   // TODO: |proxy_info| and |user_agent| should be set
   // per-factory and not when socket is created.
   AsyncPacketSocket* CreateClientTcpSocket(const SocketAddress& local_address,
                                            const SocketAddress& remote_address,
                                            const rtc::ProxyInfo& proxy_info,
                                            const std::string& user_agent,
                                            int opts) override {
-    EXPECT_TRUE(next_client_tcp_socket_ != NULL);
+    EXPECT_TRUE(next_client_tcp_socket_ != nullptr);
     AsyncPacketSocket* result = next_client_tcp_socket_;
-    next_client_tcp_socket_ = NULL;
+    next_client_tcp_socket_ = nullptr;
     return result;
   }
 
   void set_next_udp_socket(AsyncPacketSocket* next_udp_socket) {
     next_udp_socket_ = next_udp_socket;
   }
   void set_next_server_tcp_socket(AsyncPacketSocket* next_server_tcp_socket) {
     next_server_tcp_socket_ = next_server_tcp_socket;
   }
   void set_next_client_tcp_socket(AsyncPacketSocket* next_client_tcp_socket) {
     next_client_tcp_socket_ = next_client_tcp_socket;
   }
   rtc::AsyncResolverInterface* CreateAsyncResolver() override {
-    return NULL;
+    return nullptr;
   }
 
  private:
   AsyncPacketSocket* next_udp_socket_;
   AsyncPacketSocket* next_server_tcp_socket_;
   AsyncPacketSocket* next_client_tcp_socket_;
 };
 
 class FakeAsyncPacketSocket : public AsyncPacketSocket {
  public:
-  // Returns current local address. Address may be set to NULL if the
+  // Returns current local address. Address may be set to null if the
   // socket is not bound yet (GetState() returns STATE_BINDING).
   virtual SocketAddress GetLocalAddress() const {
     return SocketAddress();
   }
 
   // Returns remote address. Returns zeroes if this is not a client TCP socket.
   virtual SocketAddress GetRemoteAddress() const {
     return SocketAddress();
   }
 
@@ skipping 334 matching lines @@
   std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   lport->PrepareAddress();
   ASSERT_FALSE(lport->Candidates().empty());
   Connection* conn = lport->CreateConnection(lport->Candidates()[0],
                                              Port::ORIGIN_MESSAGE);
   conn->Ping(0);
 
-  ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(lport->last_stun_msg() != nullptr, kDefaultTimeout);
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   conn->OnReadPacket(lport->last_stun_buf()->data<char>(),
                      lport->last_stun_buf()->size(),
                      rtc::PacketTime());
-  ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(lport->last_stun_msg() != nullptr, kDefaultTimeout);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
 
   // If the tiebreaker value is different from port, we expect a error
   // response.
   lport->Reset();
   lport->AddCandidateAddress(kLocalAddr2);
   // Creating a different connection as |conn| is receiving.
   Connection* conn1 = lport->CreateConnection(lport->Candidates()[1],
                                               Port::ORIGIN_MESSAGE);
   conn1->Ping(0);
 
-  ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(lport->last_stun_msg() != nullptr, kDefaultTimeout);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   std::unique_ptr<IceMessage> modified_req(
       CreateStunMessage(STUN_BINDING_REQUEST));
   const StunByteStringAttribute* username_attr = msg->GetByteString(
       STUN_ATTR_USERNAME);
   modified_req->AddAttribute(new StunByteStringAttribute(
       STUN_ATTR_USERNAME, username_attr->GetString()));
   // To make sure we receive error response, adding tiebreaker less than
   // what's present in request.
   modified_req->AddAttribute(new StunUInt64Attribute(
       STUN_ATTR_ICE_CONTROLLING, kTiebreaker1 - 1));
   modified_req->AddMessageIntegrity("lpass");
   modified_req->AddFingerprint();
 
   lport->Reset();
   std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   WriteStunMessage(modified_req.get(), buf.get());
   conn1->OnReadPacket(buf->Data(), buf->Length(), rtc::PacketTime());
-  ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(lport->last_stun_msg() != nullptr, kDefaultTimeout);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
 }
 
 // This test verifies role conflict signal is received when there is
 // conflict in the role. In this case both ports are in controlling and
 // |rport| has higher tiebreaker value than |lport|. Since |lport| has lower
 // value of tiebreaker, when it receives ping request from |rport| it will
 // send role conflict signal.
 TEST_F(PortTest, TestIceRoleConflict) {
   std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   rport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(lport->Candidates().empty());
   ASSERT_FALSE(rport->Candidates().empty());
   Connection* lconn = lport->CreateConnection(rport->Candidates()[0],
                                               Port::ORIGIN_MESSAGE);
   Connection* rconn = rport->CreateConnection(lport->Candidates()[0],
                                               Port::ORIGIN_MESSAGE);
   rconn->Ping(0);
 
-  ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(rport->last_stun_msg() != nullptr, kDefaultTimeout);
   IceMessage* msg = rport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Send rport binding request to lport.
   lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
                       rport->last_stun_buf()->size(),
                       rtc::PacketTime());
 
-  ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(lport->last_stun_msg() != nullptr, kDefaultTimeout);
   EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
   EXPECT_TRUE(role_conflict());
 }
 
 TEST_F(PortTest, TestTcpNoDelay) {
   TCPPort* port1 = CreateTcpPort(kLocalAddr1);
   port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
   int option_value = -1;
   int success = port1->GetOption(rtc::Socket::OPT_NODELAY,
                                  &option_value);
@@ skipping 55 matching lines @@
     ports[i]->PrepareAddress();
   }
 
   // IPv4 Port, connects to IPv6 candidate and then to IPv4 candidate.
   if (type == SOCK_STREAM) {
     FakeAsyncPacketSocket* clientsocket = new FakeAsyncPacketSocket();
     factory.set_next_client_tcp_socket(clientsocket);
   }
   Connection* c = ports[0]->CreateConnection(GetCandidate(ports[2].get()),
                                              Port::ORIGIN_MESSAGE);
-  EXPECT_TRUE(NULL == c);
+  EXPECT_TRUE(nullptr == c);
   EXPECT_EQ(0U, ports[0]->connections().size());
   c = ports[0]->CreateConnection(GetCandidate(ports[1].get()),
                                  Port::ORIGIN_MESSAGE);
-  EXPECT_FALSE(NULL == c);
+  EXPECT_FALSE(nullptr == c);
   EXPECT_EQ(1U, ports[0]->connections().size());
 
   // IPv6 Port, connects to IPv4 candidate and to IPv6 candidate.
   if (type == SOCK_STREAM) {
     FakeAsyncPacketSocket* clientsocket = new FakeAsyncPacketSocket();
     factory.set_next_client_tcp_socket(clientsocket);
   }
   c = ports[2]->CreateConnection(GetCandidate(ports[0].get()),
                                  Port::ORIGIN_MESSAGE);
-  EXPECT_TRUE(NULL == c);
+  EXPECT_TRUE(nullptr == c);
   EXPECT_EQ(0U, ports[2]->connections().size());
   c = ports[2]->CreateConnection(GetCandidate(ports[3].get()),
                                  Port::ORIGIN_MESSAGE);
-  EXPECT_FALSE(NULL == c);
+  EXPECT_FALSE(nullptr == c);
   EXPECT_EQ(1U, ports[2]->connections().size());
 }
 
 TEST_F(PortTest, TestSkipCrossFamilyTcp) {
   TestCrossFamilyPorts(SOCK_STREAM);
 }
 
 TEST_F(PortTest, TestSkipCrossFamilyUdp) {
   TestCrossFamilyPorts(SOCK_DGRAM);
 }
 
 void PortTest::ExpectPortsCanConnect(bool can_connect, Port* p1, Port* p2) {
   Connection* c = p1->CreateConnection(GetCandidate(p2),
                                        Port::ORIGIN_MESSAGE);
   if (can_connect) {
-    EXPECT_FALSE(NULL == c);
+    EXPECT_FALSE(nullptr == c);
     EXPECT_EQ(1U, p1->connections().size());
   } else {
-    EXPECT_TRUE(NULL == c);
+    EXPECT_TRUE(nullptr == c);
     EXPECT_EQ(0U, p1->connections().size());
   }
 }
 
 TEST_F(PortTest, TestUdpV6CrossTypePorts) {
   FakePacketSocketFactory factory;
   std::unique_ptr<Port> ports[4];
   SocketAddress addresses[4] = {SocketAddress("2001:db8::1", 0),
                                 SocketAddress("fe80::1", 0),
                                 SocketAddress("fe80::2", 0),
@@ skipping 73 matching lines @@
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(rport->Candidates().empty());
   Connection* lconn = lport->CreateConnection(
       rport->Candidates()[0], Port::ORIGIN_MESSAGE);
   Connection* rconn = rport->CreateConnection(
       lport->Candidates()[0], Port::ORIGIN_MESSAGE);
   lconn->Ping(0);
 
   // Check that it's a proper BINDING-REQUEST.
-  ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(lport->last_stun_msg() != nullptr, kDefaultTimeout);
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   EXPECT_FALSE(msg->IsLegacy());
   const StunByteStringAttribute* username_attr =
       msg->GetByteString(STUN_ATTR_USERNAME);
-  ASSERT_TRUE(username_attr != NULL);
+  ASSERT_TRUE(username_attr != nullptr);
   const StunUInt32Attribute* priority_attr = msg->GetUInt32(STUN_ATTR_PRIORITY);
-  ASSERT_TRUE(priority_attr != NULL);
+  ASSERT_TRUE(priority_attr != nullptr);
   EXPECT_EQ(kDefaultPrflxPriority, priority_attr->value());
   EXPECT_EQ("rfrag:lfrag", username_attr->GetString());
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != nullptr);
   EXPECT_TRUE(StunMessage::ValidateMessageIntegrity(
       lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size(),
       "rpass"));
   const StunUInt64Attribute* ice_controlling_attr =
       msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING);
-  ASSERT_TRUE(ice_controlling_attr != NULL);
+  ASSERT_TRUE(ice_controlling_attr != nullptr);
   EXPECT_EQ(lport->IceTiebreaker(), ice_controlling_attr->value());
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_ICE_CONTROLLED) == NULL);
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != NULL);
-  EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_ICE_CONTROLLED) == nullptr);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != nullptr);
+  EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != nullptr);
   EXPECT_TRUE(StunMessage::ValidateFingerprint(
       lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size()));
 
   // Request should not include ping count.
-  ASSERT_TRUE(msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT) == NULL);
+  ASSERT_TRUE(msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT) == nullptr);
 
   // Save a copy of the BINDING-REQUEST for use below.
   std::unique_ptr<IceMessage> request(CopyStunMessage(msg));
 
   // Receive the BINDING-REQUEST and respond with BINDING-RESPONSE.
   rconn->OnReadPacket(lport->last_stun_buf()->data<char>(),
                       lport->last_stun_buf()->size(), rtc::PacketTime());
   msg = rport->last_stun_msg();
-  ASSERT_TRUE(msg != NULL);
+  ASSERT_TRUE(msg != nullptr);
   EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
   // Received a BINDING-RESPONSE.
   lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
                       rport->last_stun_buf()->size(), rtc::PacketTime());
   // Verify the STUN Stats.
   EXPECT_EQ(1U, lconn->stats().sent_ping_requests_total);
   EXPECT_EQ(1U, lconn->stats().sent_ping_requests_before_first_response);
   EXPECT_EQ(1U, lconn->stats().recv_ping_responses);
   EXPECT_EQ(1U, rconn->stats().recv_ping_requests);
   EXPECT_EQ(1U, rconn->stats().sent_ping_responses);
 
   EXPECT_FALSE(msg->IsLegacy());
   const StunAddressAttribute* addr_attr = msg->GetAddress(
       STUN_ATTR_XOR_MAPPED_ADDRESS);
-  ASSERT_TRUE(addr_attr != NULL);
+  ASSERT_TRUE(addr_attr != nullptr);
   EXPECT_EQ(lport->Candidates()[0].address(), addr_attr->GetAddress());
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != nullptr);
   EXPECT_TRUE(StunMessage::ValidateMessageIntegrity(
       rport->last_stun_buf()->data<char>(), rport->last_stun_buf()->size(),
       "rpass"));
-  EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
+  EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != nullptr);
   EXPECT_TRUE(StunMessage::ValidateFingerprint(
       lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size()));
   // No USERNAME or PRIORITY in ICE responses.
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USERNAME) == NULL);
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == NULL);
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MAPPED_ADDRESS) == NULL);
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_ICE_CONTROLLING) == NULL);
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_ICE_CONTROLLED) == NULL);
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == NULL);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USERNAME) == nullptr);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == nullptr);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MAPPED_ADDRESS) == nullptr);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_ICE_CONTROLLING) == nullptr);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_ICE_CONTROLLED) == nullptr);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == nullptr);
 
   // Response should not include ping count.
-  ASSERT_TRUE(msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT) == NULL);
+  ASSERT_TRUE(msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT) == nullptr);
 
   // Respond with a BINDING-ERROR-RESPONSE. This wouldn't happen in real life,
   // but we can do it here.
   rport->SendBindingErrorResponse(request.get(),
                                   lport->Candidates()[0].address(),
                                   STUN_ERROR_SERVER_ERROR,
                                   STUN_ERROR_REASON_SERVER_ERROR);
   msg = rport->last_stun_msg();
-  ASSERT_TRUE(msg != NULL);
+  ASSERT_TRUE(msg != nullptr);
   EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
   EXPECT_FALSE(msg->IsLegacy());
   const StunErrorCodeAttribute* error_attr = msg->GetErrorCode();
-  ASSERT_TRUE(error_attr != NULL);
+  ASSERT_TRUE(error_attr != nullptr);
   EXPECT_EQ(STUN_ERROR_SERVER_ERROR, error_attr->code());
   EXPECT_EQ(std::string(STUN_ERROR_REASON_SERVER_ERROR), error_attr->reason());
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != nullptr);
   EXPECT_TRUE(StunMessage::ValidateMessageIntegrity(
       rport->last_stun_buf()->data<char>(), rport->last_stun_buf()->size(),
       "rpass"));
-  EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
+  EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != nullptr);
   EXPECT_TRUE(StunMessage::ValidateFingerprint(
       lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size()));
   // No USERNAME with ICE.
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USERNAME) == NULL);
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == NULL);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USERNAME) == nullptr);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == nullptr);
 
   // Testing STUN binding requests from rport --> lport, having ICE_CONTROLLED
   // and (incremented) RETRANSMIT_COUNT attributes.
   rport->Reset();
   rport->set_send_retransmit_count_attribute(true);
   rconn->Ping(0);
   rconn->Ping(0);
   rconn->Ping(0);
-  ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(rport->last_stun_msg() != nullptr, kDefaultTimeout);
   msg = rport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   const StunUInt64Attribute* ice_controlled_attr =
       msg->GetUInt64(STUN_ATTR_ICE_CONTROLLED);
-  ASSERT_TRUE(ice_controlled_attr != NULL);
+  ASSERT_TRUE(ice_controlled_attr != nullptr);
   EXPECT_EQ(rport->IceTiebreaker(), ice_controlled_attr->value());
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == NULL);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == nullptr);
 
   // Request should include ping count.
   const StunUInt32Attribute* retransmit_attr =
       msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT);
-  ASSERT_TRUE(retransmit_attr != NULL);
+  ASSERT_TRUE(retransmit_attr != nullptr);
   EXPECT_EQ(2U, retransmit_attr->value());
 
   // Respond with a BINDING-RESPONSE.
   request.reset(CopyStunMessage(msg));
   lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
                       rport->last_stun_buf()->size(), rtc::PacketTime());
   msg = lport->last_stun_msg();
   // Receive the BINDING-RESPONSE.
   rconn->OnReadPacket(lport->last_stun_buf()->data<char>(),
                       lport->last_stun_buf()->size(), rtc::PacketTime());
 
   // Verify the Stun ping stats.
   EXPECT_EQ(3U, rconn->stats().sent_ping_requests_total);
   EXPECT_EQ(3U, rconn->stats().sent_ping_requests_before_first_response);
   EXPECT_EQ(1U, rconn->stats().recv_ping_responses);
   EXPECT_EQ(1U, lconn->stats().sent_ping_responses);
   EXPECT_EQ(1U, lconn->stats().recv_ping_requests);
   // Ping after receiver the first response
   rconn->Ping(0);
   rconn->Ping(0);
   EXPECT_EQ(5U, rconn->stats().sent_ping_requests_total);
   EXPECT_EQ(3U, rconn->stats().sent_ping_requests_before_first_response);
 
   // Response should include same ping count.
   retransmit_attr = msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT);
-  ASSERT_TRUE(retransmit_attr != NULL);
+  ASSERT_TRUE(retransmit_attr != nullptr);
   EXPECT_EQ(2U, retransmit_attr->value());
 }
 
 TEST_F(PortTest, TestUseCandidateAttribute) {
   std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   // Send a fake ping from lport to rport.
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(rport->Candidates().empty());
   Connection* lconn = lport->CreateConnection(
       rport->Candidates()[0], Port::ORIGIN_MESSAGE);
   lconn->Ping(0);
-  ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(lport->last_stun_msg() != nullptr, kDefaultTimeout);
   IceMessage* msg = lport->last_stun_msg();
   const StunUInt64Attribute* ice_controlling_attr =
       msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING);
-  ASSERT_TRUE(ice_controlling_attr != NULL);
+  ASSERT_TRUE(ice_controlling_attr != nullptr);
   const StunByteStringAttribute* use_candidate_attr = msg->GetByteString(
       STUN_ATTR_USE_CANDIDATE);
-  ASSERT_TRUE(use_candidate_attr != NULL);
+  ASSERT_TRUE(use_candidate_attr != nullptr);
 }
 
 // Tests that when the network type changes, the network cost of the port will
 // change, the network cost of the local candidates will change. Also tests that
 // the remote network costs are updated with the stun binding requests.
 TEST_F(PortTest, TestNetworkCostChange) {
   std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
@@ skipping 31 matching lines @@
   SetNetworkType(rtc::ADAPTER_TYPE_WIFI);
   Connection* rconn =
       rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
   SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
   lconn->Ping(0);
   // The rconn's remote candidate cost is rtc::kNetworkCostLow, but the ping
   // contains an attribute of network cost of rtc::kNetworkCostHigh. Once the
   // message is handled in rconn, The rconn's remote candidate will have cost
   // rtc::kNetworkCostHigh;
   EXPECT_EQ(rtc::kNetworkCostLow, rconn->remote_candidate().network_cost());
-  ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(lport->last_stun_msg() != nullptr, kDefaultTimeout);
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Pass the binding request to rport.
   rconn->OnReadPacket(lport->last_stun_buf()->data<char>(),
                       lport->last_stun_buf()->size(), rtc::PacketTime());
   // Wait until rport sends the response and then check the remote network cost.
-  ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(rport->last_stun_msg() != nullptr, kDefaultTimeout);
   EXPECT_EQ(rtc::kNetworkCostHigh, rconn->remote_candidate().network_cost());
 }
 
 TEST_F(PortTest, TestNetworkInfoAttribute) {
   std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   uint16_t lnetwork_id = 9;
   lport->Network()->set_id(lnetwork_id);
   // Send a fake ping from lport to rport.
   lport->PrepareAddress();
   rport->PrepareAddress();
   Connection* lconn =
       lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
   lconn->Ping(0);
-  ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(lport->last_stun_msg() != nullptr, kDefaultTimeout);
   IceMessage* msg = lport->last_stun_msg();
   const StunUInt32Attribute* network_info_attr =
       msg->GetUInt32(STUN_ATTR_NETWORK_INFO);
-  ASSERT_TRUE(network_info_attr != NULL);
+  ASSERT_TRUE(network_info_attr != nullptr);
   uint32_t network_info = network_info_attr->value();
   EXPECT_EQ(lnetwork_id, network_info >> 16);
   // Default network has unknown type and cost kNetworkCostUnknown.
   EXPECT_EQ(rtc::kNetworkCostUnknown, network_info & 0xFFFF);
 
   // Set the network type to be cellular so its cost will be kNetworkCostHigh.
   // Send a fake ping from rport to lport.
   SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
   uint16_t rnetwork_id = 8;
   rport->Network()->set_id(rnetwork_id);
   Connection* rconn =
       rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
   rconn->Ping(0);
-  ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(rport->last_stun_msg() != nullptr, kDefaultTimeout);
   msg = rport->last_stun_msg();
   network_info_attr = msg->GetUInt32(STUN_ATTR_NETWORK_INFO);
-  ASSERT_TRUE(network_info_attr != NULL);
+  ASSERT_TRUE(network_info_attr != nullptr);
   network_info = network_info_attr->value();
   EXPECT_EQ(rnetwork_id, network_info >> 16);
   EXPECT_EQ(rtc::kNetworkCostHigh, network_info & 0xFFFF);
 }
 
 // Test handling STUN messages.
 TEST_F(PortTest, TestHandleStunMessage) {
   // Our port will act as the "remote" port.
   std::unique_ptr<TestPort> port(CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
 
   std::unique_ptr<IceMessage> in_msg, out_msg;
   std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid ICE username,
   // MESSAGE-INTEGRITY, and FINGERPRINT.
   in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST,
                                              "rfrag:lfrag"));
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
-  EXPECT_TRUE(out_msg.get() != NULL);
+  EXPECT_TRUE(out_msg.get() != nullptr);
   EXPECT_EQ("lfrag", username);
 
   // BINDING-RESPONSE without username, with MESSAGE-INTEGRITY and FINGERPRINT.
   in_msg.reset(CreateStunMessage(STUN_BINDING_RESPONSE));
   in_msg->AddAttribute(
       new StunXorAddressAttribute(STUN_ATTR_XOR_MAPPED_ADDRESS, kLocalAddr2));
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
-  EXPECT_TRUE(out_msg.get() != NULL);
+  EXPECT_TRUE(out_msg.get() != nullptr);
   EXPECT_EQ("", username);
 
   // BINDING-ERROR-RESPONSE without username, with error, M-I, and FINGERPRINT.
   in_msg.reset(CreateStunMessage(STUN_BINDING_ERROR_RESPONSE));
   in_msg->AddAttribute(new StunErrorCodeAttribute(STUN_ATTR_ERROR_CODE,
       STUN_ERROR_SERVER_ERROR, STUN_ERROR_REASON_SERVER_ERROR));
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
-  EXPECT_TRUE(out_msg.get() != NULL);
+  EXPECT_TRUE(out_msg.get() != nullptr);
   EXPECT_EQ("", username);
-  ASSERT_TRUE(out_msg->GetErrorCode() != NULL);
+  ASSERT_TRUE(out_msg->GetErrorCode() != nullptr);
   EXPECT_EQ(STUN_ERROR_SERVER_ERROR, out_msg->GetErrorCode()->code());
   EXPECT_EQ(std::string(STUN_ERROR_REASON_SERVER_ERROR),
       out_msg->GetErrorCode()->reason());
 }
 
 // Tests handling of ICE binding requests with missing or incorrect usernames.
 TEST_F(PortTest, TestHandleStunMessageBadUsername) {
   std::unique_ptr<TestPort> port(CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
 
   std::unique_ptr<IceMessage> in_msg, out_msg;
   std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST with no username.
   in_msg.reset(CreateStunMessage(STUN_BINDING_REQUEST));
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
-  EXPECT_TRUE(out_msg.get() == NULL);
+  EXPECT_TRUE(out_msg.get() == nullptr);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_BAD_REQUEST, port->last_stun_error_code());
 
   // BINDING-REQUEST with empty username.
   in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, ""));
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
-  EXPECT_TRUE(out_msg.get() == NULL);
+  EXPECT_TRUE(out_msg.get() == nullptr);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
 
   // BINDING-REQUEST with too-short username.
   in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST, "rfra"));
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
-  EXPECT_TRUE(out_msg.get() == NULL);
+  EXPECT_TRUE(out_msg.get() == nullptr);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
 
   // BINDING-REQUEST with reversed username.
   in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST,
                                             "lfrag:rfrag"));
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
-  EXPECT_TRUE(out_msg.get() == NULL);
+  EXPECT_TRUE(out_msg.get() == nullptr);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
 
   // BINDING-REQUEST with garbage username.
   in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST,
                                              "abcd:efgh"));
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
-  EXPECT_TRUE(out_msg.get() == NULL);
+  EXPECT_TRUE(out_msg.get() == nullptr);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
 }
 
 // Test handling STUN messages with missing or malformed M-I.
 TEST_F(PortTest, TestHandleStunMessageBadMessageIntegrity) {
   // Our port will act as the "remote" port.
   std::unique_ptr<TestPort> port(CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
 
   std::unique_ptr<IceMessage> in_msg, out_msg;
   std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid ICE username and
   // FINGERPRINT, but no MESSAGE-INTEGRITY.
   in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST,
                                              "rfrag:lfrag"));
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
-  EXPECT_TRUE(out_msg.get() == NULL);
+  EXPECT_TRUE(out_msg.get() == nullptr);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_BAD_REQUEST, port->last_stun_error_code());
 
   // BINDING-REQUEST from local to remote with valid ICE username and
   // FINGERPRINT, but invalid MESSAGE-INTEGRITY.
   in_msg.reset(CreateStunMessageWithUsername(STUN_BINDING_REQUEST,
                                              "rfrag:lfrag"));
   in_msg->AddMessageIntegrity("invalid");
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                    &username));
-  EXPECT_TRUE(out_msg.get() == NULL);
+  EXPECT_TRUE(out_msg.get() == nullptr);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
 
   // TODO: BINDING-RESPONSES and BINDING-ERROR-RESPONSES are checked
   // by the Connection, not the Port, since they require the remote username.
   // Change this test to pass in data via Connection::OnReadPacket instead.
 }
 
 // Test handling STUN messages with missing or malformed FINGERPRINT.
 TEST_F(PortTest, TestHandleStunMessageBadFingerprint) {
@@ skipping 72 matching lines @@
   std::unique_ptr<IceMessage> in_msg, out_msg;
   std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   in_msg.reset(CreateStunMessage(STUN_BINDING_INDICATION));
   in_msg->AddFingerprint();
   WriteStunMessage(in_msg.get(), buf.get());
   EXPECT_TRUE(lport->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
                                     &username));
-  EXPECT_TRUE(out_msg.get() != NULL);
+  EXPECT_TRUE(out_msg.get() != nullptr);
   EXPECT_EQ(out_msg->type(), STUN_BINDING_INDICATION);
   EXPECT_EQ("", username);
 
   // Verify connection can handle STUN indication and updates
   // last_ping_received.
   std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(lport->Candidates().empty());
   ASSERT_FALSE(rport->Candidates().empty());
 
   Connection* lconn = lport->CreateConnection(rport->Candidates()[0],
                                               Port::ORIGIN_MESSAGE);
   Connection* rconn = rport->CreateConnection(lport->Candidates()[0],
                                               Port::ORIGIN_MESSAGE);
   rconn->Ping(0);
 
-  ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(rport->last_stun_msg() != nullptr, kDefaultTimeout);
   IceMessage* msg = rport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Send rport binding request to lport.
   lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
                       rport->last_stun_buf()->size(),
                       rtc::PacketTime());
-  ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(lport->last_stun_msg() != nullptr, kDefaultTimeout);
   EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
   int64_t last_ping_received1 = lconn->last_ping_received();
 
   // Adding a delay of 100ms.
   rtc::Thread::Current()->ProcessMessages(100);
   // Pinging lconn using stun indication message.
   lconn->OnReadPacket(buf->Data(), buf->Length(), rtc::PacketTime());
   int64_t last_ping_received2 = lconn->last_ping_received();
   EXPECT_GT(last_ping_received2, last_ping_received1);
 }
@@ skipping 234 matching lines @@
   TestChannel ch2(port2);
 
   // Acquire addresses.
   ch1.Start();
   ch2.Start();
   ASSERT_EQ_SIMULATED_WAIT(1, ch1.complete_count(), kDefaultTimeout, clock);
   ASSERT_EQ_SIMULATED_WAIT(1, ch2.complete_count(), kDefaultTimeout, clock);
 
   // Send a ping from src to dst.
   ch1.CreateConnection(GetCandidate(port2));
-  ASSERT_TRUE(ch1.conn() != NULL);
+  ASSERT_TRUE(ch1.conn() != nullptr);
   EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state());
   // for TCP connect
   EXPECT_TRUE_SIMULATED_WAIT(ch1.conn()->connected(), kDefaultTimeout, clock);
   ch1.Ping();
   SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
 
   // Data should be sendable before the connection is accepted.
   char data[] = "abcd";
   int data_size = arraysize(data);
   rtc::PacketOptions options;
@@ skipping 49 matching lines @@
 
   // Set up channels.
   TestChannel ch1(port1);
   TestChannel ch2(port2);
 
   // Acquire addresses.
   ch1.Start();
   ch2.Start();
 
   ch1.CreateConnection(GetCandidate(port2));
-  ASSERT_TRUE(ch1.conn() != NULL);
+  ASSERT_TRUE(ch1.conn() != nullptr);
   EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state());
 
   // Attempt to go directly to write timeout.
   for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
     ch1.Ping(i);
   }
   ch1.conn()->UpdateState(CONNECTION_WRITE_TIMEOUT + 500u);
   EXPECT_EQ(Connection::STATE_WRITE_TIMEOUT, ch1.conn()->write_state());
 }
 
@@ skipping 14 matching lines @@
   ch1.SetIceMode(ICEMODE_FULL);
 
   // Start gathering candidates.
   ch1.Start();
   ice_lite_port->PrepareAddress();
 
   ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
   ASSERT_FALSE(ice_lite_port->Candidates().empty());
 
   ch1.CreateConnection(GetCandidate(ice_lite_port.get()));
-  ASSERT_TRUE(ch1.conn() != NULL);
+  ASSERT_TRUE(ch1.conn() != nullptr);
   EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state());
 
   // Send ping from full mode client.
   // This ping must not have USE_CANDIDATE_ATTR.
   ch1.Ping();
 
   // Verify stun ping is without USE_CANDIDATE_ATTR. Getting message directly
   // from port.
-  ASSERT_TRUE_WAIT(ice_full_port->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(ice_full_port->last_stun_msg() != nullptr, kDefaultTimeout);
   IceMessage* msg = ice_full_port->last_stun_msg();
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == NULL);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == nullptr);
 
   // Respond with a BINDING-RESPONSE from litemode client.
   // NOTE: Ideally we should't create connection at this stage from lite
   // port, as it should be done only after receiving ping with USE_CANDIDATE.
   // But we need a connection to send a response message.
   ice_lite_port->CreateConnection(
       ice_full_port->Candidates()[0], cricket::Port::ORIGIN_MESSAGE);
   std::unique_ptr<IceMessage> request(CopyStunMessage(msg));
   ice_lite_port->SendBindingResponse(
       request.get(), ice_full_port->Candidates()[0].address());
 
   // Feeding the respone message from litemode to the full mode connection.
   ch1.conn()->OnReadPacket(ice_lite_port->last_stun_buf()->data<char>(),
                            ice_lite_port->last_stun_buf()->size(),
                            rtc::PacketTime());
   // Verifying full mode connection becomes writable from the response.
   EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
                  kDefaultTimeout);
   EXPECT_TRUE_WAIT(ch1.nominated(), kDefaultTimeout);
 
   // Clear existing stun messsages. Otherwise we will process old stun
   // message right after we send ping.
   ice_full_port->Reset();
   // Send ping. This must have USE_CANDIDATE_ATTR.
   ch1.Ping();
-  ASSERT_TRUE_WAIT(ice_full_port->last_stun_msg() != NULL, kDefaultTimeout);
+  ASSERT_TRUE_WAIT(ice_full_port->last_stun_msg() != nullptr, kDefaultTimeout);
   msg = ice_full_port->last_stun_msg();
-  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != NULL);
+  EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != nullptr);
   ch1.Stop();
 }
 
 // This test case verifies that both the controlling port and the controlled
 // port will time out after connectivity is lost, if they are not marked as
 // "keep alive until pruned."
 TEST_F(PortTest, TestPortTimeoutIfNotKeptAlive) {
   rtc::ScopedFakeClock clock;
   int timeout_delay = 100;
   UDPPort* port1 = CreateUdpPort(kLocalAddr1);
@@ skipping 159 matching lines @@
       port->CreateConnection(candidate, Port::ORIGIN_MESSAGE);
   EXPECT_NE(conn1, conn2);
   conn_in_use = port->GetConnection(address);
   EXPECT_EQ(conn2, conn_in_use);
   EXPECT_EQ(2u, conn_in_use->remote_candidate().generation());
 
   // Make sure the new connection was not deleted.
   rtc::Thread::Current()->ProcessMessages(300);
   EXPECT_TRUE(port->GetConnection(address) != nullptr);
 }