Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/p2ptransportchannel_unittest.cc

 /*
  *  Copyright 2009 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 274 matching lines @@
     Endpoint()
         : role_(ICEROLE_UNKNOWN),
           tiebreaker_(0),
           role_conflict_(false),
           save_candidates_(false) {}
     bool HasTransport(const rtc::PacketTransportInternal* transport) {
       return (transport == cd1_.ch_.get() || transport == cd2_.ch_.get());
     }
     ChannelData* GetChannelData(rtc::PacketTransportInternal* transport) {
       if (!HasTransport(transport))
-        return NULL;
+        return nullptr;
       if (cd1_.ch_.get() == transport)
         return &cd1_;
       else
         return &cd2_;
     }
 
     void SetIceRole(IceRole role) { role_ = role; }
     IceRole ice_role() { return role_; }
     void SetIceTiebreaker(uint64_t tiebreaker) { tiebreaker_ = tiebreaker; }
     uint64_t GetIceTiebreaker() { return tiebreaker_; }
@@ skipping 117 matching lines @@
 
   rtc::NATSocketServer* nat() { return nss_.get(); }
   rtc::FirewallSocketServer* fw() { return ss_.get(); }
 
   Endpoint* GetEndpoint(int endpoint) {
     if (endpoint == 0) {
       return &ep1_;
     } else if (endpoint == 1) {
       return &ep2_;
     } else {
-      return NULL;
+      return nullptr;
     }
   }
   BasicPortAllocator* GetAllocator(int endpoint) {
     return GetEndpoint(endpoint)->allocator_.get();
   }
   webrtc::FakeMetricsObserver* GetMetricsObserver(int endpoint) {
     return GetEndpoint(endpoint)->metrics_observer_;
   }
   void AddAddress(int endpoint, const SocketAddress& addr) {
     GetEndpoint(endpoint)->network_manager_.AddInterface(addr);
@@ skipping 102 matching lines @@
   }
 
   void Test(const Result& expected) {
     rtc::ScopedFakeClock clock;
     int64_t connect_start = rtc::TimeMillis();
     int64_t connect_time;
 
     // Create the channels and wait for them to connect.
     CreateChannels();
     EXPECT_TRUE_SIMULATED_WAIT(
-        ep1_ch1() != NULL && ep2_ch1() != NULL && ep1_ch1()->receiving() &&
-            ep1_ch1()->writable() && ep2_ch1()->receiving() &&
-            ep2_ch1()->writable(),
+        ep1_ch1() != nullptr && ep2_ch1() != nullptr &&
+            ep1_ch1()->receiving() && ep1_ch1()->writable() &&
+            ep2_ch1()->receiving() && ep2_ch1()->writable(),
         expected.connect_wait + kShortTimeout, clock);
     connect_time = rtc::TimeMillis() - connect_start;
     if (connect_time < expected.connect_wait) {
       LOG(LS_INFO) << "Connect time: " << connect_time << " ms";
     } else {
       LOG(LS_INFO) << "Connect time: " << "TIMEOUT ("
                    << expected.connect_wait << " ms)";
     }
 
     // Allow a few turns of the crank for the selected connections to emerge.
@@ skipping 243 matching lines @@
     return channel->SendPacket(data, len, options, 0);
   }
   bool CheckDataOnChannel(IceTransportInternal* channel,
                           const char* data,
                           int len) {
     return GetChannelData(channel)->CheckData(data, len);
   }
   static const Candidate* LocalCandidate(P2PTransportChannel* ch) {
     return (ch && ch->selected_connection())
                ? &ch->selected_connection()->local_candidate()
-               : NULL;
+               : nullptr;
   }
   static const Candidate* RemoteCandidate(P2PTransportChannel* ch) {
     return (ch && ch->selected_connection())
                ? &ch->selected_connection()->remote_candidate()
-               : NULL;
+               : nullptr;
   }
   Endpoint* GetEndpoint(rtc::PacketTransportInternal* transport) {
     if (ep1_.HasTransport(transport)) {
       return &ep1_;
     } else if (ep2_.HasTransport(transport)) {
       return &ep2_;
     } else {
-      return NULL;
+      return nullptr;
     }
   }
   P2PTransportChannel* GetRemoteChannel(IceTransportInternal* ch) {
     if (ch == ep1_ch1())
       return ep2_ch1();
     else if (ch == ep1_ch2())
       return ep2_ch2();
     else if (ch == ep2_ch1())
       return ep1_ch1();
     else if (ch == ep2_ch2())
       return ep1_ch2();
     else
-      return NULL;
+      return nullptr;
   }
   std::list<std::string>& GetPacketList(
       rtc::PacketTransportInternal* transport) {
     return GetChannelData(transport)->ch_packets_;
   }
 
   enum RemoteIceParameterSource { FROM_CANDIDATE, FROM_SETICEPARAMETERS };
 
   // How does the test pass ICE parameters to the P2PTransportChannel?
   // On the candidate itself, or through SetRemoteIceParameters?
@@ skipping 216 matching lines @@
 #define SUSU &kStunUdpToStunUdp
 #define SUPU &kStunUdpToPrflxUdp
 #define PUSU &kPrflxUdpToStunUdp
 #define LURU &kLocalUdpToRelayUdp
 #define PURU &kPrflxUdpToRelayUdp
 #define RUPU &kRelayUdpToPrflxUdp
 #define LTLT &kLocalTcpToLocalTcp
 #define LTPT &kLocalTcpToPrflxTcp
 #define PTLT &kPrflxTcpToLocalTcp
 // TODO: Enable these once TestRelayServer can accept external TCP.
-#define LTRT NULL
-#define LSRS NULL
+#define LTRT nullptr
+#define LSRS nullptr
 
 // Test matrix. Originator behavior defined by rows, receiever by columns.
 
-// TODO: Fix NULLs caused by lack of TCP support in NATSocket.
-// TODO: Fix NULLs caused by no HTTP proxy support.
+// TODO: Fix nulls caused by lack of TCP support in NATSocket.
+// TODO: Fix nulls caused by no HTTP proxy support.
 // TODO: Rearrange rows/columns from best to worst.
 const P2PTransportChannelTest::Result*
     P2PTransportChannelTest::kMatrix[NUM_CONFIGS][NUM_CONFIGS] = {
-//      OPEN  CONE  ADDR  PORT  SYMM  2CON  SCON  !UDP  !TCP  HTTP  PRXH  PRXS
-/*OP*/ {LULU, LUSU, LUSU, LUSU, LUPU, LUSU, LUPU, LTPT, LTPT, LSRS, NULL, LTPT},
-/*CO*/ {SULU, SUSU, SUSU, SUSU, SUPU, SUSU, SUPU, NULL, NULL, LSRS, NULL, LTRT},
-/*AD*/ {SULU, SUSU, SUSU, SUSU, SUPU, SUSU, SUPU, NULL, NULL, LSRS, NULL, LTRT},
-/*PO*/ {SULU, SUSU, SUSU, SUSU, RUPU, SUSU, RUPU, NULL, NULL, LSRS, NULL, LTRT},
-/*SY*/ {PULU, PUSU, PUSU, PURU, PURU, PUSU, PURU, NULL, NULL, LSRS, NULL, LTRT},
-/*2C*/ {SULU, SUSU, SUSU, SUSU, SUPU, SUSU, SUPU, NULL, NULL, LSRS, NULL, LTRT},
-/*SC*/ {PULU, PUSU, PUSU, PURU, PURU, PUSU, PURU, NULL, NULL, LSRS, NULL, LTRT},
-/*!U*/ {LTPT, NULL, NULL, NULL, NULL, NULL, NULL, LTPT, LTPT, LSRS, NULL, LTRT},
-/*!T*/ {PTLT, NULL, NULL, NULL, NULL, NULL, NULL, PTLT, LTRT, LSRS, NULL, LTRT},
-/*HT*/ {LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, NULL, LSRS},
-/*PR*/ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
-/*PR*/ {LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LSRS, NULL, LTRT},
+        //      OPEN  CONE  ADDR  PORT  SYMM  2CON  SCON  !UDP  !TCP  HTTP  PRXH
+        //      PRXS
+        /*OP*/ {LULU, LUSU, LUSU, LUSU, LUPU, LUSU, LUPU, LTPT, LTPT, LSRS,
+                nullptr, LTPT},
+        /*CO*/ {SULU, SUSU, SUSU, SUSU, SUPU, SUSU, SUPU, nullptr, nullptr,
+                LSRS, nullptr, LTRT},
+        /*AD*/ {SULU, SUSU, SUSU, SUSU, SUPU, SUSU, SUPU, nullptr, nullptr,
+                LSRS, nullptr, LTRT},
+        /*PO*/ {SULU, SUSU, SUSU, SUSU, RUPU, SUSU, RUPU, nullptr, nullptr,
+                LSRS, nullptr, LTRT},
+        /*SY*/ {PULU, PUSU, PUSU, PURU, PURU, PUSU, PURU, nullptr, nullptr,
+                LSRS, nullptr, LTRT},
+        /*2C*/ {SULU, SUSU, SUSU, SUSU, SUPU, SUSU, SUPU, nullptr, nullptr,
+                LSRS, nullptr, LTRT},
+        /*SC*/ {PULU, PUSU, PUSU, PURU, PURU, PUSU, PURU, nullptr, nullptr,
+                LSRS, nullptr, LTRT},
+        /*!U*/ {LTPT, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+                LTPT, LTPT, LSRS, nullptr, LTRT},
+        /*!T*/ {PTLT, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+                PTLT, LTRT, LSRS, nullptr, LTRT},
+        /*HT*/ {LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS,
+                nullptr, LSRS},
+        /*PR*/ {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, nullptr, nullptr, nullptr},
+        /*PR*/ {LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LSRS,
+                nullptr, LTRT},
 };
 
 // The actual tests that exercise all the various configurations.
 // Test names are of the form P2PTransportChannelTest_TestOPENToNAT_FULL_CONE
 #define P2P_TEST_DECLARATION(x, y, z)                            \
   TEST_F(P2PTransportChannelTest, z##Test##x##To##y) {           \
     ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_SOCKET, \
                        PORTALLOCATOR_ENABLE_SHARED_SOCKET);      \
