Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(80)

Side by Side Diff: net/quic/core/quic_framer.cc

Issue 2464683002: adds std:: to stl types (#049) (Closed)
Patch Set: Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 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/core/quic_framer.h" 5 #include "net/quic/core/quic_framer.h"
6 6
7 #include <cstdint> 7 #include <cstdint>
8 #include <memory> 8 #include <memory>
9 #include <vector> 9 #include <vector>
10 10
(...skipping 979 matching lines...) Expand 10 before | Expand all | Expand 10 after
990 const QuicAckFrame& frame) { 990 const QuicAckFrame& frame) {
991 AckFrameInfo ack_info; 991 AckFrameInfo ack_info;
992 if (frame.packets.Empty()) { 992 if (frame.packets.Empty()) {
993 return ack_info; 993 return ack_info;
994 } 994 }
995 DCHECK_GE(frame.largest_observed, frame.packets.Max()); 995 DCHECK_GE(frame.largest_observed, frame.packets.Max());
996 QuicPacketNumber last_largest_missing = 0; 996 QuicPacketNumber last_largest_missing = 0;
997 for (const Interval<QuicPacketNumber>& interval : frame.packets) { 997 for (const Interval<QuicPacketNumber>& interval : frame.packets) {
998 for (QuicPacketNumber interval_start = interval.min(); 998 for (QuicPacketNumber interval_start = interval.min();
999 interval_start < interval.max(); 999 interval_start < interval.max();
1000 interval_start += (1ull + numeric_limits<uint8_t>::max())) { 1000 interval_start += (1ull + std::numeric_limits<uint8_t>::max())) {
1001 uint8_t cur_range_length = 1001 uint8_t cur_range_length =
1002 interval.max() - interval_start > numeric_limits<uint8_t>::max() 1002 interval.max() - interval_start > std::numeric_limits<uint8_t>::max()
1003 ? numeric_limits<uint8_t>::max() 1003 ? std::numeric_limits<uint8_t>::max()
1004 : (interval.max() - interval_start) - 1; 1004 : (interval.max() - interval_start) - 1;
1005 ack_info.nack_ranges[interval_start] = cur_range_length; 1005 ack_info.nack_ranges[interval_start] = cur_range_length;
1006 } 1006 }
1007 ack_info.max_delta = 1007 ack_info.max_delta =
1008 max(ack_info.max_delta, last_largest_missing == 0 1008 max(ack_info.max_delta, last_largest_missing == 0
1009 ? QuicPacketNumber{0} 1009 ? QuicPacketNumber{0}
1010 : (interval.min() - last_largest_missing)); 1010 : (interval.min() - last_largest_missing));
1011 last_largest_missing = interval.max() - 1; 1011 last_largest_missing = interval.max() - 1;
1012 } 1012 }
1013 // Include the range to the largest observed. 1013 // Include the range to the largest observed.
(...skipping 13 matching lines...) Expand all
1027 // encoding, so skip it. 1027 // encoding, so skip it.
1028 new_ack_info.first_block_length = frame.packets.LastIntervalLength(); 1028 new_ack_info.first_block_length = frame.packets.LastIntervalLength();
1029 auto itr = frame.packets.rbegin(); 1029 auto itr = frame.packets.rbegin();
1030 QuicPacketNumber previous_start = itr->min(); 1030 QuicPacketNumber previous_start = itr->min();
1031 new_ack_info.max_block_length = itr->Length(); 1031 new_ack_info.max_block_length = itr->Length();
1032 ++itr; 1032 ++itr;
1033 1033
1034 // Don't do any more work after getting information for 256 ACK blocks; any 1034 // Don't do any more work after getting information for 256 ACK blocks; any
1035 // more can't be encoded anyway. 1035 // more can't be encoded anyway.
1036 for (; itr != frame.packets.rend() && 1036 for (; itr != frame.packets.rend() &&
1037 new_ack_info.num_ack_blocks < numeric_limits<uint8_t>::max(); 1037 new_ack_info.num_ack_blocks < std::numeric_limits<uint8_t>::max();
1038 previous_start = itr->min(), ++itr) { 1038 previous_start = itr->min(), ++itr) {
1039 const auto& interval = *itr; 1039 const auto& interval = *itr;
1040 const QuicPacketNumber total_gap = previous_start - interval.max(); 1040 const QuicPacketNumber total_gap = previous_start - interval.max();
1041 new_ack_info.num_ack_blocks += 1041 new_ack_info.num_ack_blocks +=
1042 (total_gap + numeric_limits<uint8_t>::max() - 1) / 1042 (total_gap + std::numeric_limits<uint8_t>::max() - 1) /
1043 numeric_limits<uint8_t>::max(); 1043 std::numeric_limits<uint8_t>::max();
1044 new_ack_info.max_block_length = 1044 new_ack_info.max_block_length =
1045 max(new_ack_info.max_block_length, interval.Length()); 1045 max(new_ack_info.max_block_length, interval.Length());
1046 } 1046 }
1047 return new_ack_info; 1047 return new_ack_info;
1048 } 1048 }
1049 1049
1050 bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader, 1050 bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
1051 QuicPacketHeader* header) { 1051 QuicPacketHeader* header) {
1052 header->path_id = kDefaultPathId; 1052 header->path_id = kDefaultPathId;
1053 if (header->public_header.multipath_flag && 1053 if (header->public_header.multipath_flag &&
(...skipping 1024 matching lines...) Expand 10 before | Expand all | Expand 10 after
2078 QuicDataWriter* writer) { 2078 QuicDataWriter* writer) {
2079 if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) { 2079 if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) {
2080 QUIC_BUG << "Writing stream id size failed."; 2080 QUIC_BUG << "Writing stream id size failed.";
2081 return false; 2081 return false;
2082 } 2082 }
2083 if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) { 2083 if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) {
2084 QUIC_BUG << "Writing offset size failed."; 2084 QUIC_BUG << "Writing offset size failed.";
2085 return false; 2085 return false;
2086 } 2086 }
2087 if (!no_stream_frame_length) { 2087 if (!no_stream_frame_length) {
2088 if ((frame.data_length > numeric_limits<uint16_t>::max()) || 2088 if ((frame.data_length > std::numeric_limits<uint16_t>::max()) ||
2089 !writer->WriteUInt16(static_cast<uint16_t>(frame.data_length))) { 2089 !writer->WriteUInt16(static_cast<uint16_t>(frame.data_length))) {
2090 QUIC_BUG << "Writing stream frame length failed"; 2090 QUIC_BUG << "Writing stream frame length failed";
2091 return false; 2091 return false;
2092 } 2092 }
2093 } 2093 }
2094 2094
2095 if (!writer->WriteBytes(frame.data_buffer, frame.data_length)) { 2095 if (!writer->WriteBytes(frame.data_buffer, frame.data_length)) {
2096 QUIC_BUG << "Writing frame data failed."; 2096 QUIC_BUG << "Writing frame data failed.";
2097 return false; 2097 return false;
2098 } 2098 }
(...skipping 190 matching lines...) Expand 10 before | Expand all | Expand 10 after
2289 } 2289 }
2290 if (!writer->WriteUFloat16(ack_delay_time_us)) { 2290 if (!writer->WriteUFloat16(ack_delay_time_us)) {
2291 return false; 2291 return false;
2292 } 2292 }
2293 2293
2294 size_t max_num_ack_blocks = available_timestamp_and_ack_block_bytes / 2294 size_t max_num_ack_blocks = available_timestamp_and_ack_block_bytes /
2295 (ack_block_length + PACKET_1BYTE_PACKET_NUMBER); 2295 (ack_block_length + PACKET_1BYTE_PACKET_NUMBER);
2296 2296
2297 // Number of ack blocks. 2297 // Number of ack blocks.
2298 size_t num_ack_blocks = min(new_ack_info.num_ack_blocks, max_num_ack_blocks); 2298 size_t num_ack_blocks = min(new_ack_info.num_ack_blocks, max_num_ack_blocks);
2299 if (num_ack_blocks > numeric_limits<uint8_t>::max()) { 2299 if (num_ack_blocks > std::numeric_limits<uint8_t>::max()) {
2300 num_ack_blocks = numeric_limits<uint8_t>::max(); 2300 num_ack_blocks = std::numeric_limits<uint8_t>::max();
2301 } 2301 }
2302 2302
2303 if (num_ack_blocks > 0) { 2303 if (num_ack_blocks > 0) {
2304 if (!writer->WriteBytes(&num_ack_blocks, 1)) { 2304 if (!writer->WriteBytes(&num_ack_blocks, 1)) {
2305 return false; 2305 return false;
2306 } 2306 }
2307 } 2307 }
2308 2308
2309 // First ack block length. 2309 // First ack block length.
2310 if (!AppendPacketSequenceNumber(ack_block_length, 2310 if (!AppendPacketSequenceNumber(ack_block_length,
(...skipping 15 matching lines...) Expand all
2326 auto itr = frame.packets.rbegin(); 2326 auto itr = frame.packets.rbegin();
2327 QuicPacketNumber previous_start = itr->min(); 2327 QuicPacketNumber previous_start = itr->min();
2328 ++itr; 2328 ++itr;
2329 2329
2330 for (; 2330 for (;
2331 itr != frame.packets.rend() && num_ack_blocks_written < num_ack_blocks; 2331 itr != frame.packets.rend() && num_ack_blocks_written < num_ack_blocks;
2332 previous_start = itr->min(), ++itr) { 2332 previous_start = itr->min(), ++itr) {
2333 const auto& interval = *itr; 2333 const auto& interval = *itr;
2334 const QuicPacketNumber total_gap = previous_start - interval.max(); 2334 const QuicPacketNumber total_gap = previous_start - interval.max();
2335 const size_t num_encoded_gaps = 2335 const size_t num_encoded_gaps =
2336 (total_gap + numeric_limits<uint8_t>::max() - 1) / 2336 (total_gap + std::numeric_limits<uint8_t>::max() - 1) /
2337 numeric_limits<uint8_t>::max(); 2337 std::numeric_limits<uint8_t>::max();
2338 DCHECK_GT(num_encoded_gaps, 0u); 2338 DCHECK_GT(num_encoded_gaps, 0u);
2339 2339
2340 // Append empty ACK blocks because the gap is longer than a single gap. 2340 // Append empty ACK blocks because the gap is longer than a single gap.
2341 for (size_t i = 1; 2341 for (size_t i = 1;
2342 i < num_encoded_gaps && num_ack_blocks_written < num_ack_blocks; 2342 i < num_encoded_gaps && num_ack_blocks_written < num_ack_blocks;
2343 ++i) { 2343 ++i) {
2344 if (!AppendAckBlock(numeric_limits<uint8_t>::max(), ack_block_length, 0, 2344 if (!AppendAckBlock(std::numeric_limits<uint8_t>::max(),
2345 writer)) { 2345 ack_block_length, 0, writer)) {
2346 return false; 2346 return false;
2347 } 2347 }
2348 ++num_ack_blocks_written; 2348 ++num_ack_blocks_written;
2349 } 2349 }
2350 if (num_ack_blocks_written >= num_ack_blocks) { 2350 if (num_ack_blocks_written >= num_ack_blocks) {
2351 if (PREDICT_FALSE(num_ack_blocks_written != num_ack_blocks)) { 2351 if (PREDICT_FALSE(num_ack_blocks_written != num_ack_blocks)) {
2352 QUIC_BUG << "Wrote " << num_ack_blocks_written 2352 QUIC_BUG << "Wrote " << num_ack_blocks_written
2353 << ", expected to write " << num_ack_blocks; 2353 << ", expected to write " << num_ack_blocks;
2354 } 2354 }
2355 break; 2355 break;
2356 } 2356 }
2357 2357
2358 const uint8_t last_gap = 2358 const uint8_t last_gap =
2359 total_gap - (num_encoded_gaps - 1) * numeric_limits<uint8_t>::max(); 2359 total_gap -
2360 (num_encoded_gaps - 1) * std::numeric_limits<uint8_t>::max();
2360 // Append the final ACK block with a non-empty size. 2361 // Append the final ACK block with a non-empty size.
2361 if (!AppendAckBlock(last_gap, ack_block_length, interval.Length(), 2362 if (!AppendAckBlock(last_gap, ack_block_length, interval.Length(),
2362 writer)) { 2363 writer)) {
2363 return false; 2364 return false;
2364 } 2365 }
2365 ++num_ack_blocks_written; 2366 ++num_ack_blocks_written;
2366 } 2367 }
2367 DCHECK_EQ(num_ack_blocks, num_ack_blocks_written); 2368 DCHECK_EQ(num_ack_blocks, num_ack_blocks_written);
2368 } 2369 }
2369 2370
(...skipping 10 matching lines...) Expand all
2380 if (!writer->WriteBytes(&num_received_packets, 1)) { 2381 if (!writer->WriteBytes(&num_received_packets, 1)) {
2381 return false; 2382 return false;
2382 } 2383 }
2383 } 2384 }
2384 2385
2385 return true; 2386 return true;
2386 } 2387 }
2387 2388
2388 bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame& frame, 2389 bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame& frame,
2389 QuicDataWriter* writer) { 2390 QuicDataWriter* writer) {
2390 DCHECK_GE(numeric_limits<uint8_t>::max(), frame.received_packet_times.size()); 2391 DCHECK_GE(std::numeric_limits<uint8_t>::max(),
2392 frame.received_packet_times.size());
2391 // num_received_packets is only 1 byte. 2393 // num_received_packets is only 1 byte.
2392 if (frame.received_packet_times.size() > numeric_limits<uint8_t>::max()) { 2394 if (frame.received_packet_times.size() >
2395 std::numeric_limits<uint8_t>::max()) {
2393 return false; 2396 return false;
2394 } 2397 }
2395 2398
2396 uint8_t num_received_packets = frame.received_packet_times.size(); 2399 uint8_t num_received_packets = frame.received_packet_times.size();
2397 if (!writer->WriteBytes(&num_received_packets, 1)) { 2400 if (!writer->WriteBytes(&num_received_packets, 1)) {
2398 return false; 2401 return false;
2399 } 2402 }
2400 if (num_received_packets == 0) { 2403 if (num_received_packets == 0) {
2401 return true; 2404 return true;
2402 } 2405 }
2403 2406
2404 PacketTimeVector::const_iterator it = frame.received_packet_times.begin(); 2407 PacketTimeVector::const_iterator it = frame.received_packet_times.begin();
2405 QuicPacketNumber packet_number = it->first; 2408 QuicPacketNumber packet_number = it->first;
2406 QuicPacketNumber delta_from_largest_observed = 2409 QuicPacketNumber delta_from_largest_observed =
2407 frame.largest_observed - packet_number; 2410 frame.largest_observed - packet_number;
2408 2411
2409 DCHECK_GE(numeric_limits<uint8_t>::max(), delta_from_largest_observed); 2412 DCHECK_GE(std::numeric_limits<uint8_t>::max(), delta_from_largest_observed);
2410 if (delta_from_largest_observed > numeric_limits<uint8_t>::max()) { 2413 if (delta_from_largest_observed > std::numeric_limits<uint8_t>::max()) {
2411 return false; 2414 return false;
2412 } 2415 }
2413 2416
2414 if (!writer->WriteUInt8(delta_from_largest_observed & 2417 if (!writer->WriteUInt8(delta_from_largest_observed &
2415 k1ByteSequenceNumberMask)) { 2418 k1ByteSequenceNumberMask)) {
2416 return false; 2419 return false;
2417 } 2420 }
2418 2421
2419 // Use the lowest 4 bytes of the time delta from the creation_time_. 2422 // Use the lowest 4 bytes of the time delta from the creation_time_.
2420 const uint64_t time_epoch_delta_us = UINT64_C(1) << 32; 2423 const uint64_t time_epoch_delta_us = UINT64_C(1) << 32;
2421 uint32_t time_delta_us = 2424 uint32_t time_delta_us =
2422 static_cast<uint32_t>((it->second - creation_time_).ToMicroseconds() & 2425 static_cast<uint32_t>((it->second - creation_time_).ToMicroseconds() &
2423 (time_epoch_delta_us - 1)); 2426 (time_epoch_delta_us - 1));
2424 if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) { 2427 if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) {
2425 return false; 2428 return false;
2426 } 2429 }
2427 2430
2428 QuicTime prev_time = it->second; 2431 QuicTime prev_time = it->second;
2429 2432
2430 for (++it; it != frame.received_packet_times.end(); ++it) { 2433 for (++it; it != frame.received_packet_times.end(); ++it) {
2431 packet_number = it->first; 2434 packet_number = it->first;
2432 delta_from_largest_observed = frame.largest_observed - packet_number; 2435 delta_from_largest_observed = frame.largest_observed - packet_number;
2433 2436
2434 if (delta_from_largest_observed > numeric_limits<uint8_t>::max()) { 2437 if (delta_from_largest_observed > std::numeric_limits<uint8_t>::max()) {
2435 return false; 2438 return false;
2436 } 2439 }
2437 2440
2438 if (!writer->WriteUInt8(delta_from_largest_observed & 2441 if (!writer->WriteUInt8(delta_from_largest_observed &
2439 k1ByteSequenceNumberMask)) { 2442 k1ByteSequenceNumberMask)) {
2440 return false; 2443 return false;
2441 } 2444 }
2442 2445
2443 uint64_t frame_time_delta_us = (it->second - prev_time).ToMicroseconds(); 2446 uint64_t frame_time_delta_us = (it->second - prev_time).ToMicroseconds();
2444 prev_time = it->second; 2447 prev_time = it->second;
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after
2561 2564
2562 bool QuicFramer::RaiseError(QuicErrorCode error) { 2565 bool QuicFramer::RaiseError(QuicErrorCode error) {
2563 DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error) 2566 DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
2564 << " detail: " << detailed_error_; 2567 << " detail: " << detailed_error_;
2565 set_error(error); 2568 set_error(error);
2566 visitor_->OnError(this); 2569 visitor_->OnError(this);
2567 return false; 2570 return false;
2568 } 2571 }
2569 2572
2570 } // namespace net 2573 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698