Landing Recent QUIC changes until Sun May 8 00:39:29 2016 +0000

net/quic/quic_framer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_framer.h"
 
 #include <cstdint>
 #include <memory>
 #include <vector>
 
@@ skipping 1360 matching lines @@
     if (!reader->ReadStringPiece16(&data)) {
       set_detailed_error("Unable to read frame data.");
       return false;
     }
   } else {
     if (!reader->ReadStringPiece(&data, reader->BytesRemaining())) {
       set_detailed_error("Unable to read frame data.");
       return false;
     }
   }
-  frame->frame_buffer = data.data();
-  frame->frame_length = static_cast<uint16_t>(data.length());
+  frame->data_buffer = data.data();
+  frame->data_length = static_cast<uint16_t>(data.length());
 
   return true;
 }
 
 bool QuicFramer::ProcessAckFrame(QuicDataReader* reader,
                                  uint8_t frame_type,
                                  QuicAckFrame* ack_frame) {
   // Determine the three lengths from the frame type: largest observed length,
   // missing packet number length, and missing range length.
   const QuicPacketNumberLength missing_packet_number_length =
@@ skipping 261 matching lines @@
     return false;
   }
 
   uint32_t error_code;
   if (!reader->ReadUInt32(&error_code)) {
     set_detailed_error("Unable to read rst stream error code.");
     return false;
   }
 
   if (error_code >= QUIC_STREAM_LAST_ERROR) {
-    if (FLAGS_quic_ignore_invalid_error_code) {
-      // Ignore invalid stream error code if any.
-      error_code = QUIC_STREAM_LAST_ERROR;
-    } else {
-      set_detailed_error("Invalid rst stream error code.");
-      return false;
-    }
+    // Ignore invalid stream error code if any.
+    error_code = QUIC_STREAM_LAST_ERROR;
   }
 
   frame->error_code = static_cast<QuicRstStreamErrorCode>(error_code);
   return true;
 }
 
 bool QuicFramer::ProcessConnectionCloseFrame(QuicDataReader* reader,
                                              QuicConnectionCloseFrame* frame) {
   uint32_t error_code;
   if (!reader->ReadUInt32(&error_code)) {
     set_detailed_error("Unable to read connection close error code.");
     return false;
   }
 
   if (error_code >= QUIC_LAST_ERROR) {
-    if (FLAGS_quic_ignore_invalid_error_code) {
-      // Ignore invalid QUIC error code if any.
-      error_code = QUIC_LAST_ERROR;
-    } else {
-      set_detailed_error("Invalid error code.");
-      return false;
-    }
+    // Ignore invalid QUIC error code if any.
+    error_code = QUIC_LAST_ERROR;
   }
 
   frame->error_code = static_cast<QuicErrorCode>(error_code);
 
   StringPiece error_details;
   if (!reader->ReadStringPiece16(&error_details)) {
     set_detailed_error("Unable to read connection close error details.");
     return false;
   }
   frame->error_details = error_details.as_string();
 
   return true;
 }
 
 bool QuicFramer::ProcessGoAwayFrame(QuicDataReader* reader,
                                     QuicGoAwayFrame* frame) {
   uint32_t error_code;
   if (!reader->ReadUInt32(&error_code)) {
     set_detailed_error("Unable to read go away error code.");
     return false;
   }
 
   if (error_code >= QUIC_LAST_ERROR) {
-    if (FLAGS_quic_ignore_invalid_error_code) {
-      // Ignore invalid QUIC error code if any.
-      error_code = QUIC_LAST_ERROR;
-    } else {
-      set_detailed_error("Invalid error code.");
-      return false;
-    }
+    // Ignore invalid QUIC error code if any.
+    error_code = QUIC_LAST_ERROR;
   }
   frame->error_code = static_cast<QuicErrorCode>(error_code);
 
   uint32_t stream_id;
   if (!reader->ReadUInt32(&stream_id)) {
     set_detailed_error("Unable to read last good stream id.");
     return false;
   }
   frame->last_good_stream_id = static_cast<QuicStreamId>(stream_id);
 
@@ skipping 279 matching lines @@
 
 size_t QuicFramer::ComputeFrameLength(
     const QuicFrame& frame,
     bool last_frame_in_packet,
     QuicPacketNumberLength packet_number_length) {
   switch (frame.type) {
     case STREAM_FRAME:
       return GetMinStreamFrameSize(frame.stream_frame->stream_id,
                                    frame.stream_frame->offset,
                                    last_frame_in_packet) +
-             frame.stream_frame->frame_length;
+             frame.stream_frame->data_length;
     case ACK_FRAME: {
       return GetAckFrameSize(*frame.ack_frame, packet_number_length);
     }
     case STOP_WAITING_FRAME:
       return GetStopWaitingFrameSize(quic_version_, packet_number_length);
     case MTU_DISCOVERY_FRAME:
     // MTU discovery frames are serialized as ping frames.
     case PING_FRAME:
       // Ping has no payload.
       return kQuicFrameTypeSize;
@@ skipping 99 matching lines @@
                                    QuicDataWriter* writer) {
   if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) {
     QUIC_BUG << "Writing stream id size failed.";
     return false;
   }
   if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) {
     QUIC_BUG << "Writing offset size failed.";
     return false;
   }
   if (!no_stream_frame_length) {
-    if ((frame.frame_length > numeric_limits<uint16_t>::max()) ||
-        !writer->WriteUInt16(static_cast<uint16_t>(frame.frame_length))) {
+    if ((frame.data_length > numeric_limits<uint16_t>::max()) ||
+        !writer->WriteUInt16(static_cast<uint16_t>(frame.data_length))) {
       QUIC_BUG << "Writing stream frame length failed";
       return false;
     }
   }
 
-  if (!writer->WriteBytes(frame.frame_buffer, frame.frame_length)) {
+  if (!writer->WriteBytes(frame.data_buffer, frame.data_length)) {
     QUIC_BUG << "Writing frame data failed.";
     return false;
   }
   return true;
 }
 
 void QuicFramer::set_version(const QuicVersion version) {
   DCHECK(IsSupportedVersion(version)) << QuicVersionToString(version);
   quic_version_ = version;
 }
@@ skipping 420 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net