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/quic/quic_received_packet_manager.h" | 5 #include "net/quic/quic_received_packet_manager.h" |
6 | 6 |
| 7 #include <limits> |
| 8 #include <utility> |
| 9 |
7 #include "base/logging.h" | 10 #include "base/logging.h" |
8 #include "base/stl_util.h" | 11 #include "base/stl_util.h" |
9 #include "net/base/linked_hash_map.h" | 12 #include "net/base/linked_hash_map.h" |
10 #include "net/quic/crypto/crypto_protocol.h" | 13 #include "net/quic/crypto/crypto_protocol.h" |
11 #include "net/quic/quic_connection_stats.h" | 14 #include "net/quic/quic_connection_stats.h" |
12 | 15 |
13 using std::make_pair; | 16 using std::make_pair; |
14 using std::max; | 17 using std::max; |
15 using std::min; | 18 using std::min; |
16 using std::numeric_limits; | 19 using std::numeric_limits; |
(...skipping 177 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
194 bool QuicReceivedPacketManager::IsMissing( | 197 bool QuicReceivedPacketManager::IsMissing( |
195 QuicPacketSequenceNumber sequence_number) { | 198 QuicPacketSequenceNumber sequence_number) { |
196 return ContainsKey(ack_frame_.missing_packets, sequence_number); | 199 return ContainsKey(ack_frame_.missing_packets, sequence_number); |
197 } | 200 } |
198 | 201 |
199 bool QuicReceivedPacketManager::IsAwaitingPacket( | 202 bool QuicReceivedPacketManager::IsAwaitingPacket( |
200 QuicPacketSequenceNumber sequence_number) { | 203 QuicPacketSequenceNumber sequence_number) { |
201 return ::net::IsAwaitingPacket(ack_frame_, sequence_number); | 204 return ::net::IsAwaitingPacket(ack_frame_, sequence_number); |
202 } | 205 } |
203 | 206 |
| 207 namespace { |
| 208 struct isTooLarge { |
| 209 explicit isTooLarge(QuicPacketSequenceNumber n) : largest_observed_(n) {} |
| 210 QuicPacketSequenceNumber largest_observed_; |
| 211 |
| 212 // Return true if the packet in p is too different from largest_observed_ |
| 213 // to express. |
| 214 bool operator() ( |
| 215 const std::pair<QuicPacketSequenceNumber, QuicTime>& p) const { |
| 216 return largest_observed_ - p.first >= numeric_limits<uint8>::max(); |
| 217 } |
| 218 }; |
| 219 } // namespace |
| 220 |
204 void QuicReceivedPacketManager::UpdateReceivedPacketInfo( | 221 void QuicReceivedPacketManager::UpdateReceivedPacketInfo( |
205 QuicAckFrame* ack_frame, QuicTime approximate_now) { | 222 QuicAckFrame* ack_frame, QuicTime approximate_now) { |
206 *ack_frame = ack_frame_; | 223 *ack_frame = ack_frame_; |
207 ack_frame->entropy_hash = EntropyHash(ack_frame_.largest_observed); | 224 ack_frame->entropy_hash = EntropyHash(ack_frame_.largest_observed); |
208 | 225 |
209 if (time_largest_observed_ == QuicTime::Zero()) { | 226 if (time_largest_observed_ == QuicTime::Zero()) { |
210 // We have received no packets. | 227 // We have received no packets. |
211 ack_frame->delta_time_largest_observed = QuicTime::Delta::Infinite(); | 228 ack_frame->delta_time_largest_observed = QuicTime::Delta::Infinite(); |
212 return; | 229 return; |
213 } | 230 } |
214 | 231 |
215 if (approximate_now < time_largest_observed_) { | 232 if (approximate_now < time_largest_observed_) { |
216 // Approximate now may well be "in the past". | 233 // Approximate now may well be "in the past". |
217 ack_frame->delta_time_largest_observed = QuicTime::Delta::Zero(); | 234 ack_frame->delta_time_largest_observed = QuicTime::Delta::Zero(); |
218 return; | 235 return; |
219 } | 236 } |
220 | 237 |
221 ack_frame->delta_time_largest_observed = | 238 ack_frame->delta_time_largest_observed = |
222 approximate_now.Subtract(time_largest_observed_); | 239 approximate_now.Subtract(time_largest_observed_); |
223 | 240 |
224 // Remove all packets that are too far from largest_observed to express. | 241 // Remove all packets that are too far from largest_observed to express. |
225 received_packet_times_.remove_if( | 242 received_packet_times_.remove_if(isTooLarge(ack_frame_.largest_observed)); |
226 [this] (std::pair<QuicPacketSequenceNumber, QuicTime> p) | |
227 { return ack_frame_.largest_observed - p.first >= | |
228 numeric_limits<uint8>::max();}); | |
229 | 243 |
230 ack_frame->received_packet_times = received_packet_times_; | 244 ack_frame->received_packet_times = received_packet_times_; |
231 received_packet_times_.clear(); | 245 received_packet_times_.clear(); |
232 } | 246 } |
233 | 247 |
234 bool QuicReceivedPacketManager::GenerateCongestionFeedback( | 248 bool QuicReceivedPacketManager::GenerateCongestionFeedback( |
235 QuicCongestionFeedbackFrame* feedback) { | 249 QuicCongestionFeedbackFrame* feedback) { |
236 return receive_algorithm_->GenerateCongestionFeedback(feedback); | 250 return receive_algorithm_->GenerateCongestionFeedback(feedback); |
237 } | 251 } |
238 | 252 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
273 peer_least_packet_awaiting_ack_); | 287 peer_least_packet_awaiting_ack_); |
274 } | 288 } |
275 | 289 |
276 bool QuicReceivedPacketManager::HasNewMissingPackets() { | 290 bool QuicReceivedPacketManager::HasNewMissingPackets() { |
277 return !ack_frame_.missing_packets.empty() && | 291 return !ack_frame_.missing_packets.empty() && |
278 (ack_frame_.largest_observed - | 292 (ack_frame_.largest_observed - |
279 *ack_frame_.missing_packets.rbegin()) <= kMaxPacketsAfterNewMissing; | 293 *ack_frame_.missing_packets.rbegin()) <= kMaxPacketsAfterNewMissing; |
280 } | 294 } |
281 | 295 |
282 } // namespace net | 296 } // namespace net |
OLD | NEW |