webrtc/p2p/base/port_unittest.cc - Issue 2685783014: Replace NULL with nullptr in all C++ files.

Unified Diff: webrtc/p2p/base/port_unittest.cc

Issue 2685783014: Replace NULL with nullptr in all C++ files. (Closed)

Patch Set: Fixing android. Created 3 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: webrtc/p2p/base/port_unittest.cc

diff --git a/webrtc/p2p/base/port_unittest.cc b/webrtc/p2p/base/port_unittest.cc

index 38012a683ae50de52e41eb2a320a3af1d2196516..fbb184d2d2b77b7f92e6a892a0d8728063980e06 100644

--- a/webrtc/p2p/base/port_unittest.cc

+++ b/webrtc/p2p/base/port_unittest.cc

@@ -229,7 +229,7 @@ class TestChannel : public sigslot::has_slots<> {

: ice_mode_(ICEMODE_FULL),

port_(p1),

complete_count_(0),

- conn_(NULL),

+ conn_(nullptr),

remote_request_(),

nominated_(false) {

port_->SignalPortComplete.connect(this, &TestChannel::OnPortComplete);

@@ -263,7 +263,7 @@ class TestChannel : public sigslot::has_slots<> {

}

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);

@@ -307,9 +307,9 @@ class TestChannel : public sigslot::has_slots<> {

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;

@@ -318,7 +318,7 @@ class TestChannel : public sigslot::has_slots<> {

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();

@@ -654,7 +654,7 @@ class PortTest : public testing::Test, public sigslot::has_slots<> {

// 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,

@@ -729,8 +729,8 @@ class PortTest : public testing::Test, public sigslot::has_slots<> {

// 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) {

@@ -828,7 +828,7 @@ void PortTest::TestConnectivity(const char* name1, Port* port1,

// 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();

@@ -847,7 +847,7 @@ void PortTest::TestConnectivity(const char* name1, Port* port1,

// 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);

@@ -859,7 +859,7 @@ void PortTest::TestConnectivity(const char* name1, Port* port1,

// 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);

@@ -893,7 +893,7 @@ void PortTest::TestConnectivity(const char* name1, Port* port1,

// 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,

@@ -922,8 +922,8 @@ void PortTest::TestConnectivity(const char* name1, Port* port1,

}

// 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());

@@ -939,25 +939,24 @@ void PortTest::TestConnectivity(const char* name1, Port* port1,

// 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;

}

@@ -965,9 +964,9 @@ class FakePacketSocketFactory : public rtc::PacketSocketFactory {

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;

}

@@ -978,9 +977,9 @@ class FakePacketSocketFactory : public rtc::PacketSocketFactory {

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;

}

@@ -994,7 +993,7 @@ class FakePacketSocketFactory : public rtc::PacketSocketFactory {

next_client_tcp_socket_ = next_client_tcp_socket;

}

rtc::AsyncResolverInterface* CreateAsyncResolver() override {

- return NULL;

+ return nullptr;

}

private:

@@ -1005,7 +1004,7 @@ class FakePacketSocketFactory : public rtc::PacketSocketFactory {

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();

@@ -1360,13 +1359,13 @@ TEST_F(PortTest, TestLoopbackCall) {

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());

@@ -1379,7 +1378,7 @@ TEST_F(PortTest, TestLoopbackCall) {

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(

@@ -1399,7 +1398,7 @@ TEST_F(PortTest, TestLoopbackCall) {

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());

}

@@ -1429,7 +1428,7 @@ TEST_F(PortTest, TestIceRoleConflict) {

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.

@@ -1437,7 +1436,7 @@ TEST_F(PortTest, TestIceRoleConflict) {

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());

}

@@ -1513,11 +1512,11 @@ void PortTest::TestCrossFamilyPorts(int type) {

}

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.

@@ -1527,11 +1526,11 @@ void PortTest::TestCrossFamilyPorts(int type) {

}

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());

}

@@ -1547,10 +1546,10 @@ 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());

}

@@ -1644,33 +1643,33 @@ TEST_F(PortTest, TestSendStunMessage) {

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));

@@ -1679,7 +1678,7 @@ TEST_F(PortTest, TestSendStunMessage) {

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>(),

@@ -1694,25 +1693,25 @@ TEST_F(PortTest, TestSendStunMessage) {

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.

@@ -1721,23 +1720,23 @@ TEST_F(PortTest, TestSendStunMessage) {

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.

@@ -1746,19 +1745,19 @@ TEST_F(PortTest, TestSendStunMessage) {

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.

@@ -1784,7 +1783,7 @@ TEST_F(PortTest, TestSendStunMessage) {

// 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());

}

@@ -1805,14 +1804,14 @@ TEST_F(PortTest, TestUseCandidateAttribute) {

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

@@ -1864,14 +1863,14 @@ TEST_F(PortTest, TestNetworkCostChange) {

// 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());

}

@@ -1893,11 +1892,11 @@ TEST_F(PortTest, TestNetworkInfoAttribute) {

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.

@@ -1911,10 +1910,10 @@ TEST_F(PortTest, TestNetworkInfoAttribute) {

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);

@@ -1939,7 +1938,7 @@ TEST_F(PortTest, TestHandleStunMessage) {

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.

@@ -1951,7 +1950,7 @@ TEST_F(PortTest, TestHandleStunMessage) {

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.

@@ -1962,9 +1961,9 @@ TEST_F(PortTest, TestHandleStunMessage) {

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());

@@ -1986,7 +1985,7 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {

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());

@@ -1997,7 +1996,7 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {

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());

@@ -2008,7 +2007,7 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {

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());

@@ -2020,7 +2019,7 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {

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());

@@ -2032,7 +2031,7 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {

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());

}

@@ -2055,7 +2054,7 @@ TEST_F(PortTest, TestHandleStunMessageBadMessageIntegrity) {

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());

@@ -2068,7 +2067,7 @@ TEST_F(PortTest, TestHandleStunMessageBadMessageIntegrity) {

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());

@@ -2161,7 +2160,7 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {

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);

@@ -2183,14 +2182,14 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {

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();

@@ -2445,7 +2444,7 @@ TEST_F(PortTest, TestWritableState) {

// 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);

@@ -2515,7 +2514,7 @@ TEST_F(PortTest, TestTimeoutForNeverWritable) {

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.

@@ -2550,7 +2549,7 @@ TEST_F(PortTest, TestIceLiteConnectivity) {

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.

@@ -2559,9 +2558,9 @@ TEST_F(PortTest, TestIceLiteConnectivity) {

// 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

@@ -2587,9 +2586,9 @@ TEST_F(PortTest, TestIceLiteConnectivity) {

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();

}

« webrtc/base/event.cc ('K') | « webrtc/p2p/base/port.cc ('k') | webrtc/p2p/base/pseudotcp.cc » ('j') | no next file with comments »