Fix issue with send-side bandwidth estimation over TURN TCP connections.

webrtc/p2p/base/asyncstuntcpsocket_unittest.cc

 /*
  *  Copyright 2013 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 68 matching lines @@
         kServerAddr.family(), SOCK_STREAM);
     server->Bind(kServerAddr);
     recv_socket_.reset(new AsyncStunTCPSocket(server, true));
     recv_socket_->SignalNewConnection.connect(
         this, &AsyncStunTCPSocketTest::OnNewConnection);
 
     rtc::AsyncSocket* client = vss_->CreateAsyncSocket(
         kClientAddr.family(), SOCK_STREAM);
     send_socket_.reset(AsyncStunTCPSocket::Create(
         client, kClientAddr, recv_socket_->GetLocalAddress()));
+    send_socket_->SignalSentPacket.connect(
+        this, &AsyncStunTCPSocketTest::OnSentPacket);
     ASSERT_TRUE(send_socket_.get() != NULL);
     vss_->ProcessMessagesUntilIdle();
   }
 
   void OnReadPacket(rtc::AsyncPacketSocket* socket, const char* data,
                     size_t len, const rtc::SocketAddress& remote_addr,
                     const rtc::PacketTime& packet_time) {
     recv_packets_.push_back(std::string(data, len));
   }
 
+  void OnSentPacket(rtc::AsyncPacketSocket* socket,
+                    const rtc::SentPacket& packet) {
+    ++sent_packets_;
+  }
+
   void OnNewConnection(rtc::AsyncPacketSocket* server,
                        rtc::AsyncPacketSocket* new_socket) {
     listen_socket_.reset(new_socket);
     new_socket->SignalReadPacket.connect(
         this, &AsyncStunTCPSocketTest::OnReadPacket);
   }
 
   bool Send(const void* data, size_t len) {
     rtc::PacketOptions options;
     size_t ret = send_socket_->Send(
@@ skipping 11 matching lines @@
     }
     return ret;
   }
 
   std::unique_ptr<rtc::VirtualSocketServer> vss_;
   rtc::AutoSocketServerThread thread_;
   std::unique_ptr<AsyncStunTCPSocket> send_socket_;
   std::unique_ptr<AsyncStunTCPSocket> recv_socket_;
   std::unique_ptr<rtc::AsyncPacketSocket> listen_socket_;
   std::list<std::string> recv_packets_;
+  int sent_packets_ = 0;
 };
 
 // Testing a stun packet sent/recv properly.
 TEST_F(AsyncStunTCPSocketTest, TestSingleStunPacket) {
   EXPECT_TRUE(Send(kStunMessageWithZeroLength,
                    sizeof(kStunMessageWithZeroLength)));
   EXPECT_EQ(1u, recv_packets_.size());
   EXPECT_TRUE(CheckData(kStunMessageWithZeroLength,
                         sizeof(kStunMessageWithZeroLength)));
 }
@@ skipping 112 matching lines @@
 // Investigate why WriteEvent is not signaled from VSS.
 TEST_F(AsyncStunTCPSocketTest, DISABLED_TestWithSmallSendBuffer) {
   vss_->set_send_buffer_capacity(1);
   Send(kTurnChannelDataMessageWithOddLength,
        sizeof(kTurnChannelDataMessageWithOddLength));
   EXPECT_EQ(1u, recv_packets_.size());
   EXPECT_TRUE(CheckData(kTurnChannelDataMessageWithOddLength,
                         sizeof(kTurnChannelDataMessageWithOddLength)));
 }
 
+// Test that SignalSentPacket is fired when a packet is sent.
+TEST_F(AsyncStunTCPSocketTest, SignalSentPacketFiredWhenPacketSent) {
+  ASSERT_TRUE(
+      Send(kStunMessageWithZeroLength, sizeof(kStunMessageWithZeroLength)));
+  EXPECT_EQ(1, sent_packets_);
+  // Send another packet for good measure.
+  ASSERT_TRUE(
+      Send(kStunMessageWithZeroLength, sizeof(kStunMessageWithZeroLength)));
+  EXPECT_EQ(2, sent_packets_);
+}
+
+// Test that SignalSentPacket isn't fired when a packet isn't sent (for
+// example, because it's invalid).
+TEST_F(AsyncStunTCPSocketTest, SignalSentPacketNotFiredWhenPacketNotSent) {
+  // Attempt to send a packet that's too small; since it isn't sent,
+  // SignalSentPacket shouldn't fire.
+  char data[1];
+  ASSERT_FALSE(Send(data, sizeof(data)));
+  EXPECT_EQ(0, sent_packets_);
+}
+
 }  // namespace cricket