Adding ability to simulate EWOULDBLOCK/SignalReadyToSend.

webrtc/base/testclient.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.
  */
 
 #include "webrtc/base/testclient.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 
 namespace rtc {
 
 // DESIGN: Each packet received is put it into a list of packets.
 //         Callers can retrieve received packets from any thread by calling
 //         NextPacket.
 
 TestClient::TestClient(AsyncPacketSocket* socket)
-    : socket_(socket), ready_to_send_(false), prev_packet_timestamp_(-1) {
+    : socket_(socket), prev_packet_timestamp_(-1) {
   packets_ = new std::vector<Packet*>();
   socket_->SignalReadPacket.connect(this, &TestClient::OnPacket);
   socket_->SignalReadyToSend.connect(this, &TestClient::OnReadyToSend);
 }
 
 TestClient::~TestClient() {
   delete socket_;
   for (unsigned i = 0; i < packets_->size(); i++)
     delete (*packets_)[i];
   delete packets_;
@@ skipping 90 matching lines @@
 }
 
 int TestClient::GetError() {
   return socket_->GetError();
 }
 
 int TestClient::SetOption(Socket::Option opt, int value) {
   return socket_->SetOption(opt, value);
 }
 
-bool TestClient::ready_to_send() const {
-  return ready_to_send_;
-}
-
 void TestClient::OnPacket(AsyncPacketSocket* socket, const char* buf,
                           size_t size, const SocketAddress& remote_addr,
                           const PacketTime& packet_time) {
   CritScope cs(&crit_);
   packets_->push_back(new Packet(remote_addr, buf, size, packet_time));
 }
 
 void TestClient::OnReadyToSend(AsyncPacketSocket* socket) {
-  ready_to_send_ = true;
+  ++ready_to_send_count_;
 }
 
 TestClient::Packet::Packet(const SocketAddress& a,
                            const char* b,
                            size_t s,
                            const PacketTime& packet_time)
     : addr(a), buf(0), size(s), packet_time(packet_time) {
   buf = new char[size];
   memcpy(buf, b, size);
 }
 
 TestClient::Packet::Packet(const Packet& p)
     : addr(p.addr), buf(0), size(p.size), packet_time(p.packet_time) {
   buf = new char[size];
   memcpy(buf, p.buf, size);
 }
 
 TestClient::Packet::~Packet() {
   delete[] buf;
 }
 
 }  // namespace rtc