src/remoting/test/fake_socket_factory.h

   1 // Copyright 2014 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 REMOTING_TEST_FAKE_SOCKET_FACTORY_H_
   6 #define REMOTING_TEST_FAKE_SOCKET_FACTORY_H_
   7
   8 #include <list>
   9
  10 #include "base/callback_forward.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "remoting/test/fake_network_dispatcher.h"
  14 #include "third_party/libjingle/source/talk/p2p/base/packetsocketfactory.h"
  15
  16 namespace remoting {
  17
  18 class FakeNetworkDispatcher;
  19 class LeakyBucket;
  20
  21 class FakePacketSocketFactory : public rtc::PacketSocketFactory,
  22                                 public FakeNetworkDispatcher::Node {
  23  public:
  24   // |dispatcher| must outlive the factory.
  25   explicit FakePacketSocketFactory(FakeNetworkDispatcher* dispatcher);
  26   virtual ~FakePacketSocketFactory();
  27
  28   void OnSocketDestroyed(int port);
  29
  30   // |bandwidth| - simulated link bandwidth in bytes/second. 0 indicates that
  31   // bandwidth is unlimited.
  32   // |max_buffer| - size of buffers in bytes. Ignored when |bandwidth| is 0.
  33   void SetBandwidth(int bandwidth, int max_buffer);
  34
  35   // Specifies parameters for simulated network latency. Latency is generated
  36   // with normal distribution around |average| with the given |stddev|. Random
  37   // latency calculated based on these parameters is added to the buffering
  38   // delay (which is calculated based on the parameters passed to
  39   // SetBandwidth()). I.e. total latency for each packet is calculated using the
  40   // following formula
  41   //
  42   //    l = NormalRand(average, stddev) + bytes_buffered / bandwidth .
  43   //
  44   // Where bytes_buffered is the current level in the leaky bucket used to
  45   // control bandwidth.
  46   void SetLatency(base::TimeDelta average, base::TimeDelta stddev);
  47
  48   void set_out_of_order_rate(double out_of_order_rate) {
  49     out_of_order_rate_ = out_of_order_rate;
  50   }
  51
  52   // rtc::PacketSocketFactory interface.
  53   virtual rtc::AsyncPacketSocket* CreateUdpSocket(
  54       const rtc::SocketAddress& local_address,
  55       int min_port, int max_port) OVERRIDE;
  56   virtual rtc::AsyncPacketSocket* CreateServerTcpSocket(
  57       const rtc::SocketAddress& local_address,
  58       int min_port, int max_port,
  59       int opts) OVERRIDE;
  60   virtual rtc::AsyncPacketSocket* CreateClientTcpSocket(
  61       const rtc::SocketAddress& local_address,
  62       const rtc::SocketAddress& remote_address,
  63       const rtc::ProxyInfo& proxy_info,
  64       const std::string& user_agent,
  65       int opts) OVERRIDE;
  66   virtual rtc::AsyncResolverInterface* CreateAsyncResolver() OVERRIDE;
  67
  68   // FakeNetworkDispatcher::Node interface.
  69   virtual const scoped_refptr<base::SingleThreadTaskRunner>& GetThread()
  70       const OVERRIDE;
  71   virtual const rtc::IPAddress& GetAddress() const OVERRIDE;
  72   virtual void ReceivePacket(const rtc::SocketAddress& from,
  73                              const rtc::SocketAddress& to,
  74                              const scoped_refptr<net::IOBuffer>& data,
  75                              int data_size) OVERRIDE;
  76
  77  private:
  78   struct PendingPacket {
  79     PendingPacket();
  80     PendingPacket(
  81         const rtc::SocketAddress& from,
  82         const rtc::SocketAddress& to,
  83         const scoped_refptr<net::IOBuffer>& data,
  84         int data_size);
  85     ~PendingPacket();
  86
  87     rtc::SocketAddress from;
  88     rtc::SocketAddress to;
  89     scoped_refptr<net::IOBuffer> data;
  90     int data_size;
  91   };
  92
  93   typedef base::Callback<void(const rtc::SocketAddress& from,
  94                               const rtc::SocketAddress& to,
  95                               const scoped_refptr<net::IOBuffer>& data,
  96                               int data_size)> ReceiveCallback;
  97   typedef std::map<uint16_t, ReceiveCallback> UdpSocketsMap;
  98
  99   void DoReceivePacket();
 100
 101   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 102   scoped_refptr<FakeNetworkDispatcher> dispatcher_;
 103
 104   rtc::IPAddress address_;
 105
 106   scoped_ptr<LeakyBucket> leaky_bucket_;
 107   base::TimeDelta latency_average_;
 108   base::TimeDelta latency_stddev_;
 109   double out_of_order_rate_;
 110
 111   UdpSocketsMap udp_sockets_;
 112   uint16_t next_port_;
 113
 114   std::list<PendingPacket> pending_packets_;
 115
 116   base::WeakPtrFactory<FakePacketSocketFactory> weak_factory_;
 117
 118   DISALLOW_COPY_AND_ASSIGN(FakePacketSocketFactory);
 119 };
 120
 121 }  // namespace remoting
 122
 123 #endif  // REMOTING_TEST_FAKE_SOCKET_FACTORY_H_