Replace readable with receiving where receiving means receiving anything (stun ping, response or da…

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 803 matching lines @@
     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);
     ch2.Ping();
     WAIT(ch2.conn()->write_state() == Connection::STATE_WRITABLE, kTimeout);
 
     if (same_addr1 && same_addr2) {
       // The new ping got back to the source.
-      EXPECT_EQ(Connection::STATE_READABLE, ch1.conn()->read_state());
+      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
       // through.  So we will have to do another.
       if (ch1.conn()->write_state() == Connection::STATE_WRITE_INIT) {
         ch1.Ping();
         EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
                        kTimeout);
       }
     } else if (!same_addr1 && possible) {
       // The new ping went to the candidate address, but that address was bad.
       // This will happen when the source NAT is symmetric.
       EXPECT_TRUE(ch1.remote_address().IsNil());
       EXPECT_TRUE(ch2.remote_address().IsNil());
 
       // 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_WAIT(!ch2.remote_address().IsNil(), kTimeout);
-      EXPECT_EQ(Connection::STATE_READ_INIT, ch2.conn()->read_state());
+      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);
       ch2.Ping();
       EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch2.conn()->write_state(),
                      kTimeout);
     } 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_EQ(Connection::STATE_READ_INIT, ch1.conn()->read_state());
+      EXPECT_FALSE(ch1.conn()->receiving());
 
       // Update our address and complete the connection.
       ch1.AcceptConnection(GetCandidate(port2));
       ch1.Ping();
       EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
                      kTimeout);
     } 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();
       WAIT(!ch2.remote_address().IsNil(), kTimeout);
       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);
   if (possible) {
-    EXPECT_EQ(Connection::STATE_READABLE, ch1.conn()->read_state());
+    EXPECT_TRUE(ch1.conn()->receiving());
     EXPECT_EQ(Connection::STATE_WRITABLE, ch1.conn()->write_state());
-    EXPECT_EQ(Connection::STATE_READABLE, ch2.conn()->read_state());
+    EXPECT_TRUE(ch2.conn()->receiving());
     EXPECT_EQ(Connection::STATE_WRITABLE, ch2.conn()->write_state());
   } else {
-    EXPECT_NE(Connection::STATE_READABLE, ch1.conn()->read_state());
+    EXPECT_FALSE(ch1.conn()->receiving());
     EXPECT_NE(Connection::STATE_WRITABLE, ch1.conn()->write_state());
-    EXPECT_NE(Connection::STATE_READABLE, ch2.conn()->read_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_WAIT(ch1.conn() == NULL, kTimeout);
   EXPECT_TRUE_WAIT(ch2.conn() == NULL, kTimeout);
 }
 
@@ skipping 369 matching lines @@
                      lport->last_stun_buf()->Length(),
                      rtc::PacketTime());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   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 in STATE_READABLE.
+  // 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, 1000);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   rtc::scoped_ptr<IceMessage> modified_req(
       CreateStunMessage(STUN_BINDING_REQUEST));
   const StunByteStringAttribute* username_attr = msg->GetByteString(
@@ skipping 1116 matching lines @@
   // Set up channels and ensure both ports will be deleted.
   TestChannel ch1(port1);
   TestChannel ch2(port2);
 
   // Simulate a connection that succeeds, and then is destroyed.
   StartConnectAndStopChannels(&ch1, &ch2);
 
   // The controlled port should be destroyed after 10 milliseconds.
   EXPECT_TRUE_WAIT(destroyed(), kTimeout);
 }