jingle/glue/fake_socket_factory.h

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef JINGLE_GLUE_FAKE_SOCKET_FACTORY_H_
   6 #define JINGLE_GLUE_FAKE_SOCKET_FACTORY_H_
   7
   8 #include <map>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/threading/non_thread_safe.h"
  15 #include "net/base/ip_endpoint.h"
  16 #include "third_party/libjingle/source/talk/base/asyncpacketsocket.h"
  17 #include "third_party/libjingle/source/talk/p2p/base/packetsocketfactory.h"
  18
  19 namespace base {
  20 class MessageLoop;
  21 }
  22
  23 namespace jingle_glue {
  24
  25 class FakeSocketManager;
  26
  27 class FakeUDPPacketSocket : public talk_base::AsyncPacketSocket,
  28                             public base::NonThreadSafe {
  29  public:
  30   FakeUDPPacketSocket(FakeSocketManager* fake_socket_manager,
  31                       const net::IPEndPoint& address);
  32   virtual ~FakeUDPPacketSocket();
  33
  34   const net::IPEndPoint& endpoint() const { return endpoint_; }
  35   void DeliverPacket(const net::IPEndPoint& from,
  36                      const std::vector<char>& data);
  37
  38   // talk_base::AsyncPacketSocket implementation.
  39   virtual talk_base::SocketAddress GetLocalAddress() const OVERRIDE;
  40   virtual talk_base::SocketAddress GetRemoteAddress() const OVERRIDE;
  41   virtual int Send(const void *pv, size_t cb) OVERRIDE;
  42   virtual int SendTo(const void *pv, size_t cb,
  43                      const talk_base::SocketAddress& addr) OVERRIDE;
  44   virtual int Close() OVERRIDE;
  45   virtual State GetState() const OVERRIDE;
  46   virtual int GetOption(talk_base::Socket::Option opt, int* value) OVERRIDE;
  47   virtual int SetOption(talk_base::Socket::Option opt, int value) OVERRIDE;
  48   virtual int GetError() const OVERRIDE;
  49   virtual void SetError(int error) OVERRIDE;
  50
  51  private:
  52   enum InternalState {
  53     IS_OPEN,
  54     IS_CLOSED,
  55   };
  56
  57   scoped_refptr<FakeSocketManager> fake_socket_manager_;
  58   net::IPEndPoint endpoint_;
  59   talk_base::SocketAddress local_address_;
  60   talk_base::SocketAddress remote_address_;
  61   InternalState state_;
  62   int error_;
  63
  64   DISALLOW_COPY_AND_ASSIGN(FakeUDPPacketSocket);
  65 };
  66
  67 class FakeSocketManager : public base::RefCountedThreadSafe<FakeSocketManager> {
  68  public:
  69   FakeSocketManager();
  70
  71   void SendPacket(const net::IPEndPoint& from,
  72                   const net::IPEndPoint& to,
  73                   const std::vector<char>& data);
  74
  75   void AddSocket(FakeUDPPacketSocket* socket_factory);
  76   void RemoveSocket(FakeUDPPacketSocket* socket_factory);
  77
  78  private:
  79   friend class base::RefCountedThreadSafe<FakeSocketManager>;
  80
  81   ~FakeSocketManager();
  82
  83   void DeliverPacket(const net::IPEndPoint& from,
  84                      const net::IPEndPoint& to,
  85                      const std::vector<char>& data);
  86
  87   base::MessageLoop* message_loop_;
  88   std::map<net::IPEndPoint, FakeUDPPacketSocket*> endpoints_;
  89
  90   DISALLOW_COPY_AND_ASSIGN(FakeSocketManager);
  91 };
  92
  93 class FakeSocketFactory : public talk_base::PacketSocketFactory {
  94  public:
  95   FakeSocketFactory(FakeSocketManager* socket_manager,
  96                     const net::IPAddressNumber& address);
  97   virtual ~FakeSocketFactory();
  98
  99   // talk_base::PacketSocketFactory implementation.
 100   virtual talk_base::AsyncPacketSocket* CreateUdpSocket(
 101       const talk_base::SocketAddress& local_address,
 102       int min_port, int max_port) OVERRIDE;
 103   virtual talk_base::AsyncPacketSocket* CreateServerTcpSocket(
 104       const talk_base::SocketAddress& local_address, int min_port, int max_port,
 105       int opts) OVERRIDE;
 106   virtual talk_base::AsyncPacketSocket* CreateClientTcpSocket(
 107       const talk_base::SocketAddress& local_address,
 108       const talk_base::SocketAddress& remote_address,
 109       const talk_base::ProxyInfo& proxy_info,
 110       const std::string& user_agent,
 111       int opts) OVERRIDE;
 112
 113  private:
 114   scoped_refptr<FakeSocketManager> socket_manager_;
 115   net::IPAddressNumber address_;
 116   int last_allocated_port_;
 117
 118   DISALLOW_COPY_AND_ASSIGN(FakeSocketFactory);
 119 };
 120
 121 }  // namespace jingle_glue
 122
 123 #endif  // JINGLE_GLUE_FAKE_SOCKET_FACTORY_H_