src/net/tools/quic/test_tools/packet_dropping_test_writer.h

   1 // Copyright 2013 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 NET_TOOLS_QUIC_TEST_TOOLS_PACKET_DROPPING_TEST_WRITER_H_
   6 #define NET_TOOLS_QUIC_TEST_TOOLS_PACKET_DROPPING_TEST_WRITER_H_
   7
   8 #include <list>
   9
  10 #include "base/logging.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/synchronization/lock.h"
  13 #include "net/quic/quic_alarm.h"
  14 #include "net/quic/quic_blocked_writer_interface.h"
  15 #include "net/quic/quic_packet_writer.h"
  16 #include "net/quic/test_tools/quic_test_writer.h"
  17 #include "net/tools/quic/quic_epoll_clock.h"
  18 #include "net/tools/quic/test_tools/quic_test_client.h"
  19 #include "net/tools/quic/test_tools/quic_test_utils.h"
  20
  21 namespace net {
  22 namespace tools {
  23 namespace test {
  24
  25 // Simulates a connection that drops packets a configured percentage of the time
  26 // and has a blocked socket a configured percentage of the time.  Also provides
  27 // the options to delay packets and reorder packets if delay is enabled.
  28 class PacketDroppingTestWriter : public net::test::QuicTestWriter {
  29  public:
  30   PacketDroppingTestWriter();
  31
  32   virtual ~PacketDroppingTestWriter();
  33
  34   void SetConnectionHelper(QuicEpollConnectionHelper* helper);
  35
  36   // QuicPacketWriter methods:
  37   virtual WriteResult WritePacket(
  38       const char* buffer, size_t buf_len,
  39       const IPAddressNumber& self_address,
  40       const IPEndPoint& peer_address,
  41       QuicBlockedWriterInterface* blocked_writer) OVERRIDE;
  42
  43   virtual bool IsWriteBlockedDataBuffered() const OVERRIDE;
  44
  45   // Writes out the next packet to the contained writer and returns the time
  46   // for the next delayed packet to be written.
  47   QuicTime ReleaseNextPacket();
  48
  49   QuicBlockedWriterInterface* blocked_writer() { return blocked_writer_; }
  50
  51   // The percent of time a packet is simulated as being lost.
  52   void set_fake_packet_loss_percentage(int32 fake_packet_loss_percentage) {
  53     base::AutoLock locked(config_mutex_);
  54     fake_packet_loss_percentage_ = fake_packet_loss_percentage;
  55   }
  56
  57   // The percent of time WritePacket will block and set WriteResult's status
  58   // to WRITE_STATUS_BLOCKED.
  59   void set_fake_blocked_socket_percentage(
  60       int32 fake_blocked_socket_percentage) {
  61     DCHECK(clock_);
  62     base::AutoLock locked(config_mutex_);
  63     fake_blocked_socket_percentage_  = fake_blocked_socket_percentage;
  64   }
  65
  66   // The percent of time a packet is simulated as being reordered.
  67   void set_fake_reorder_percentage(int32 fake_packet_reorder_percentage) {
  68     DCHECK(clock_);
  69     base::AutoLock locked(config_mutex_);
  70     DCHECK(!fake_packet_delay_.IsZero());
  71     fake_packet_reorder_percentage_ = fake_packet_reorder_percentage;
  72   }
  73
  74   // The percent of time WritePacket will block and set WriteResult's status
  75   // to WRITE_STATUS_BLOCKED.
  76   void set_fake_packet_delay(QuicTime::Delta fake_packet_delay) {
  77     DCHECK(clock_);
  78     base::AutoLock locked(config_mutex_);
  79     fake_packet_delay_  = fake_packet_delay;
  80   }
  81
  82   void set_seed(uint64 seed) {
  83     simple_random_.set_seed(seed);
  84   }
  85
  86  private:
  87   // A single packet which will be sent at the supplied send_time.
  88   class DelayedWrite {
  89    public:
  90     DelayedWrite(const char* buffer,
  91                  size_t buf_len,
  92                  const IPAddressNumber& self_address,
  93                  const IPEndPoint& peer_address,
  94                  QuicTime send_time);
  95     ~DelayedWrite();
  96
  97     string buffer;
  98     const IPAddressNumber self_address;
  99     const IPEndPoint peer_address;
 100     QuicTime send_time;
 101   };
 102
 103   typedef std::list<DelayedWrite> DelayedPacketList;
 104
 105   const QuicClock* clock_;
 106   scoped_ptr<QuicAlarm> write_unblocked_alarm_;
 107   scoped_ptr<QuicAlarm> delay_alarm_;
 108   QuicBlockedWriterInterface* blocked_writer_;
 109   SimpleRandom simple_random_;
 110   DelayedPacketList delayed_packets_;
 111
 112   base::Lock config_mutex_;
 113   int32 fake_packet_loss_percentage_;
 114   int32 fake_blocked_socket_percentage_;
 115   int32 fake_packet_reorder_percentage_;
 116   QuicTime::Delta fake_packet_delay_;
 117
 118   DISALLOW_COPY_AND_ASSIGN(PacketDroppingTestWriter);
 119 };
 120
 121 }  // namespace test
 122 }  // namespace tools
 123 }  // namespace net
 124
 125 #endif  // NET_TOOLS_QUIC_TEST_TOOLS_PACKET_DROPPING_TEST_WRITER_H_