Remove QUIC_VERSION_15 now that Chrome Stable supports QUIC_VERSION_16.

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 "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
@@ skipping 180 matching lines @@
   return kQuicFrameTypeSize + GetStreamIdSize(stream_id) +
       GetStreamOffsetSize(offset) +
       (no_stream_frame_length ? 0 : kQuicStreamPayloadLengthSize);
 }
 
 // static
 size_t QuicFramer::GetMinAckFrameSize(
     QuicVersion version,
     QuicSequenceNumberLength sequence_number_length,
     QuicSequenceNumberLength largest_observed_length) {
-  size_t len = kQuicFrameTypeSize + kQuicEntropyHashSize +
+  return kQuicFrameTypeSize + kQuicEntropyHashSize +
       largest_observed_length + kQuicDeltaTimeLargestObservedSize;
-  if (version <= QUIC_VERSION_15) {
-    len += sequence_number_length + kQuicEntropyHashSize;
-  }
-  return len;
 }
 
 // static
 size_t QuicFramer::GetStopWaitingFrameSize(
     QuicSequenceNumberLength sequence_number_length) {
   return kQuicFrameTypeSize + kQuicEntropyHashSize +
       sequence_number_length;
 }
 
 // static
@@ skipping 158 matching lines @@
         }
         break;
       case CONGESTION_FEEDBACK_FRAME:
         if (!AppendCongestionFeedbackFrame(
                 *frame.congestion_feedback_frame, &writer)) {
           LOG(DFATAL) << "AppendCongestionFeedbackFrame failed";
           return kNoPacket;
         }
         break;
       case STOP_WAITING_FRAME:
-        if (quic_version_ <= QUIC_VERSION_15) {
-          LOG(DFATAL) << "Attempt to add a StopWaitingFrame in "
-                      << QuicVersionToString(quic_version_);
-          return kNoPacket;
-        }
         if (!AppendStopWaitingFrame(
                 header, *frame.stop_waiting_frame, &writer)) {
           LOG(DFATAL) << "AppendStopWaitingFrame failed";
           return kNoPacket;
         }
         break;
       case PING_FRAME:
         if (quic_version_ <= QUIC_VERSION_16) {
           LOG(DFATAL) << "Attempt to add a PingFrame in "
                       << QuicVersionToString(quic_version_);
@@ skipping 812 matching lines @@
         }
         if (!visitor_->OnBlockedFrame(blocked_frame)) {
           DVLOG(1) << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
         }
         continue;
       }
 
       case STOP_WAITING_FRAME: {
-        if (quic_version_ <= QUIC_VERSION_15) {
-          LOG(DFATAL) << "Trying to read a StopWaiting in "
-                      << QuicVersionToString(quic_version_);
-          return RaiseError(QUIC_INTERNAL_ERROR);
-        }
         QuicStopWaitingFrame stop_waiting_frame;
         if (!ProcessStopWaitingFrame(header, &stop_waiting_frame)) {
           return RaiseError(QUIC_INVALID_STOP_WAITING_DATA);
         }
         if (!visitor_->OnStopWaitingFrame(stop_waiting_frame)) {
           DVLOG(1) << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
         }
         continue;
@@ skipping 77 matching lines @@
   if (!frame_data.empty()) {
     frame->data.Append(const_cast<char*>(frame_data.data()), frame_data.size());
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessAckFrame(const QuicPacketHeader& header,
                                  uint8 frame_type,
                                  QuicAckFrame* frame) {
-  if (quic_version_ <= QUIC_VERSION_15) {
-    if (!ProcessStopWaitingFrame(header, &frame->sent_info)) {
-      return false;
-    }
-  }
   if (!ProcessReceivedInfo(frame_type, &frame->received_info)) {
     return false;
   }
   return true;
 }
 
 bool QuicFramer::ProcessReceivedInfo(uint8 frame_type,
                                      ReceivedPacketInfo* received_info) {
   // Determine the three lengths from the frame type: largest observed length,
   // missing sequence number length, and missing range length.
@@ skipping 703 matching lines @@
   // Missing sequence number length.
   type_byte <<= kQuicSequenceNumberLengthShift;
   type_byte |= GetSequenceNumberFlags(missing_sequence_number_length);
 
   type_byte |= kQuicFrameTypeAckMask;
 
   if (!writer->WriteUInt8(type_byte)) {
     return false;
   }
 
-  if (quic_version_ <= QUIC_VERSION_15) {
-    if (!AppendStopWaitingFrame(header, frame.sent_info, writer)) {
-      return false;
-    }
-  }
-
   const ReceivedPacketInfo& received_info = frame.received_info;
   QuicPacketEntropyHash ack_entropy_hash = received_info.entropy_hash;
   NackRangeMap::reverse_iterator ack_iter = ack_info.nack_ranges.rbegin();
   if (truncated) {
     // Skip the nack ranges which the truncated ack won't include and set
     // a correct largest observed for the truncated ack.
     for (size_t i = 1; i < (ack_info.nack_ranges.size() - max_num_ranges);
          ++i) {
       ++ack_iter;
     }
@@ skipping 269 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net