OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/tools/quic/test_tools/packet_dropping_test_writer.h" | 5 #include "net/tools/quic/test_tools/packet_dropping_test_writer.h" |
6 | 6 |
7 #include <limits> | 7 #include <limits> |
8 | 8 |
9 #include "base/rand_util.h" | 9 #include "base/rand_util.h" |
10 #include "net/tools/quic/quic_epoll_connection_helper.h" | 10 #include "net/tools/quic/quic_epoll_connection_helper.h" |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
48 cur_buffer_size_(0), | 48 cur_buffer_size_(0), |
49 num_calls_to_write_(0), | 49 num_calls_to_write_(0), |
50 config_mutex_(), | 50 config_mutex_(), |
51 fake_packet_loss_percentage_(0), | 51 fake_packet_loss_percentage_(0), |
52 fake_drop_first_n_packets_(0), | 52 fake_drop_first_n_packets_(0), |
53 fake_blocked_socket_percentage_(0), | 53 fake_blocked_socket_percentage_(0), |
54 fake_packet_reorder_percentage_(0), | 54 fake_packet_reorder_percentage_(0), |
55 fake_packet_delay_(QuicTime::Delta::Zero()), | 55 fake_packet_delay_(QuicTime::Delta::Zero()), |
56 fake_bandwidth_(QuicBandwidth::Zero()), | 56 fake_bandwidth_(QuicBandwidth::Zero()), |
57 buffer_size_(0) { | 57 buffer_size_(0) { |
58 uint32 seed = base::RandInt(0, std::numeric_limits<int32>::max()); | 58 uint32_t seed = base::RandInt(0, std::numeric_limits<int32_t>::max()); |
59 VLOG(1) << "Seeding packet loss with " << seed; | 59 VLOG(1) << "Seeding packet loss with " << seed; |
60 simple_random_.set_seed(seed); | 60 simple_random_.set_seed(seed); |
61 } | 61 } |
62 | 62 |
63 PacketDroppingTestWriter::~PacketDroppingTestWriter() {} | 63 PacketDroppingTestWriter::~PacketDroppingTestWriter() {} |
64 | 64 |
65 void PacketDroppingTestWriter::Initialize(QuicConnectionHelperInterface* helper, | 65 void PacketDroppingTestWriter::Initialize(QuicConnectionHelperInterface* helper, |
66 Delegate* on_can_write) { | 66 Delegate* on_can_write) { |
67 clock_ = helper->GetClock(); | 67 clock_ = helper->GetClock(); |
68 write_unblocked_alarm_.reset( | 68 write_unblocked_alarm_.reset( |
69 helper->CreateAlarm(new WriteUnblockedAlarm(this))); | 69 helper->CreateAlarm(new WriteUnblockedAlarm(this))); |
70 delay_alarm_.reset(helper->CreateAlarm(new DelayAlarm(this))); | 70 delay_alarm_.reset(helper->CreateAlarm(new DelayAlarm(this))); |
71 on_can_write_.reset(on_can_write); | 71 on_can_write_.reset(on_can_write); |
72 } | 72 } |
73 | 73 |
74 WriteResult PacketDroppingTestWriter::WritePacket( | 74 WriteResult PacketDroppingTestWriter::WritePacket( |
75 const char* buffer, | 75 const char* buffer, |
76 size_t buf_len, | 76 size_t buf_len, |
77 const net::IPAddressNumber& self_address, | 77 const net::IPAddressNumber& self_address, |
78 const net::IPEndPoint& peer_address) { | 78 const net::IPEndPoint& peer_address) { |
79 ++num_calls_to_write_; | 79 ++num_calls_to_write_; |
80 ReleaseOldPackets(); | 80 ReleaseOldPackets(); |
81 | 81 |
82 base::AutoLock locked(config_mutex_); | 82 base::AutoLock locked(config_mutex_); |
83 if (fake_drop_first_n_packets_ > 0 && | 83 if (fake_drop_first_n_packets_ > 0 && |
84 num_calls_to_write_ <= static_cast<uint64>(fake_drop_first_n_packets_)) { | 84 num_calls_to_write_ <= |
| 85 static_cast<uint64_t>(fake_drop_first_n_packets_)) { |
85 DVLOG(1) << "Dropping first " << fake_drop_first_n_packets_ | 86 DVLOG(1) << "Dropping first " << fake_drop_first_n_packets_ |
86 << " packets (packet number " << num_calls_to_write_ << ")"; | 87 << " packets (packet number " << num_calls_to_write_ << ")"; |
87 return WriteResult(WRITE_STATUS_OK, buf_len); | 88 return WriteResult(WRITE_STATUS_OK, buf_len); |
88 } | 89 } |
89 if (fake_packet_loss_percentage_ > 0 && | 90 if (fake_packet_loss_percentage_ > 0 && |
90 simple_random_.RandUint64() % 100 < | 91 simple_random_.RandUint64() % 100 < |
91 static_cast<uint64>(fake_packet_loss_percentage_)) { | 92 static_cast<uint64_t>(fake_packet_loss_percentage_)) { |
92 DVLOG(1) << "Dropping packet."; | 93 DVLOG(1) << "Dropping packet."; |
93 return WriteResult(WRITE_STATUS_OK, buf_len); | 94 return WriteResult(WRITE_STATUS_OK, buf_len); |
94 } | 95 } |
95 if (fake_blocked_socket_percentage_ > 0 && | 96 if (fake_blocked_socket_percentage_ > 0 && |
96 simple_random_.RandUint64() % 100 < | 97 simple_random_.RandUint64() % 100 < |
97 static_cast<uint64>(fake_blocked_socket_percentage_)) { | 98 static_cast<uint64_t>(fake_blocked_socket_percentage_)) { |
98 CHECK(on_can_write_.get() != nullptr); | 99 CHECK(on_can_write_.get() != nullptr); |
99 DVLOG(1) << "Blocking socket."; | 100 DVLOG(1) << "Blocking socket."; |
100 if (!write_unblocked_alarm_->IsSet()) { | 101 if (!write_unblocked_alarm_->IsSet()) { |
101 // Set the alarm to fire immediately. | 102 // Set the alarm to fire immediately. |
102 write_unblocked_alarm_->Set(clock_->ApproximateNow()); | 103 write_unblocked_alarm_->Set(clock_->ApproximateNow()); |
103 } | 104 } |
104 return WriteResult(WRITE_STATUS_BLOCKED, EAGAIN); | 105 return WriteResult(WRITE_STATUS_BLOCKED, EAGAIN); |
105 } | 106 } |
106 | 107 |
107 if (!fake_packet_delay_.IsZero() || !fake_bandwidth_.IsZero()) { | 108 if (!fake_packet_delay_.IsZero() || !fake_bandwidth_.IsZero()) { |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
155 | 156 |
156 QuicTime PacketDroppingTestWriter::ReleaseNextPacket() { | 157 QuicTime PacketDroppingTestWriter::ReleaseNextPacket() { |
157 if (delayed_packets_.empty()) { | 158 if (delayed_packets_.empty()) { |
158 return QuicTime::Zero(); | 159 return QuicTime::Zero(); |
159 } | 160 } |
160 base::AutoLock locked(config_mutex_); | 161 base::AutoLock locked(config_mutex_); |
161 DelayedPacketList::iterator iter = delayed_packets_.begin(); | 162 DelayedPacketList::iterator iter = delayed_packets_.begin(); |
162 // Determine if we should re-order. | 163 // Determine if we should re-order. |
163 if (delayed_packets_.size() > 1 && fake_packet_reorder_percentage_ > 0 && | 164 if (delayed_packets_.size() > 1 && fake_packet_reorder_percentage_ > 0 && |
164 simple_random_.RandUint64() % 100 < | 165 simple_random_.RandUint64() % 100 < |
165 static_cast<uint64>(fake_packet_reorder_percentage_)) { | 166 static_cast<uint64_t>(fake_packet_reorder_percentage_)) { |
166 DVLOG(1) << "Reordering packets."; | 167 DVLOG(1) << "Reordering packets."; |
167 ++iter; | 168 ++iter; |
168 // Swap the send times when re-ordering packets. | 169 // Swap the send times when re-ordering packets. |
169 delayed_packets_.begin()->send_time = iter->send_time; | 170 delayed_packets_.begin()->send_time = iter->send_time; |
170 } | 171 } |
171 | 172 |
172 DVLOG(1) << "Releasing packet. " << (delayed_packets_.size() - 1) | 173 DVLOG(1) << "Releasing packet. " << (delayed_packets_.size() - 1) |
173 << " remaining."; | 174 << " remaining."; |
174 // Grab the next one off the queue and send it. | 175 // Grab the next one off the queue and send it. |
175 QuicPacketWriterWrapper::WritePacket(iter->buffer.data(), | 176 QuicPacketWriterWrapper::WritePacket(iter->buffer.data(), |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
210 : buffer(buffer, buf_len), | 211 : buffer(buffer, buf_len), |
211 self_address(self_address), | 212 self_address(self_address), |
212 peer_address(peer_address), | 213 peer_address(peer_address), |
213 send_time(send_time) {} | 214 send_time(send_time) {} |
214 | 215 |
215 PacketDroppingTestWriter::DelayedWrite::~DelayedWrite() {} | 216 PacketDroppingTestWriter::DelayedWrite::~DelayedWrite() {} |
216 | 217 |
217 } // namespace test | 218 } // namespace test |
218 } // namespace tools | 219 } // namespace tools |
219 } // namespace net | 220 } // namespace net |
OLD | NEW |