-    if (kMatrix[x][y] != NULL)                                   \
+    if (kMatrix[x][y] != nullptr)                                \
       Test(*kMatrix[x][y]);                                      \
     else                                                         \
       LOG(LS_WARNING) << "Not yet implemented";                  \
   }
 
 #define P2P_TEST(x, y) \
   P2P_TEST_DECLARATION(x, y,)
 
 #define P2P_TEST_SET(x)                    \
   P2P_TEST(x, OPEN)                        \
@@ skipping 382 matching lines @@
   DestroyChannels();
 }
 
 // Test that if remote candidates don't have ufrag and pwd, we still work.
 TEST_F(P2PTransportChannelTest, RemoteCandidatesWithoutUfragPwd) {
   rtc::ScopedFakeClock clock;
   set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
   ConfigureEndpoints(OPEN, OPEN, kDefaultPortAllocatorFlags,
                      kDefaultPortAllocatorFlags);
   CreateChannels();
-  const Connection* selected_connection = NULL;
+  const Connection* selected_connection = nullptr;
   // Wait until the callee's connections are created.
   EXPECT_TRUE_SIMULATED_WAIT(
-      (selected_connection = ep2_ch1()->selected_connection()) != NULL,
+      (selected_connection = ep2_ch1()->selected_connection()) != nullptr,
       kMediumTimeout, clock);
   // Wait to make sure the selected connection is not changed.
   SIMULATED_WAIT(ep2_ch1()->selected_connection() != selected_connection,
                  kShortTimeout, clock);
   EXPECT_TRUE(ep2_ch1()->selected_connection() == selected_connection);
   DestroyChannels();
 }
 
 // Test that a host behind NAT cannot be reached when incoming_only
 // is set to true.
