diff options
Diffstat (limited to 'chromium/third_party/webrtc/base/testclient.cc')
-rw-r--r-- | chromium/third_party/webrtc/base/testclient.cc | 148 |
1 files changed, 148 insertions, 0 deletions
diff --git a/chromium/third_party/webrtc/base/testclient.cc b/chromium/third_party/webrtc/base/testclient.cc new file mode 100644 index 00000000000..32670e21a9e --- /dev/null +++ b/chromium/third_party/webrtc/base/testclient.cc @@ -0,0 +1,148 @@ +/* + * 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) { + 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_; +} + +bool TestClient::CheckConnState(AsyncPacketSocket::State state) { + // Wait for our timeout value until the socket reaches the desired state. + uint32 end = TimeAfter(kTimeout); + while (socket_->GetState() != state && TimeUntil(end) > 0) + Thread::Current()->ProcessMessages(1); + return (socket_->GetState() == state); +} + +int TestClient::Send(const char* buf, size_t size) { + rtc::PacketOptions options; + return socket_->Send(buf, size, options); +} + +int TestClient::SendTo(const char* buf, size_t size, + const SocketAddress& dest) { + rtc::PacketOptions options; + return socket_->SendTo(buf, size, dest, options); +} + +TestClient::Packet* TestClient::NextPacket() { + // If no packets are currently available, we go into a get/dispatch loop for + // at most 1 second. If, during the loop, a packet arrives, then we can stop + // early and return it. + + // Note that the case where no packet arrives is important. We often want to + // test that a packet does not arrive. + + // Note also that we only try to pump our current thread's message queue. + // Pumping another thread's queue could lead to messages being dispatched from + // the wrong thread to non-thread-safe objects. + + uint32 end = TimeAfter(kTimeout); + while (TimeUntil(end) > 0) { + { + CritScope cs(&crit_); + if (packets_->size() != 0) { + break; + } + } + Thread::Current()->ProcessMessages(1); + } + + // Return the first packet placed in the queue. + Packet* packet = NULL; + CritScope cs(&crit_); + if (packets_->size() > 0) { + packet = packets_->front(); + packets_->erase(packets_->begin()); + } + + return packet; +} + +bool TestClient::CheckNextPacket(const char* buf, size_t size, + SocketAddress* addr) { + bool res = false; + Packet* packet = NextPacket(); + if (packet) { + res = (packet->size == size && memcmp(packet->buf, buf, size) == 0); + if (addr) + *addr = packet->addr; + delete packet; + } + return res; +} + +bool TestClient::CheckNoPacket() { + bool res; + Packet* packet = NextPacket(); + res = (packet == NULL); + delete packet; + return res; +} + +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)); +} + +void TestClient::OnReadyToSend(AsyncPacketSocket* socket) { + ready_to_send_ = true; +} + +TestClient::Packet::Packet(const SocketAddress& a, const char* b, size_t s) + : addr(a), buf(0), size(s) { + buf = new char[size]; + memcpy(buf, b, size); +} + +TestClient::Packet::Packet(const Packet& p) + : addr(p.addr), buf(0), size(p.size) { + buf = new char[size]; + memcpy(buf, p.buf, size); +} + +TestClient::Packet::~Packet() { + delete[] buf; +} + +} // namespace rtc |