Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / third_party / libjingle / source / talk / p2p / base / testrelayserver.h

diff --git a/src/third_party/libjingle/source/talk/p2p/base/testrelayserver.h b/src/third_party/libjingle/source/talk/p2p/base/testrelayserver.h
index 29e9fe4..eaeefc8 100644 (file)
--- a/src/third_party/libjingle/source/talk/p2p/base/testrelayserver.h
+++ b/src/third_party/libjingle/source/talk/p2p/base/testrelayserver.h
@@ -28,29 +28,29 @@
 #ifndef TALK_P2P_BASE_TESTRELAYSERVER_H_
 #define TALK_P2P_BASE_TESTRELAYSERVER_H_
 
-#include "talk/base/asynctcpsocket.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/socketadapters.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/thread.h"
 #include "talk/p2p/base/relayserver.h"
+#include "webrtc/base/asynctcpsocket.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/socketadapters.h"
+#include "webrtc/base/thread.h"
 
 namespace cricket {
 
 // A test relay server. Useful for unit tests.
 class TestRelayServer : public sigslot::has_slots<> {
  public:
-  TestRelayServer(talk_base::Thread* thread,
-                  const talk_base::SocketAddress& udp_int_addr,
-                  const talk_base::SocketAddress& udp_ext_addr,
-                  const talk_base::SocketAddress& tcp_int_addr,
-                  const talk_base::SocketAddress& tcp_ext_addr,
-                  const talk_base::SocketAddress& ssl_int_addr,
-                  const talk_base::SocketAddress& ssl_ext_addr)
+  TestRelayServer(rtc::Thread* thread,
+                  const rtc::SocketAddress& udp_int_addr,
+                  const rtc::SocketAddress& udp_ext_addr,
+                  const rtc::SocketAddress& tcp_int_addr,
+                  const rtc::SocketAddress& tcp_ext_addr,
+                  const rtc::SocketAddress& ssl_int_addr,
+                  const rtc::SocketAddress& ssl_ext_addr)
       : server_(thread) {
-    server_.AddInternalSocket(talk_base::AsyncUDPSocket::Create(
+    server_.AddInternalSocket(rtc::AsyncUDPSocket::Create(
         thread->socketserver(), udp_int_addr));
-    server_.AddExternalSocket(talk_base::AsyncUDPSocket::Create(
+    server_.AddExternalSocket(rtc::AsyncUDPSocket::Create(
         thread->socketserver(), udp_ext_addr));
 
     tcp_int_socket_.reset(CreateListenSocket(thread, tcp_int_addr));
@@ -61,33 +61,33 @@ class TestRelayServer : public sigslot::has_slots<> {
   int GetConnectionCount() const {
     return server_.GetConnectionCount();
   }
-  talk_base::SocketAddressPair GetConnection(int connection) const {
+  rtc::SocketAddressPair GetConnection(int connection) const {
     return server_.GetConnection(connection);
   }
-  bool HasConnection(const talk_base::SocketAddress& address) const {
+  bool HasConnection(const rtc::SocketAddress& address) const {
     return server_.HasConnection(address);
   }
 
  private:
-  talk_base::AsyncSocket* CreateListenSocket(talk_base::Thread* thread,
-      const talk_base::SocketAddress& addr) {
-    talk_base::AsyncSocket* socket =
+  rtc::AsyncSocket* CreateListenSocket(rtc::Thread* thread,
+      const rtc::SocketAddress& addr) {
+    rtc::AsyncSocket* socket =
         thread->socketserver()->CreateAsyncSocket(addr.family(), SOCK_STREAM);
     socket->Bind(addr);
     socket->Listen(5);
     socket->SignalReadEvent.connect(this, &TestRelayServer::OnAccept);
     return socket;
   }
-  void OnAccept(talk_base::AsyncSocket* socket) {
+  void OnAccept(rtc::AsyncSocket* socket) {
     bool external = (socket == tcp_ext_socket_.get() ||
                      socket == ssl_ext_socket_.get());
     bool ssl = (socket == ssl_int_socket_.get() ||
                 socket == ssl_ext_socket_.get());
-    talk_base::AsyncSocket* raw_socket = socket->Accept(NULL);
+    rtc::AsyncSocket* raw_socket = socket->Accept(NULL);
     if (raw_socket) {
-      talk_base::AsyncTCPSocket* packet_socket = new talk_base::AsyncTCPSocket(
+      rtc::AsyncTCPSocket* packet_socket = new rtc::AsyncTCPSocket(
           (!ssl) ? raw_socket :
-          new talk_base::AsyncSSLServerSocket(raw_socket), false);
+          new rtc::AsyncSSLServerSocket(raw_socket), false);
       if (!external) {
         packet_socket->SignalClose.connect(this,
             &TestRelayServer::OnInternalClose);
@@ -99,18 +99,18 @@ class TestRelayServer : public sigslot::has_slots<> {
       }
     }
   }
-  void OnInternalClose(talk_base::AsyncPacketSocket* socket, int error) {
+  void OnInternalClose(rtc::AsyncPacketSocket* socket, int error) {
     server_.RemoveInternalSocket(socket);
   }
-  void OnExternalClose(talk_base::AsyncPacketSocket* socket, int error) {
+  void OnExternalClose(rtc::AsyncPacketSocket* socket, int error) {
     server_.RemoveExternalSocket(socket);
   }
  private:
   cricket::RelayServer server_;
-  talk_base::scoped_ptr<talk_base::AsyncSocket> tcp_int_socket_;
-  talk_base::scoped_ptr<talk_base::AsyncSocket> tcp_ext_socket_;
-  talk_base::scoped_ptr<talk_base::AsyncSocket> ssl_int_socket_;
-  talk_base::scoped_ptr<talk_base::AsyncSocket> ssl_ext_socket_;
+  rtc::scoped_ptr<rtc::AsyncSocket> tcp_int_socket_;
+  rtc::scoped_ptr<rtc::AsyncSocket> tcp_ext_socket_;
+  rtc::scoped_ptr<rtc::AsyncSocket> ssl_int_socket_;
+  rtc::scoped_ptr<rtc::AsyncSocket> ssl_ext_socket_;
 };
 
 }  // namespace cricket