Removing QUIC's VERSION_6, now that QUIC no longer needs to support the

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 "base/containers/hash_tables.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
@@ skipping 85 matching lines @@
   encrypter_[ENCRYPTION_NONE].reset(QuicEncrypter::Create(kNULL));
 }
 
 QuicFramer::~QuicFramer() {}
 
 // static
 size_t QuicFramer::GetMinStreamFrameSize(QuicVersion version,
                                          QuicStreamId stream_id,
                                          QuicStreamOffset offset,
                                          bool last_frame_in_packet) {
-  if (version == QUIC_VERSION_6) {
-    return kQuicFrameTypeSize + kQuicMaxStreamIdSize +
-        kQuicStreamFinSize + kQuicMaxStreamOffsetSize +
-        kQuicStreamPayloadLengthSize;
-  }
   return kQuicFrameTypeSize + GetStreamIdSize(stream_id) +
       GetStreamOffsetSize(offset) +
       (last_frame_in_packet ? 0 : kQuicStreamPayloadLengthSize);
 }
 
 // static
 size_t QuicFramer::GetMinAckFrameSize() {
   return kQuicFrameTypeSize + kQuicEntropyHashSize +
       PACKET_6BYTE_SEQUENCE_NUMBER + kQuicEntropyHashSize +
       PACKET_6BYTE_SEQUENCE_NUMBER + kQuicDeltaTimeLargestObservedSize +
@@ skipping 155 matching lines @@
     const bool last_frame_in_packet = i == (frames.size() - 1);
     if (!AppendTypeByte(frame, last_frame_in_packet, &writer)) {
       return kNoPacket;
     }
 
     switch (frame.type) {
       case PADDING_FRAME:
         writer.WritePadding();
         break;
       case STREAM_FRAME:
-        if (quic_version_ == QUIC_VERSION_6) {
-          if (!AppendV6StreamFramePayload(*frame.stream_frame, &writer)) {
-            return kNoPacket;
-          }
-        } else {
-          if (!AppendStreamFramePayload(
-              *frame.stream_frame, last_frame_in_packet, &writer)) {
-            return kNoPacket;
-          }
+        if (!AppendStreamFramePayload(
+            *frame.stream_frame, last_frame_in_packet, &writer)) {
+          return kNoPacket;
         }
         break;
       case ACK_FRAME:
         if (!AppendAckFramePayload(*frame.ack_frame, &writer)) {
           return kNoPacket;
         }
         break;
       case CONGESTION_FEEDBACK_FRAME:
         if (!AppendQuicCongestionFeedbackFramePayload(
                 *frame.congestion_feedback_frame, &writer)) {
@@ skipping 586 matching lines @@
     set_detailed_error("Unable to read frame type.");
     return RaiseError(QUIC_INVALID_FRAME_DATA);
   }
   while (!reader_->IsDoneReading()) {
     uint8 frame_type;
     if (!reader_->ReadBytes(&frame_type, 1)) {
       set_detailed_error("Unable to read frame type.");
       return RaiseError(QUIC_INVALID_FRAME_DATA);
     }
 
-    if (quic_version_ >= QUIC_VERSION_7) {
-      if ((frame_type & kQuicFrameType0BitMask) == 0) {
-        QuicStreamFrame frame;
-        if (!ProcessStreamFrame(frame_type, &frame)) {
-          return RaiseError(QUIC_INVALID_FRAME_DATA);
-        }
-        if (!visitor_->OnStreamFrame(frame)) {
-          DLOG(INFO) << "Visitor asked to stop further processing.";
-          // Returning true since there was no parsing error.
-          return true;
-        }
-        continue;
+    if ((frame_type & kQuicFrameType0BitMask) == 0) {
+      QuicStreamFrame frame;
+      if (!ProcessStreamFrame(frame_type, &frame)) {
+        return RaiseError(QUIC_INVALID_FRAME_DATA);
       }
-
-      frame_type >>= 1;
-      if ((frame_type & kQuicFrameType0BitMask) == 0) {
-        QuicAckFrame frame;
-        if (!ProcessAckFrame(&frame)) {
-          return RaiseError(QUIC_INVALID_FRAME_DATA);
-        }
-        if (!visitor_->OnAckFrame(frame)) {
-          DLOG(INFO) << "Visitor asked to stop further processing.";
-          // Returning true since there was no parsing error.
-          return true;
-        }
-        continue;
+      if (!visitor_->OnStreamFrame(frame)) {
+        DLOG(INFO) << "Visitor asked to stop further processing.";
+        // Returning true since there was no parsing error.
+        return true;
       }
-
-      frame_type >>= 1;
-      if ((frame_type & kQuicFrameType0BitMask) == 0) {
-        QuicCongestionFeedbackFrame frame;
-        if (!ProcessQuicCongestionFeedbackFrame(&frame)) {
-          return RaiseError(QUIC_INVALID_FRAME_DATA);
-        }
-        if (!visitor_->OnCongestionFeedbackFrame(frame)) {
-          DLOG(INFO) << "Visitor asked to stop further processing.";
-          // Returning true since there was no parsing error.
-          return true;
-        }
-        continue;
-      }
-
-      frame_type >>= 1;
+      continue;
     }
 
+    frame_type >>= 1;
+    if ((frame_type & kQuicFrameType0BitMask) == 0) {
+      QuicAckFrame frame;
+      if (!ProcessAckFrame(&frame)) {
+        return RaiseError(QUIC_INVALID_FRAME_DATA);
+      }
+      if (!visitor_->OnAckFrame(frame)) {
+        DLOG(INFO) << "Visitor asked to stop further processing.";
+        // Returning true since there was no parsing error.
+        return true;
+      }
+      continue;
+    }
+
+    frame_type >>= 1;
+    if ((frame_type & kQuicFrameType0BitMask) == 0) {
+      QuicCongestionFeedbackFrame frame;
+      if (!ProcessQuicCongestionFeedbackFrame(&frame)) {
+        return RaiseError(QUIC_INVALID_FRAME_DATA);
+      }
+      if (!visitor_->OnCongestionFeedbackFrame(frame)) {
+        DLOG(INFO) << "Visitor asked to stop further processing.";
+        // Returning true since there was no parsing error.
+        return true;
+      }
+      continue;
+    }
+
+    frame_type >>= 1;
+
     switch (frame_type) {
+      // STREAM_FRAME, ACK_FRAME, and CONGESTION_FEEDBACK_FRAME are handled
+      // above.
       case PADDING_FRAME:
         // We're done with the packet
         return true;
-      // STREAM_FRAME, ACK_FRAME, and CONGESTION_FEEDBACK handled above for
-      // QUIC_VERSION_7 and later.
-      case STREAM_FRAME: {
-        QuicStreamFrame frame;
-        if (!ProcessV6StreamFrame(&frame)) {
-          return RaiseError(QUIC_INVALID_FRAME_DATA);
-        }
-        if (!visitor_->OnStreamFrame(frame)) {
-          DLOG(INFO) << "Visitor asked to stop further processing.";
-          // Returning true since there was no parsing error.
-          return true;
-        }
-        continue;
-      }
-
-      case ACK_FRAME: {
-        QuicAckFrame frame;
-        if (!ProcessAckFrame(&frame)) {
-          return RaiseError(QUIC_INVALID_FRAME_DATA);
-        }
-        if (!visitor_->OnAckFrame(frame)) {
-          DLOG(INFO) << "Visitor asked to stop further processing.";
-          // Returning true since there was no parsing error.
-          // TODO(ianswett): Consider continuing to process frames, since there
-          // was not a parsing error.
-          return true;
-        }
-        continue;
-      }
-
-      case CONGESTION_FEEDBACK_FRAME: {
-        QuicCongestionFeedbackFrame frame;
-        if (!ProcessQuicCongestionFeedbackFrame(&frame)) {
-          return RaiseError(QUIC_INVALID_FRAME_DATA);
-        }
-        if (!visitor_->OnCongestionFeedbackFrame(frame)) {
-          DLOG(INFO) << "Visitor asked to stop further processing.";
-          // Returning true since there was no parsing error.
-          return true;
-        }
-        continue;
-      }
 
       case RST_STREAM_FRAME: {
         QuicRstStreamFrame frame;
         if (!ProcessRstStreamFrame(&frame)) {
           return RaiseError(QUIC_INVALID_RST_STREAM_DATA);
         }
         if (!visitor_->OnRstStreamFrame(frame)) {
           DLOG(INFO) << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
@@ skipping 84 matching lines @@
   } else {
     if (!reader_->ReadStringPiece(&frame->data, reader_->BytesRemaining())) {
       set_detailed_error("Unable to read frame data.");
       return false;
     }
   }
 
   return true;
 }
 
-bool QuicFramer::ProcessV6StreamFrame(QuicStreamFrame* frame) {
-  if (!reader_->ReadUInt32(&frame->stream_id)) {
-    set_detailed_error("Unable to read stream_id.");
-    return false;
-  }
-
-  uint8 fin;
-  if (!reader_->ReadBytes(&fin, 1)) {
-    set_detailed_error("Unable to read fin.");
-    return false;
-  }
-  if (fin > 1) {
-    set_detailed_error("Invalid fin value.");
-    return false;
-  }
-  frame->fin = (fin == 1);
-
-  if (!reader_->ReadUInt64(&frame->offset)) {
-    set_detailed_error("Unable to read offset.");
-    return false;
-  }
-
-  if (!reader_->ReadStringPiece16(&frame->data)) {
-    set_detailed_error("Unable to read frame data.");
-    return false;
-  }
-
-  return true;
-}
-
 bool QuicFramer::ProcessAckFrame(QuicAckFrame* frame) {
   if (!ProcessSentInfo(&frame->sent_info)) {
     return false;
   }
   if (!ProcessReceivedInfo(&frame->received_info)) {
     return false;
   }
   return true;
 }
 
@@ skipping 459 matching lines @@
   }
 
   // Not reachable, but some Chrome compilers can't figure that out.  *sigh*
   DCHECK(false);
   return 0;
 }
 
 bool QuicFramer::AppendTypeByte(const QuicFrame& frame,
                                 bool last_frame_in_packet,
                                 QuicDataWriter* writer) {
-  if (quic_version_ == QUIC_VERSION_6) {
-    return writer->WriteUInt8(frame.type);
-  }
-
   uint8 type_byte = 0;
   switch (frame.type) {
     case STREAM_FRAME: {
       if (frame.stream_frame == NULL) {
         LOG(DFATAL) << "Failed to append STREAM frame with no stream_frame.";
       }
       // Fin bit.
       type_byte |= frame.stream_frame->fin ? kQuicStreamFinMask : 0;
 
       // Data Length bit.
@@ skipping 80 matching lines @@
     if (!writer->WriteUInt16(frame.data.size())) {
       return false;
     }
   }
   if (!writer->WriteBytes(frame.data.data(), frame.data.size())) {
     return false;
   }
   return true;
 }
 
-bool QuicFramer::AppendV6StreamFramePayload(
-    const QuicStreamFrame& frame,
-    QuicDataWriter* writer) {
-  if (!writer->WriteUInt32(frame.stream_id)) {
-    return false;
-  }
-  if (!writer->WriteUInt8(frame.fin)) {
-    return false;
-  }
-  if (!writer->WriteUInt64(frame.offset)) {
-    return false;
-  }
-  if (!writer->WriteUInt16(frame.data.size())) {
-    return false;
-  }
-  if (!writer->WriteBytes(frame.data.data(), frame.data.size())) {
-    return false;
-  }
-  return true;
-}
-
 QuicPacketSequenceNumber QuicFramer::CalculateLargestObserved(
     const SequenceNumberSet& missing_packets,
     SequenceNumberSet::const_iterator largest_written) {
   SequenceNumberSet::const_iterator it = largest_written;
   QuicPacketSequenceNumber previous_missing = *it;
   ++it;
 
   // See if the next thing is a gap in the missing packets: if it's a
   // non-missing packet we can return it.
   if (it != missing_packets.end() && previous_missing + 1 != *it) {
@@ skipping 218 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net