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 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
53 blocked_writer_(NULL), | 53 blocked_writer_(NULL), |
54 cur_buffer_size_(0), | 54 cur_buffer_size_(0), |
55 config_mutex_(), | 55 config_mutex_(), |
56 fake_packet_loss_percentage_(0), | 56 fake_packet_loss_percentage_(0), |
57 fake_blocked_socket_percentage_(0), | 57 fake_blocked_socket_percentage_(0), |
58 fake_packet_reorder_percentage_(0), | 58 fake_packet_reorder_percentage_(0), |
59 fake_packet_delay_(QuicTime::Delta::Zero()), | 59 fake_packet_delay_(QuicTime::Delta::Zero()), |
60 fake_bandwidth_(QuicBandwidth::Zero()), | 60 fake_bandwidth_(QuicBandwidth::Zero()), |
61 buffer_size_(0) { | 61 buffer_size_(0) { |
62 uint32 seed = base::RandInt(0, std::numeric_limits<int32>::max()); | 62 uint32 seed = base::RandInt(0, std::numeric_limits<int32>::max()); |
63 LOG(INFO) << "Seeding packet loss with " << seed; | 63 VLOG(0) << "Seeding packet loss with " << seed; |
64 simple_random_.set_seed(seed); | 64 simple_random_.set_seed(seed); |
65 } | 65 } |
66 | 66 |
67 PacketDroppingTestWriter::~PacketDroppingTestWriter() { } | 67 PacketDroppingTestWriter::~PacketDroppingTestWriter() { } |
68 | 68 |
69 void PacketDroppingTestWriter::SetConnectionHelper( | 69 void PacketDroppingTestWriter::SetConnectionHelper( |
70 QuicEpollConnectionHelper* helper) { | 70 QuicEpollConnectionHelper* helper) { |
71 clock_ = helper->GetClock(); | 71 clock_ = helper->GetClock(); |
72 write_unblocked_alarm_.reset( | 72 write_unblocked_alarm_.reset( |
73 helper->CreateAlarm(new WriteUnblockedAlarm(this))); | 73 helper->CreateAlarm(new WriteUnblockedAlarm(this))); |
74 delay_alarm_.reset( | 74 delay_alarm_.reset( |
75 helper->CreateAlarm(new DelayAlarm(this))); | 75 helper->CreateAlarm(new DelayAlarm(this))); |
76 } | 76 } |
77 | 77 |
78 WriteResult PacketDroppingTestWriter::WritePacket( | 78 WriteResult PacketDroppingTestWriter::WritePacket( |
79 const char* buffer, size_t buf_len, | 79 const char* buffer, size_t buf_len, |
80 const net::IPAddressNumber& self_address, | 80 const net::IPAddressNumber& self_address, |
81 const net::IPEndPoint& peer_address, | 81 const net::IPEndPoint& peer_address, |
82 QuicBlockedWriterInterface* blocked_writer) { | 82 QuicBlockedWriterInterface* blocked_writer) { |
83 ReleaseOldPackets(); | 83 ReleaseOldPackets(); |
84 | 84 |
85 base::AutoLock locked(config_mutex_); | 85 base::AutoLock locked(config_mutex_); |
86 if (fake_packet_loss_percentage_ > 0 && | 86 if (fake_packet_loss_percentage_ > 0 && |
87 simple_random_.RandUint64() % 100 < | 87 simple_random_.RandUint64() % 100 < |
88 static_cast<uint64>(fake_packet_loss_percentage_)) { | 88 static_cast<uint64>(fake_packet_loss_percentage_)) { |
89 DLOG(INFO) << "Dropping packet."; | 89 DVLOG(0) << "Dropping packet."; |
90 return WriteResult(WRITE_STATUS_OK, buf_len); | 90 return WriteResult(WRITE_STATUS_OK, buf_len); |
91 } | 91 } |
92 if (fake_blocked_socket_percentage_ > 0 && | 92 if (fake_blocked_socket_percentage_ > 0 && |
93 simple_random_.RandUint64() % 100 < | 93 simple_random_.RandUint64() % 100 < |
94 static_cast<uint64>(fake_blocked_socket_percentage_)) { | 94 static_cast<uint64>(fake_blocked_socket_percentage_)) { |
95 DLOG(INFO) << "Blocking socket."; | 95 DVLOG(0) << "Blocking socket."; |
96 if (!write_unblocked_alarm_->IsSet()) { | 96 if (!write_unblocked_alarm_->IsSet()) { |
97 blocked_writer_ = blocked_writer; | 97 blocked_writer_ = blocked_writer; |
98 // Set the alarm for 1ms in the future. | 98 // Set the alarm for 1ms in the future. |
99 write_unblocked_alarm_->Set( | 99 write_unblocked_alarm_->Set( |
100 clock_->ApproximateNow().Add( | 100 clock_->ApproximateNow().Add( |
101 QuicTime::Delta::FromMilliseconds(1))); | 101 QuicTime::Delta::FromMilliseconds(1))); |
102 } | 102 } |
103 return WriteResult(WRITE_STATUS_BLOCKED, EAGAIN); | 103 return WriteResult(WRITE_STATUS_BLOCKED, EAGAIN); |
104 } | 104 } |
105 | 105 |
106 if (!fake_packet_delay_.IsZero() || !fake_bandwidth_.IsZero()) { | 106 if (!fake_packet_delay_.IsZero() || !fake_bandwidth_.IsZero()) { |
107 if (buffer_size_ > 0 && buf_len + cur_buffer_size_ > buffer_size_) { | 107 if (buffer_size_ > 0 && buf_len + cur_buffer_size_ > buffer_size_) { |
108 // Drop packets which do not fit into the buffer. | 108 // Drop packets which do not fit into the buffer. |
109 DLOG(INFO) << "Dropping packet because the buffer is full."; | 109 DVLOG(0) << "Dropping packet because the buffer is full."; |
110 return WriteResult(WRITE_STATUS_OK, buf_len); | 110 return WriteResult(WRITE_STATUS_OK, buf_len); |
111 } | 111 } |
112 | 112 |
113 // Queue it to be sent. | 113 // Queue it to be sent. |
114 QuicTime send_time = clock_->ApproximateNow().Add(fake_packet_delay_); | 114 QuicTime send_time = clock_->ApproximateNow().Add(fake_packet_delay_); |
115 if (!fake_bandwidth_.IsZero()) { | 115 if (!fake_bandwidth_.IsZero()) { |
116 // Calculate a time the bandwidth limit would impose. | 116 // Calculate a time the bandwidth limit would impose. |
117 QuicTime::Delta bandwidth_delay = QuicTime::Delta::FromMicroseconds( | 117 QuicTime::Delta bandwidth_delay = QuicTime::Delta::FromMicroseconds( |
118 (buf_len * kNumMicrosPerSecond) / | 118 (buf_len * kNumMicrosPerSecond) / |
119 fake_bandwidth_.ToBytesPerSecond()); | 119 fake_bandwidth_.ToBytesPerSecond()); |
(...skipping 24 matching lines...) Expand all Loading... |
144 QuicTime PacketDroppingTestWriter::ReleaseNextPacket() { | 144 QuicTime PacketDroppingTestWriter::ReleaseNextPacket() { |
145 if (delayed_packets_.empty()) { | 145 if (delayed_packets_.empty()) { |
146 return QuicTime::Zero(); | 146 return QuicTime::Zero(); |
147 } | 147 } |
148 base::AutoLock locked(config_mutex_); | 148 base::AutoLock locked(config_mutex_); |
149 DelayedPacketList::iterator iter = delayed_packets_.begin(); | 149 DelayedPacketList::iterator iter = delayed_packets_.begin(); |
150 // Determine if we should re-order. | 150 // Determine if we should re-order. |
151 if (delayed_packets_.size() > 1 && fake_packet_reorder_percentage_ > 0 && | 151 if (delayed_packets_.size() > 1 && fake_packet_reorder_percentage_ > 0 && |
152 simple_random_.RandUint64() % 100 < | 152 simple_random_.RandUint64() % 100 < |
153 static_cast<uint64>(fake_packet_reorder_percentage_)) { | 153 static_cast<uint64>(fake_packet_reorder_percentage_)) { |
154 DLOG(INFO) << "Reordering packets."; | 154 DVLOG(0) << "Reordering packets."; |
155 ++iter; | 155 ++iter; |
156 // Swap the send times when re-ordering packets. | 156 // Swap the send times when re-ordering packets. |
157 delayed_packets_.begin()->send_time = iter->send_time; | 157 delayed_packets_.begin()->send_time = iter->send_time; |
158 } | 158 } |
159 | 159 |
160 DLOG(INFO) << "Releasing packet. " << (delayed_packets_.size() - 1) | 160 DVLOG(0) << "Releasing packet. " << (delayed_packets_.size() - 1) |
161 << " remaining."; | 161 << " remaining."; |
162 // Grab the next one off the queue and send it. | 162 // Grab the next one off the queue and send it. |
163 writer()->WritePacket(iter->buffer.data(), iter->buffer.length(), | 163 writer()->WritePacket(iter->buffer.data(), iter->buffer.length(), |
164 iter->self_address, iter->peer_address, NULL); | 164 iter->self_address, iter->peer_address, NULL); |
165 DCHECK_GE(cur_buffer_size_, iter->buffer.length()); | 165 DCHECK_GE(cur_buffer_size_, iter->buffer.length()); |
166 cur_buffer_size_ -= iter->buffer.length(); | 166 cur_buffer_size_ -= iter->buffer.length(); |
167 delayed_packets_.erase(iter); | 167 delayed_packets_.erase(iter); |
168 | 168 |
169 // If there are others, find the time for the next to be sent. | 169 // If there are others, find the time for the next to be sent. |
170 if (delayed_packets_.empty()) { | 170 if (delayed_packets_.empty()) { |
(...skipping 23 matching lines...) Expand all Loading... |
194 self_address(self_address), | 194 self_address(self_address), |
195 peer_address(peer_address), | 195 peer_address(peer_address), |
196 send_time(send_time) { | 196 send_time(send_time) { |
197 } | 197 } |
198 | 198 |
199 PacketDroppingTestWriter::DelayedWrite::~DelayedWrite() {} | 199 PacketDroppingTestWriter::DelayedWrite::~DelayedWrite() {} |
200 | 200 |
201 } // namespace test | 201 } // namespace test |
202 } // namespace tools | 202 } // namespace tools |
203 } // namespace net | 203 } // namespace net |
OLD | NEW |