@@ skipping 22 matching lines @@
 TEST_F(P2PTransportChannelTest, IncomingOnlyOpen) {
   rtc::ScopedFakeClock clock;
   ConfigureEndpoints(OPEN, NAT_FULL_CONE, kDefaultPortAllocatorFlags,
                      kDefaultPortAllocatorFlags);
 
   SetAllocatorFlags(0, kOnlyLocalPorts);
   CreateChannels();
   ep1_ch1()->set_incoming_only(true);
 
   EXPECT_TRUE_SIMULATED_WAIT(
-      ep1_ch1() != NULL && ep2_ch1() != NULL && ep1_ch1()->receiving() &&
+      ep1_ch1() != nullptr && ep2_ch1() != nullptr && ep1_ch1()->receiving() &&
           ep1_ch1()->writable() && ep2_ch1()->receiving() &&
           ep2_ch1()->writable(),
       kMediumTimeout, clock);
 
   DestroyChannels();
 }
 
 TEST_F(P2PTransportChannelTest, TestTcpConnectionsFromActiveToPassive) {
   rtc::ScopedFakeClock clock;
   AddAddress(0, kPublicAddrs[0]);
@@ skipping 193 matching lines @@
                      kDefaultPortAllocatorFlags);
   SetAllocationStepDelay(0, kDefaultStepDelay);
   SetAllocationStepDelay(1, kDefaultStepDelay);
   IceConfig continual_gathering_config =
       CreateIceConfig(1000, GATHER_CONTINUALLY);
   // By default, ep2 does not gather continually.
   IceConfig default_config;
   CreateChannels(continual_gathering_config, default_config);
 
   EXPECT_TRUE_SIMULATED_WAIT(
-      ep1_ch1() != NULL && ep2_ch1() != NULL && ep1_ch1()->receiving() &&
+      ep1_ch1() != nullptr && ep2_ch1() != nullptr && ep1_ch1()->receiving() &&
           ep1_ch1()->writable() && ep2_ch1()->receiving() &&
           ep2_ch1()->writable(),
       kMediumTimeout, clock);
   SIMULATED_WAIT(
       IceGatheringState::kIceGatheringComplete == ep1_ch1()->gathering_state(),
       kShortTimeout, clock);
   EXPECT_EQ(IceGatheringState::kIceGatheringGathering,
             ep1_ch1()->gathering_state());
   // By now, ep2 should have completed gathering.
   EXPECT_EQ(IceGatheringState::kIceGatheringComplete,
@@ skipping 23 matching lines @@
   ASSERT_NE(nullptr, pooled_session_1);
   ASSERT_NE(nullptr, pooled_session_2);
   // Sanity check that pooled sessions haven't gathered anything yet.
   EXPECT_TRUE(pooled_session_1->ReadyPorts().empty());
   EXPECT_TRUE(pooled_session_1->ReadyCandidates().empty());
   EXPECT_TRUE(pooled_session_2->ReadyPorts().empty());
   EXPECT_TRUE(pooled_session_2->ReadyCandidates().empty());
   // Now let the endpoints connect and try exchanging some data.
   CreateChannels();
   EXPECT_TRUE_SIMULATED_WAIT(
-      ep1_ch1() != NULL && ep2_ch1() != NULL && ep1_ch1()->receiving() &&
+      ep1_ch1() != nullptr && ep2_ch1() != nullptr && ep1_ch1()->receiving() &&
           ep1_ch1()->writable() && ep2_ch1()->receiving() &&
           ep2_ch1()->writable(),
       kMediumTimeout, clock);
   TestSendRecv(clock);
   // Make sure the P2PTransportChannels are actually using ports from the
   // pooled sessions.
   auto pooled_ports_1 = pooled_session_1->ReadyPorts();
   auto pooled_ports_2 = pooled_session_2->ReadyPorts();
   EXPECT_NE(pooled_ports_1.end(),
             std::find(pooled_ports_1.begin(), pooled_ports_1.end(),
@@ skipping 24 matching lines @@
   ASSERT_NE(nullptr, pooled_session_1);
   ASSERT_NE(nullptr, pooled_session_2);
   // Wait for the pooled sessions to finish gathering before the
   // P2PTransportChannels try to use them.
   EXPECT_TRUE_SIMULATED_WAIT(pooled_session_1->CandidatesAllocationDone() &&
                                  pooled_session_2->CandidatesAllocationDone(),
                              kDefaultTimeout, clock);
   // Now let the endpoints connect and try exchanging some data.
   CreateChannels();
   EXPECT_TRUE_SIMULATED_WAIT(
-      ep1_ch1() != NULL && ep2_ch1() != NULL && ep1_ch1()->receiving() &&
+      ep1_ch1() != nullptr && ep2_ch1() != nullptr && ep1_ch1()->receiving() &&
           ep1_ch1()->writable() && ep2_ch1()->receiving() &&
           ep2_ch1()->writable(),
       kMediumTimeout, clock);
   TestSendRecv(clock);
   // Make sure the P2PTransportChannels are actually using ports from the
   // pooled sessions.
   auto pooled_ports_1 = pooled_session_1->ReadyPorts();
   auto pooled_ports_2 = pooled_session_2->ReadyPorts();
   EXPECT_NE(pooled_ports_1.end(),
             std::find(pooled_ports_1.begin(), pooled_ports_1.end(),
@@ skipping 2508 matching lines @@
 
   // TCP Relay/Relay is the next.
   VerifyNextPingableConnection(RELAY_PORT_TYPE, RELAY_PORT_TYPE,
                                TCP_PROTOCOL_NAME);
 
   // Finally, Local/Relay will be pinged.
   VerifyNextPingableConnection(LOCAL_PORT_TYPE, RELAY_PORT_TYPE);
 }
 
 }  // namespace cricket {