| Index: net/quic/quic_framer.cc
|
| diff --git a/net/quic/quic_framer.cc b/net/quic/quic_framer.cc
|
| index 09cd43df6372fb98e62d66b0147d51e603bc0aef..fea3b3847f5c32e0eb523b79f7c08ad1e8ab3119 100644
|
| --- a/net/quic/quic_framer.cc
|
| +++ b/net/quic/quic_framer.cc
|
| @@ -132,8 +132,9 @@ QuicSequenceNumberLength ReadSequenceNumberLength(uint8 flags) {
|
| }
|
| }
|
|
|
| -bool CanTruncate(
|
| - QuicVersion version, const QuicFrame& frame, size_t free_bytes) {
|
| +bool CanTruncate(QuicVersion version,
|
| + const QuicFrame& frame,
|
| + size_t free_bytes) {
|
| if ((frame.type == ACK_FRAME || frame.type == CONNECTION_CLOSE_FRAME) &&
|
| free_bytes >=
|
| QuicFramer::GetMinAckFrameSize(version,
|
| @@ -174,11 +175,11 @@ QuicFramer::QuicFramer(const QuicVersionVector& supported_versions,
|
| DCHECK(!supported_versions.empty());
|
| quic_version_ = supported_versions_[0];
|
| decrypter_.reset(QuicDecrypter::Create(kNULL));
|
| - encrypter_[ENCRYPTION_NONE].reset(
|
| - QuicEncrypter::Create(kNULL));
|
| + encrypter_[ENCRYPTION_NONE].reset(QuicEncrypter::Create(kNULL));
|
| }
|
|
|
| -QuicFramer::~QuicFramer() {}
|
| +QuicFramer::~QuicFramer() {
|
| +}
|
|
|
| // static
|
| size_t QuicFramer::GetMinStreamFrameSize(QuicVersion version,
|
| @@ -186,11 +187,11 @@ size_t QuicFramer::GetMinStreamFrameSize(QuicVersion version,
|
| QuicStreamOffset offset,
|
| bool last_frame_in_packet,
|
| InFecGroup is_in_fec_group) {
|
| - bool no_stream_frame_length = last_frame_in_packet &&
|
| - is_in_fec_group == NOT_IN_FEC_GROUP;
|
| + bool no_stream_frame_length =
|
| + last_frame_in_packet && is_in_fec_group == NOT_IN_FEC_GROUP;
|
| return kQuicFrameTypeSize + GetStreamIdSize(stream_id) +
|
| - GetStreamOffsetSize(offset) +
|
| - (no_stream_frame_length ? 0 : kQuicStreamPayloadLengthSize);
|
| + GetStreamOffsetSize(offset) +
|
| + (no_stream_frame_length ? 0 : kQuicStreamPayloadLengthSize);
|
| }
|
|
|
| // static
|
| @@ -198,23 +199,21 @@ size_t QuicFramer::GetMinAckFrameSize(
|
| QuicVersion version,
|
| QuicSequenceNumberLength sequence_number_length,
|
| QuicSequenceNumberLength largest_observed_length) {
|
| - return kQuicFrameTypeSize + kQuicEntropyHashSize +
|
| - sequence_number_length + kQuicEntropyHashSize +
|
| - largest_observed_length + kQuicDeltaTimeLargestObservedSize;
|
| + return kQuicFrameTypeSize + kQuicEntropyHashSize + sequence_number_length +
|
| + kQuicEntropyHashSize + largest_observed_length +
|
| + kQuicDeltaTimeLargestObservedSize;
|
| }
|
|
|
| // static
|
| size_t QuicFramer::GetStopWaitingFrameSize(
|
| QuicSequenceNumberLength sequence_number_length) {
|
| - return kQuicFrameTypeSize + kQuicEntropyHashSize +
|
| - sequence_number_length;
|
| + return kQuicFrameTypeSize + kQuicEntropyHashSize + sequence_number_length;
|
| }
|
|
|
| // static
|
| size_t QuicFramer::GetMinRstStreamFrameSize(QuicVersion quic_version) {
|
| - return kQuicFrameTypeSize + kQuicMaxStreamIdSize +
|
| - kQuicMaxStreamOffsetSize + kQuicErrorCodeSize +
|
| - kQuicErrorDetailsLengthSize;
|
| + return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize +
|
| + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize;
|
| }
|
|
|
| // static
|
| @@ -225,7 +224,7 @@ size_t QuicFramer::GetMinConnectionCloseFrameSize() {
|
| // static
|
| size_t QuicFramer::GetMinGoAwayFrameSize() {
|
| return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
|
| - kQuicMaxStreamIdSize;
|
| + kQuicMaxStreamIdSize;
|
| }
|
|
|
| // static
|
| @@ -272,7 +271,7 @@ size_t QuicFramer::GetStreamOffsetSize(QuicStreamOffset offset) {
|
| // static
|
| size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
|
| return kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID +
|
| - number_versions * kQuicVersionSize;
|
| + number_versions * kQuicVersionSize;
|
| }
|
|
|
| bool QuicFramer::IsSupportedVersion(const QuicVersion version) const {
|
| @@ -295,9 +294,8 @@ size_t QuicFramer::GetSerializedFrameLength(
|
| // PADDING implies end of packet.
|
| return free_bytes;
|
| }
|
| - size_t frame_len =
|
| - ComputeFrameLength(frame, last_frame, is_in_fec_group,
|
| - sequence_number_length);
|
| + size_t frame_len = ComputeFrameLength(
|
| + frame, last_frame, is_in_fec_group, sequence_number_length);
|
| if (frame_len > free_bytes) {
|
| // Only truncate the first frame in a packet, so if subsequent ones go
|
| // over, stop including more frames.
|
| @@ -316,9 +314,11 @@ size_t QuicFramer::GetSerializedFrameLength(
|
| return frame_len;
|
| }
|
|
|
| -QuicFramer::AckFrameInfo::AckFrameInfo() : max_delta(0) { }
|
| +QuicFramer::AckFrameInfo::AckFrameInfo() : max_delta(0) {
|
| +}
|
|
|
| -QuicFramer::AckFrameInfo::~AckFrameInfo() { }
|
| +QuicFramer::AckFrameInfo::~AckFrameInfo() {
|
| +}
|
|
|
| QuicPacketEntropyHash QuicFramer::GetPacketEntropyHash(
|
| const QuicPacketHeader& header) const {
|
| @@ -335,20 +335,22 @@ SerializedPacket QuicFramer::BuildUnsizedDataPacket(
|
| DCHECK_LE(packet_size, max_plaintext_size);
|
| bool first_frame = i == 0;
|
| bool last_frame = i == frames.size() - 1;
|
| - const size_t frame_size = GetSerializedFrameLength(
|
| - frames[i], max_plaintext_size - packet_size, first_frame, last_frame,
|
| - header.is_in_fec_group,
|
| - header.public_header.sequence_number_length);
|
| + const size_t frame_size =
|
| + GetSerializedFrameLength(frames[i],
|
| + max_plaintext_size - packet_size,
|
| + first_frame,
|
| + last_frame,
|
| + header.is_in_fec_group,
|
| + header.public_header.sequence_number_length);
|
| DCHECK(frame_size);
|
| packet_size += frame_size;
|
| }
|
| return BuildDataPacket(header, frames, packet_size);
|
| }
|
|
|
| -SerializedPacket QuicFramer::BuildDataPacket(
|
| - const QuicPacketHeader& header,
|
| - const QuicFrames& frames,
|
| - size_t packet_size) {
|
| +SerializedPacket QuicFramer::BuildDataPacket(const QuicPacketHeader& header,
|
| + const QuicFrames& frames,
|
| + size_t packet_size) {
|
| QuicDataWriter writer(packet_size);
|
| const SerializedPacket kNoPacket(
|
| 0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
|
| @@ -375,21 +377,20 @@ SerializedPacket QuicFramer::BuildDataPacket(
|
| break;
|
| case STREAM_FRAME:
|
| if (!AppendStreamFrame(
|
| - *frame.stream_frame, no_stream_frame_length, &writer)) {
|
| + *frame.stream_frame, no_stream_frame_length, &writer)) {
|
| LOG(DFATAL) << "AppendStreamFrame failed";
|
| return kNoPacket;
|
| }
|
| break;
|
| case ACK_FRAME:
|
| - if (!AppendAckFrameAndTypeByte(
|
| - header, *frame.ack_frame, &writer)) {
|
| + if (!AppendAckFrameAndTypeByte(header, *frame.ack_frame, &writer)) {
|
| LOG(DFATAL) << "AppendAckFrameAndTypeByte failed";
|
| return kNoPacket;
|
| }
|
| break;
|
| case CONGESTION_FEEDBACK_FRAME:
|
| - if (!AppendCongestionFeedbackFrame(
|
| - *frame.congestion_feedback_frame, &writer)) {
|
| + if (!AppendCongestionFeedbackFrame(*frame.congestion_feedback_frame,
|
| + &writer)) {
|
| LOG(DFATAL) << "AppendCongestionFeedbackFrame failed";
|
| return kNoPacket;
|
| }
|
| @@ -421,8 +422,8 @@ SerializedPacket QuicFramer::BuildDataPacket(
|
| }
|
| break;
|
| case CONNECTION_CLOSE_FRAME:
|
| - if (!AppendConnectionCloseFrame(
|
| - *frame.connection_close_frame, &writer)) {
|
| + if (!AppendConnectionCloseFrame(*frame.connection_close_frame,
|
| + &writer)) {
|
| LOG(DFATAL) << "AppendConnectionCloseFrame failed";
|
| return kNoPacket;
|
| }
|
| @@ -457,10 +458,13 @@ SerializedPacket QuicFramer::BuildDataPacket(
|
| // Less than or equal because truncated acks end up with max_plaintex_size
|
| // length, even though they're typically slightly shorter.
|
| DCHECK_LE(len, packet_size);
|
| - QuicPacket* packet = QuicPacket::NewDataPacket(
|
| - writer.take(), len, true, header.public_header.connection_id_length,
|
| - header.public_header.version_flag,
|
| - header.public_header.sequence_number_length);
|
| + QuicPacket* packet =
|
| + QuicPacket::NewDataPacket(writer.take(),
|
| + len,
|
| + true,
|
| + header.public_header.connection_id_length,
|
| + header.public_header.version_flag,
|
| + header.public_header.sequence_number_length);
|
|
|
| if (fec_builder_) {
|
| fec_builder_->OnBuiltFecProtectedPayload(header,
|
| @@ -468,8 +472,10 @@ SerializedPacket QuicFramer::BuildDataPacket(
|
| }
|
|
|
| return SerializedPacket(header.packet_sequence_number,
|
| - header.public_header.sequence_number_length, packet,
|
| - GetPacketEntropyHash(header), NULL);
|
| + header.public_header.sequence_number_length,
|
| + packet,
|
| + GetPacketEntropyHash(header),
|
| + NULL);
|
| }
|
|
|
| SerializedPacket QuicFramer::BuildFecPacket(const QuicPacketHeader& header,
|
| @@ -495,11 +501,14 @@ SerializedPacket QuicFramer::BuildFecPacket(const QuicPacketHeader& header,
|
| return SerializedPacket(
|
| header.packet_sequence_number,
|
| header.public_header.sequence_number_length,
|
| - QuicPacket::NewFecPacket(writer.take(), len, true,
|
| + QuicPacket::NewFecPacket(writer.take(),
|
| + len,
|
| + true,
|
| header.public_header.connection_id_length,
|
| header.public_header.version_flag,
|
| header.public_header.sequence_number_length),
|
| - GetPacketEntropyHash(header), NULL);
|
| + GetPacketEntropyHash(header),
|
| + NULL);
|
| }
|
|
|
| // static
|
| @@ -627,9 +636,8 @@ bool QuicFramer::ProcessVersionNegotiationPacket(
|
| return true;
|
| }
|
|
|
| -bool QuicFramer::ProcessDataPacket(
|
| - const QuicPacketPublicHeader& public_header,
|
| - const QuicEncryptedPacket& packet) {
|
| +bool QuicFramer::ProcessDataPacket(const QuicPacketPublicHeader& public_header,
|
| + const QuicEncryptedPacket& packet) {
|
| QuicPacketHeader header(public_header);
|
| if (!ProcessPacketHeader(&header, packet)) {
|
| DLOG(WARNING) << "Unable to process data packet header.";
|
| @@ -699,8 +707,8 @@ bool QuicFramer::ProcessPublicResetPacket(
|
| if (reset->GetStringPiece(kCADR, &address)) {
|
| QuicSocketAddressCoder address_coder;
|
| if (address_coder.Decode(address.data(), address.length())) {
|
| - packet.client_address = IPEndPoint(address_coder.ip(),
|
| - address_coder.port());
|
| + packet.client_address =
|
| + IPEndPoint(address_coder.ip(), address_coder.port());
|
| }
|
| }
|
|
|
| @@ -751,38 +759,38 @@ bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header,
|
|
|
| public_flags |=
|
| GetSequenceNumberFlags(header.public_header.sequence_number_length)
|
| - << kPublicHeaderSequenceNumberShift;
|
| + << kPublicHeaderSequenceNumberShift;
|
|
|
| switch (header.public_header.connection_id_length) {
|
| case PACKET_0BYTE_CONNECTION_ID:
|
| - if (!writer->WriteUInt8(
|
| - public_flags | PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) {
|
| + if (!writer->WriteUInt8(public_flags |
|
| + PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) {
|
| return false;
|
| }
|
| break;
|
| case PACKET_1BYTE_CONNECTION_ID:
|
| - if (!writer->WriteUInt8(
|
| - public_flags | PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID)) {
|
| - return false;
|
| + if (!writer->WriteUInt8(public_flags |
|
| + PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID)) {
|
| + return false;
|
| }
|
| - if (!writer->WriteUInt8(
|
| - header.public_header.connection_id & k1ByteConnectionIdMask)) {
|
| + if (!writer->WriteUInt8(header.public_header.connection_id &
|
| + k1ByteConnectionIdMask)) {
|
| return false;
|
| }
|
| break;
|
| case PACKET_4BYTE_CONNECTION_ID:
|
| - if (!writer->WriteUInt8(
|
| - public_flags | PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID)) {
|
| - return false;
|
| + if (!writer->WriteUInt8(public_flags |
|
| + PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID)) {
|
| + return false;
|
| }
|
| - if (!writer->WriteUInt32(
|
| - header.public_header.connection_id & k4ByteConnectionIdMask)) {
|
| + if (!writer->WriteUInt32(header.public_header.connection_id &
|
| + k4ByteConnectionIdMask)) {
|
| return false;
|
| }
|
| break;
|
| case PACKET_8BYTE_CONNECTION_ID:
|
| - if (!writer->WriteUInt8(
|
| - public_flags | PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID)) {
|
| + if (!writer->WriteUInt8(public_flags |
|
| + PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID)) {
|
| return false;
|
| }
|
| if (!writer->WriteUInt64(header.public_header.connection_id)) {
|
| @@ -798,7 +806,8 @@ bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header,
|
| }
|
|
|
| if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length,
|
| - header.packet_sequence_number, writer)) {
|
| + header.packet_sequence_number,
|
| + writer)) {
|
| return false;
|
| }
|
|
|
| @@ -844,8 +853,8 @@ QuicPacketSequenceNumber QuicFramer::CalculatePacketSequenceNumberFromWire(
|
| // epoch_delta is the delta between epochs the sequence number was serialized
|
| // with, so the correct value is likely the same epoch as the last sequence
|
| // number or an adjacent epoch.
|
| - const QuicPacketSequenceNumber epoch_delta =
|
| - GG_UINT64_C(1) << (8 * sequence_number_length);
|
| + const QuicPacketSequenceNumber epoch_delta = GG_UINT64_C(1)
|
| + << (8 * sequence_number_length);
|
| QuicPacketSequenceNumber next_sequence_number = last_sequence_number_ + 1;
|
| QuicPacketSequenceNumber epoch = last_sequence_number_ & ~(epoch_delta - 1);
|
| QuicPacketSequenceNumber prev_epoch = epoch - epoch_delta;
|
| @@ -858,8 +867,7 @@ QuicPacketSequenceNumber QuicFramer::CalculatePacketSequenceNumberFromWire(
|
| next_epoch + packet_sequence_number));
|
| }
|
|
|
| -bool QuicFramer::ProcessPublicHeader(
|
| - QuicPacketPublicHeader* public_header) {
|
| +bool QuicFramer::ProcessPublicHeader(QuicPacketPublicHeader* public_header) {
|
| uint8 public_flags;
|
| if (!reader_->ReadBytes(&public_flags, 1)) {
|
| set_detailed_error("Unable to read public flags.");
|
| @@ -870,8 +878,8 @@ bool QuicFramer::ProcessPublicHeader(
|
| public_header->version_flag =
|
| (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0;
|
|
|
| - if (validate_flags_ &&
|
| - !public_header->version_flag && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
|
| + if (validate_flags_ && !public_header->version_flag &&
|
| + public_flags > PACKET_PUBLIC_FLAGS_MAX) {
|
| set_detailed_error("Illegal public flags value.");
|
| return false;
|
| }
|
| @@ -899,8 +907,9 @@ bool QuicFramer::ProcessPublicHeader(
|
| }
|
| if ((public_header->connection_id & k4ByteConnectionIdMask) !=
|
| (last_serialized_connection_id_ & k4ByteConnectionIdMask)) {
|
| - set_detailed_error("Truncated 4 byte ConnectionId does not match "
|
| - "previous connection_id.");
|
| + set_detailed_error(
|
| + "Truncated 4 byte ConnectionId does not match "
|
| + "previous connection_id.");
|
| return false;
|
| }
|
| public_header->connection_id_length = PACKET_4BYTE_CONNECTION_ID;
|
| @@ -914,8 +923,9 @@ bool QuicFramer::ProcessPublicHeader(
|
| }
|
| if ((public_header->connection_id & k1ByteConnectionIdMask) !=
|
| (last_serialized_connection_id_ & k1ByteConnectionIdMask)) {
|
| - set_detailed_error("Truncated 1 byte ConnectionId does not match "
|
| - "previous connection_id.");
|
| + set_detailed_error(
|
| + "Truncated 1 byte ConnectionId does not match "
|
| + "previous connection_id.");
|
| return false;
|
| }
|
| public_header->connection_id_length = PACKET_1BYTE_CONNECTION_ID;
|
| @@ -927,9 +937,8 @@ bool QuicFramer::ProcessPublicHeader(
|
| break;
|
| }
|
|
|
| - public_header->sequence_number_length =
|
| - ReadSequenceNumberLength(
|
| - public_flags >> kPublicHeaderSequenceNumberShift);
|
| + public_header->sequence_number_length = ReadSequenceNumberLength(
|
| + public_flags >> kPublicHeaderSequenceNumberShift);
|
|
|
| // Read the version only if the packet is from the client.
|
| // version flag from the server means version negotiation packet.
|
| @@ -960,8 +969,8 @@ QuicSequenceNumberLength QuicFramer::GetMinSequenceNumberLength(
|
| return PACKET_1BYTE_SEQUENCE_NUMBER;
|
| } else if (sequence_number < 1 << (PACKET_2BYTE_SEQUENCE_NUMBER * 8)) {
|
| return PACKET_2BYTE_SEQUENCE_NUMBER;
|
| - } else if (sequence_number <
|
| - GG_UINT64_C(1) << (PACKET_4BYTE_SEQUENCE_NUMBER * 8)) {
|
| + } else if (sequence_number < GG_UINT64_C(1)
|
| + << (PACKET_4BYTE_SEQUENCE_NUMBER * 8)) {
|
| return PACKET_4BYTE_SEQUENCE_NUMBER;
|
| } else {
|
| return PACKET_6BYTE_SEQUENCE_NUMBER;
|
| @@ -1005,8 +1014,8 @@ QuicFramer::AckFrameInfo QuicFramer::GetAckFrameInfo(
|
| *iter == (last_missing + 1)) {
|
| ++cur_range_length;
|
| } else {
|
| - ack_info.nack_ranges[last_missing - cur_range_length]
|
| - = cur_range_length;
|
| + ack_info.nack_ranges[last_missing - cur_range_length] =
|
| + cur_range_length;
|
| cur_range_length = 0;
|
| }
|
| ack_info.max_delta = max(ack_info.max_delta, *iter - last_missing);
|
| @@ -1015,15 +1024,14 @@ QuicFramer::AckFrameInfo QuicFramer::GetAckFrameInfo(
|
| // Include the last nack range.
|
| ack_info.nack_ranges[last_missing - cur_range_length] = cur_range_length;
|
| // Include the range to the largest observed.
|
| - ack_info.max_delta = max(ack_info.max_delta,
|
| - received_info.largest_observed - last_missing);
|
| + ack_info.max_delta =
|
| + max(ack_info.max_delta, received_info.largest_observed - last_missing);
|
| }
|
| return ack_info;
|
| }
|
|
|
| -bool QuicFramer::ProcessPacketHeader(
|
| - QuicPacketHeader* header,
|
| - const QuicEncryptedPacket& packet) {
|
| +bool QuicFramer::ProcessPacketHeader(QuicPacketHeader* header,
|
| + const QuicEncryptedPacket& packet) {
|
| if (!ProcessPacketSequenceNumber(header->public_header.sequence_number_length,
|
| &header->packet_sequence_number)) {
|
| set_detailed_error("Unable to read sequence number.");
|
| @@ -1066,8 +1074,9 @@ bool QuicFramer::ProcessPacketHeader(
|
| return RaiseError(QUIC_INVALID_PACKET_HEADER);
|
| }
|
| if (first_fec_protected_packet_offset >= header->packet_sequence_number) {
|
| - set_detailed_error("First fec protected packet offset must be less "
|
| - "than the sequence number.");
|
| + set_detailed_error(
|
| + "First fec protected packet offset must be less "
|
| + "than the sequence number.");
|
| return RaiseError(QUIC_INVALID_PACKET_HEADER);
|
| }
|
| header->fec_group =
|
| @@ -1091,9 +1100,8 @@ bool QuicFramer::ProcessPacketSequenceNumber(
|
|
|
| // TODO(ianswett): Explore the usefulness of trying multiple sequence numbers
|
| // in case the first guess is incorrect.
|
| - *sequence_number =
|
| - CalculatePacketSequenceNumberFromWire(sequence_number_length,
|
| - wire_sequence_number);
|
| + *sequence_number = CalculatePacketSequenceNumberFromWire(
|
| + sequence_number_length, wire_sequence_number);
|
| return true;
|
| }
|
|
|
| @@ -1155,8 +1163,7 @@ bool QuicFramer::ProcessFrameData(const QuicPacketHeader& header) {
|
| // This was a special frame type that did not match any
|
| // of the known ones. Error.
|
| set_detailed_error("Illegal frame type.");
|
| - DLOG(WARNING) << "Illegal frame type: "
|
| - << static_cast<int>(frame_type);
|
| + DLOG(WARNING) << "Illegal frame type: " << static_cast<int>(frame_type);
|
| return RaiseError(QUIC_INVALID_FRAME_DATA);
|
| }
|
|
|
| @@ -1266,8 +1273,7 @@ bool QuicFramer::ProcessFrameData(const QuicPacketHeader& header) {
|
|
|
| default:
|
| set_detailed_error("Illegal frame type.");
|
| - DLOG(WARNING) << "Illegal frame type: "
|
| - << static_cast<int>(frame_type);
|
| + DLOG(WARNING) << "Illegal frame type: " << static_cast<int>(frame_type);
|
| return RaiseError(QUIC_INVALID_FRAME_DATA);
|
| }
|
| }
|
| @@ -1275,8 +1281,7 @@ bool QuicFramer::ProcessFrameData(const QuicPacketHeader& header) {
|
| return true;
|
| }
|
|
|
| -bool QuicFramer::ProcessStreamFrame(uint8 frame_type,
|
| - QuicStreamFrame* frame) {
|
| +bool QuicFramer::ProcessStreamFrame(uint8 frame_type, QuicStreamFrame* frame) {
|
| uint8 stream_flags = frame_type;
|
|
|
| stream_flags &= ~kQuicFrameTypeStreamMask;
|
| @@ -1464,8 +1469,7 @@ bool QuicFramer::ProcessQuicCongestionFeedbackFrame(
|
| set_detailed_error("Unable to read congestion feedback type.");
|
| return false;
|
| }
|
| - frame->type =
|
| - static_cast<CongestionFeedbackType>(feedback_type);
|
| + frame->type = static_cast<CongestionFeedbackType>(feedback_type);
|
|
|
| switch (frame->type) {
|
| case kInterArrival: {
|
| @@ -1512,8 +1516,9 @@ bool QuicFramer::ProcessQuicCongestionFeedbackFrame(
|
| }
|
| QuicPacketSequenceNumber packet = smallest_received + sequence_delta;
|
| inter_arrival->received_packet_times.insert(
|
| - make_pair(packet, time_received.Add(
|
| - QuicTime::Delta::FromMicroseconds(time_delta_us))));
|
| + make_pair(packet,
|
| + time_received.Add(
|
| + QuicTime::Delta::FromMicroseconds(time_delta_us))));
|
| }
|
| }
|
| break;
|
| @@ -1541,8 +1546,7 @@ bool QuicFramer::ProcessQuicCongestionFeedbackFrame(
|
| }
|
| default:
|
| set_detailed_error("Illegal congestion feedback type.");
|
| - DLOG(WARNING) << "Illegal congestion feedback type: "
|
| - << frame->type;
|
| + DLOG(WARNING) << "Illegal congestion feedback type: " << frame->type;
|
| return RaiseError(QUIC_INVALID_FRAME_DATA);
|
| }
|
|
|
| @@ -1591,8 +1595,7 @@ bool QuicFramer::ProcessConnectionCloseFrame(QuicConnectionCloseFrame* frame) {
|
| return false;
|
| }
|
|
|
| - if (error_code >= QUIC_LAST_ERROR ||
|
| - error_code < QUIC_NO_ERROR) {
|
| + if (error_code >= QUIC_LAST_ERROR || error_code < QUIC_NO_ERROR) {
|
| set_detailed_error("Invalid error code.");
|
| return false;
|
| }
|
| @@ -1617,8 +1620,7 @@ bool QuicFramer::ProcessGoAwayFrame(QuicGoAwayFrame* frame) {
|
| }
|
| frame->error_code = static_cast<QuicErrorCode>(error_code);
|
|
|
| - if (error_code >= QUIC_LAST_ERROR ||
|
| - error_code < QUIC_NO_ERROR) {
|
| + if (error_code >= QUIC_LAST_ERROR || error_code < QUIC_NO_ERROR) {
|
| set_detailed_error("Invalid error code.");
|
| return false;
|
| }
|
| @@ -1670,13 +1672,13 @@ StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
|
| bool includes_version,
|
| QuicSequenceNumberLength sequence_number_length) {
|
| return StringPiece(
|
| - encrypted.data() + kStartOfHashData, GetStartOfEncryptedData(
|
| - connection_id_length, includes_version, sequence_number_length)
|
| - - kStartOfHashData);
|
| + encrypted.data() + kStartOfHashData,
|
| + GetStartOfEncryptedData(
|
| + connection_id_length, includes_version, sequence_number_length) -
|
| + kStartOfHashData);
|
| }
|
|
|
| -void QuicFramer::SetDecrypter(QuicDecrypter* decrypter,
|
| - EncryptionLevel level) {
|
| +void QuicFramer::SetDecrypter(QuicDecrypter* decrypter, EncryptionLevel level) {
|
| DCHECK(alternative_decrypter_.get() == NULL);
|
| DCHECK_GE(level, decrypter_level_);
|
| decrypter_.reset(decrypter);
|
| @@ -1699,8 +1701,7 @@ const QuicDecrypter* QuicFramer::alternative_decrypter() const {
|
| return alternative_decrypter_.get();
|
| }
|
|
|
| -void QuicFramer::SetEncrypter(EncryptionLevel level,
|
| - QuicEncrypter* encrypter) {
|
| +void QuicFramer::SetEncrypter(EncryptionLevel level, QuicEncrypter* encrypter) {
|
| DCHECK_GE(level, 0);
|
| DCHECK_LT(level, NUM_ENCRYPTION_LEVELS);
|
| encrypter_[level].reset(encrypter);
|
| @@ -1726,7 +1727,7 @@ QuicEncryptedPacket* QuicFramer::EncryptPacket(
|
| return NULL;
|
| }
|
| StringPiece header_data = packet.BeforePlaintext();
|
| - size_t len = header_data.length() + out->length();
|
| + size_t len = header_data.length() + out->length();
|
| char* buffer = new char[len];
|
| // TODO(rch): eliminate this buffer copy by passing in a buffer to Encrypt().
|
| memcpy(buffer, header_data.data(), header_data.length());
|
| @@ -1766,9 +1767,9 @@ bool QuicFramer::DecryptPayload(const QuicPacketHeader& header,
|
| header.public_header.version_flag,
|
| header.public_header.sequence_number_length),
|
| encrypted));
|
| - if (decrypted_.get() != NULL) {
|
| + if (decrypted_.get() != NULL) {
|
| visitor_->OnDecryptedPacket(decrypter_level_);
|
| - } else if (alternative_decrypter_.get() != NULL) {
|
| + } else if (alternative_decrypter_.get() != NULL) {
|
| decrypted_.reset(alternative_decrypter_->DecryptPacket(
|
| header.packet_sequence_number,
|
| GetAssociatedDataFromEncryptedPacket(
|
| @@ -1795,7 +1796,7 @@ bool QuicFramer::DecryptPayload(const QuicPacketHeader& header,
|
| }
|
| }
|
|
|
| - if (decrypted_.get() == NULL) {
|
| + if (decrypted_.get() == NULL) {
|
| DLOG(WARNING) << "DecryptPacket failed for sequence_number:"
|
| << header.packet_sequence_number;
|
| return false;
|
| @@ -1814,13 +1815,12 @@ size_t QuicFramer::GetAckFrameSize(
|
| QuicSequenceNumberLength missing_sequence_number_length =
|
| GetMinSequenceNumberLength(ack_info.max_delta);
|
|
|
| - size_t ack_size = GetMinAckFrameSize(quic_version_,
|
| - sequence_number_length,
|
| - largest_observed_length);
|
| + size_t ack_size = GetMinAckFrameSize(
|
| + quic_version_, sequence_number_length, largest_observed_length);
|
| if (!ack_info.nack_ranges.empty()) {
|
| - ack_size += kNumberOfMissingPacketsSize + kNumberOfRevivedPacketsSize;
|
| + ack_size += kNumberOfMissingPacketsSize + kNumberOfRevivedPacketsSize;
|
| ack_size += ack_info.nack_ranges.size() *
|
| - (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
|
| + (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
|
| ack_size +=
|
| ack.received_info.revived_packets.size() * largest_observed_length;
|
| }
|
| @@ -1839,7 +1839,7 @@ size_t QuicFramer::ComputeFrameLength(
|
| frame.stream_frame->offset,
|
| last_frame_in_packet,
|
| is_in_fec_group) +
|
| - frame.stream_frame->data.TotalBufferSize();
|
| + frame.stream_frame->data.TotalBufferSize();
|
| case ACK_FRAME: {
|
| return GetAckFrameSize(*frame.ack_frame, sequence_number_length);
|
| }
|
| @@ -1856,10 +1856,10 @@ size_t QuicFramer::ComputeFrameLength(
|
| len += 1; // Number received packets.
|
| if (inter_arrival.received_packet_times.size() > 0) {
|
| len += PACKET_6BYTE_SEQUENCE_NUMBER; // Smallest received.
|
| - len += 8; // Time.
|
| + len += 8; // Time.
|
| // 2 bytes per sequence number delta plus 4 bytes per delta time.
|
| len += PACKET_6BYTE_SEQUENCE_NUMBER *
|
| - (inter_arrival.received_packet_times.size() - 1);
|
| + (inter_arrival.received_packet_times.size() - 1);
|
| }
|
| break;
|
| }
|
| @@ -1883,10 +1883,10 @@ size_t QuicFramer::ComputeFrameLength(
|
| return kQuicFrameTypeSize;
|
| case RST_STREAM_FRAME:
|
| return GetMinRstStreamFrameSize(quic_version_) +
|
| - frame.rst_stream_frame->error_details.size();
|
| + frame.rst_stream_frame->error_details.size();
|
| case CONNECTION_CLOSE_FRAME:
|
| return GetMinConnectionCloseFrameSize() +
|
| - frame.connection_close_frame->error_details.size();
|
| + frame.connection_close_frame->error_details.size();
|
| case GOAWAY_FRAME:
|
| return GetMinGoAwayFrameSize() + frame.goaway_frame->reason_phrase.size();
|
| case WINDOW_UPDATE_FRAME:
|
| @@ -1920,7 +1920,7 @@ bool QuicFramer::AppendTypeByte(const QuicFrame& frame,
|
|
|
| // Data Length bit.
|
| type_byte <<= kQuicStreamDataLengthShift;
|
| - type_byte |= no_stream_frame_length ? 0: kQuicStreamDataLengthMask;
|
| + type_byte |= no_stream_frame_length ? 0 : kQuicStreamDataLengthMask;
|
|
|
| // Offset 3 bits.
|
| type_byte <<= kQuicStreamOffsetShift;
|
| @@ -1962,20 +1962,20 @@ bool QuicFramer::AppendPacketSequenceNumber(
|
| }
|
| switch (sequence_number_length) {
|
| case PACKET_1BYTE_SEQUENCE_NUMBER:
|
| - return writer->WriteUInt8(
|
| - packet_sequence_number & k1ByteSequenceNumberMask);
|
| + return writer->WriteUInt8(packet_sequence_number &
|
| + k1ByteSequenceNumberMask);
|
| break;
|
| case PACKET_2BYTE_SEQUENCE_NUMBER:
|
| - return writer->WriteUInt16(
|
| - packet_sequence_number & k2ByteSequenceNumberMask);
|
| + return writer->WriteUInt16(packet_sequence_number &
|
| + k2ByteSequenceNumberMask);
|
| break;
|
| case PACKET_4BYTE_SEQUENCE_NUMBER:
|
| - return writer->WriteUInt32(
|
| - packet_sequence_number & k4ByteSequenceNumberMask);
|
| + return writer->WriteUInt32(packet_sequence_number &
|
| + k4ByteSequenceNumberMask);
|
| break;
|
| case PACKET_6BYTE_SEQUENCE_NUMBER:
|
| - return writer->WriteUInt48(
|
| - packet_sequence_number & k6ByteSequenceNumberMask);
|
| + return writer->WriteUInt48(packet_sequence_number &
|
| + k6ByteSequenceNumberMask);
|
| break;
|
| default:
|
| DCHECK(false) << "sequence_number_length: " << sequence_number_length;
|
| @@ -1983,10 +1983,9 @@ bool QuicFramer::AppendPacketSequenceNumber(
|
| }
|
| }
|
|
|
| -bool QuicFramer::AppendStreamFrame(
|
| - const QuicStreamFrame& frame,
|
| - bool no_stream_frame_length,
|
| - QuicDataWriter* writer) {
|
| +bool QuicFramer::AppendStreamFrame(const QuicStreamFrame& frame,
|
| + bool no_stream_frame_length,
|
| + QuicDataWriter* writer) {
|
| if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) {
|
| LOG(DFATAL) << "Writing stream id size failed.";
|
| return false;
|
| @@ -2015,10 +2014,9 @@ void QuicFramer::set_version(const QuicVersion version) {
|
| quic_version_ = version;
|
| }
|
|
|
| -bool QuicFramer::AppendAckFrameAndTypeByte(
|
| - const QuicPacketHeader& header,
|
| - const QuicAckFrame& frame,
|
| - QuicDataWriter* writer) {
|
| +bool QuicFramer::AppendAckFrameAndTypeByte(const QuicPacketHeader& header,
|
| + const QuicAckFrame& frame,
|
| + QuicDataWriter* writer) {
|
| AckFrameInfo ack_info = GetAckFrameInfo(frame);
|
| QuicPacketSequenceNumber ack_largest_observed =
|
| frame.received_info.largest_observed;
|
| @@ -2027,11 +2025,14 @@ bool QuicFramer::AppendAckFrameAndTypeByte(
|
| QuicSequenceNumberLength missing_sequence_number_length =
|
| GetMinSequenceNumberLength(ack_info.max_delta);
|
| // Determine whether we need to truncate ranges.
|
| - size_t available_range_bytes = writer->capacity() - writer->length() -
|
| + size_t available_range_bytes =
|
| + writer->capacity() - writer->length() -
|
| GetMinAckFrameSize(quic_version_,
|
| header.public_header.sequence_number_length,
|
| - largest_observed_length) - kNumberOfRevivedPacketsSize;
|
| - size_t max_num_ranges = available_range_bytes /
|
| + largest_observed_length) -
|
| + kNumberOfRevivedPacketsSize;
|
| + size_t max_num_ranges =
|
| + available_range_bytes /
|
| (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
|
| max_num_ranges =
|
| min(static_cast<size_t>(numeric_limits<uint8>::max()), max_num_ranges);
|
| @@ -2092,8 +2093,8 @@ bool QuicFramer::AppendAckFrameAndTypeByte(
|
| return false;
|
| }
|
|
|
| - if (!AppendPacketSequenceNumber(largest_observed_length,
|
| - ack_largest_observed, writer)) {
|
| + if (!AppendPacketSequenceNumber(
|
| + largest_observed_length, ack_largest_observed, writer)) {
|
| return false;
|
| }
|
|
|
| @@ -2125,12 +2126,12 @@ bool QuicFramer::AppendAckFrameAndTypeByte(
|
| // Calculate the delta to the last number in the range.
|
| QuicPacketSequenceNumber missing_delta =
|
| last_sequence_written - (ack_iter->first + ack_iter->second);
|
| - if (!AppendPacketSequenceNumber(missing_sequence_number_length,
|
| - missing_delta, writer)) {
|
| + if (!AppendPacketSequenceNumber(
|
| + missing_sequence_number_length, missing_delta, writer)) {
|
| return false;
|
| }
|
| - if (!AppendPacketSequenceNumber(PACKET_1BYTE_SEQUENCE_NUMBER,
|
| - ack_iter->second, writer)) {
|
| + if (!AppendPacketSequenceNumber(
|
| + PACKET_1BYTE_SEQUENCE_NUMBER, ack_iter->second, writer)) {
|
| return false;
|
| }
|
| // Subtract 1 so a missing_delta of 0 means an adjacent range.
|
| @@ -2144,9 +2145,9 @@ bool QuicFramer::AppendAckFrameAndTypeByte(
|
| uint8 num_revived_packets =
|
| min(received_info.revived_packets.size(),
|
| static_cast<size_t>(numeric_limits<uint8>::max()));
|
| - num_revived_packets = min(
|
| - static_cast<size_t>(num_revived_packets),
|
| - (writer->capacity() - writer->length()) / largest_observed_length);
|
| + num_revived_packets =
|
| + min(static_cast<size_t>(num_revived_packets),
|
| + (writer->capacity() - writer->length()) / largest_observed_length);
|
| if (!writer->WriteBytes(&num_revived_packets, 1)) {
|
| return false;
|
| }
|
| @@ -2155,8 +2156,7 @@ bool QuicFramer::AppendAckFrameAndTypeByte(
|
| received_info.revived_packets.begin();
|
| for (int i = 0; i < num_revived_packets; ++i, ++iter) {
|
| LOG_IF(DFATAL, !ContainsKey(received_info.missing_packets, *iter));
|
| - if (!AppendPacketSequenceNumber(largest_observed_length,
|
| - *iter, writer)) {
|
| + if (!AppendPacketSequenceNumber(largest_observed_length, *iter, writer)) {
|
| return false;
|
| }
|
| }
|
| @@ -2182,8 +2182,7 @@ bool QuicFramer::AppendCongestionFeedbackFrame(
|
| return false;
|
| }
|
| // TODO(ianswett): Make num_received_packets a varint.
|
| - uint8 num_received_packets =
|
| - inter_arrival.received_packet_times.size();
|
| + uint8 num_received_packets = inter_arrival.received_packet_times.size();
|
| if (!writer->WriteBytes(&num_received_packets, 1)) {
|
| return false;
|
| }
|
| @@ -2192,8 +2191,8 @@ bool QuicFramer::AppendCongestionFeedbackFrame(
|
| inter_arrival.received_packet_times.begin();
|
|
|
| QuicPacketSequenceNumber lowest_sequence = it->first;
|
| - if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
|
| - lowest_sequence, writer)) {
|
| + if (!AppendPacketSequenceNumber(
|
| + PACKET_6BYTE_SEQUENCE_NUMBER, lowest_sequence, writer)) {
|
| return false;
|
| }
|
|
|
| @@ -2223,8 +2222,7 @@ bool QuicFramer::AppendCongestionFeedbackFrame(
|
| break;
|
| }
|
| case kFixRate: {
|
| - const CongestionFeedbackMessageFixRate& fix_rate =
|
| - frame.fix_rate;
|
| + const CongestionFeedbackMessageFixRate& fix_rate = frame.fix_rate;
|
| if (!writer->WriteUInt32(fix_rate.bitrate.ToBytesPerSecond())) {
|
| return false;
|
| }
|
| @@ -2247,10 +2245,9 @@ bool QuicFramer::AppendCongestionFeedbackFrame(
|
| return true;
|
| }
|
|
|
| -bool QuicFramer::AppendStopWaitingFrame(
|
| - const QuicPacketHeader& header,
|
| - const QuicStopWaitingFrame& frame,
|
| - QuicDataWriter* writer) {
|
| +bool QuicFramer::AppendStopWaitingFrame(const QuicPacketHeader& header,
|
| + const QuicStopWaitingFrame& frame,
|
| + QuicDataWriter* writer) {
|
| DCHECK_GE(header.packet_sequence_number, frame.least_unacked);
|
| const QuicPacketSequenceNumber least_unacked_delta =
|
| header.packet_sequence_number - frame.least_unacked;
|
| @@ -2269,7 +2266,8 @@ bool QuicFramer::AppendStopWaitingFrame(
|
| return false;
|
| }
|
| if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length,
|
| - least_unacked_delta, writer)) {
|
| + least_unacked_delta,
|
| + writer)) {
|
| LOG(DFATAL) << " seq failed: "
|
| << header.public_header.sequence_number_length;
|
| return false;
|
| @@ -2278,9 +2276,8 @@ bool QuicFramer::AppendStopWaitingFrame(
|
| return true;
|
| }
|
|
|
| -bool QuicFramer::AppendRstStreamFrame(
|
| - const QuicRstStreamFrame& frame,
|
| - QuicDataWriter* writer) {
|
| +bool QuicFramer::AppendRstStreamFrame(const QuicRstStreamFrame& frame,
|
| + QuicDataWriter* writer) {
|
| if (!writer->WriteUInt32(frame.stream_id)) {
|
| return false;
|
| }
|
|
|
Chromium Code Reviews
