Remove QUIC_VERSION_15 now that Chrome Stable supports QUIC_VERSION_16.

net/quic/quic_connection.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_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 533 matching lines @@
   }
 
   last_ack_frames_.push_back(incoming_ack);
   return connected_;
 }
 
 void QuicConnection::ProcessAckFrame(const QuicAckFrame& incoming_ack) {
   largest_seen_packet_with_ack_ = last_header_.packet_sequence_number;
   received_packet_manager_.UpdatePacketInformationReceivedByPeer(
       incoming_ack.received_info);
-  if (version() <= QUIC_VERSION_15) {
-    ProcessStopWaitingFrame(incoming_ack.sent_info);
-  }
 
   sent_entropy_manager_.ClearEntropyBefore(
       received_packet_manager_.least_packet_awaited_by_peer() - 1);
 
   sent_packet_manager_.OnIncomingAck(incoming_ack.received_info,
                                      time_of_last_received_packet_);
   if (sent_packet_manager_.HasPendingRetransmissions()) {
     WriteIfNotBlocked();
   }
 
@@ skipping 68 matching lines @@
   if (incoming_ack.received_info.largest_observed <
           received_packet_manager_.peer_largest_observed_packet()) {
     DLOG(ERROR) << ENDPOINT << "Peer's largest_observed packet decreased:"
                 << incoming_ack.received_info.largest_observed << " vs "
                 << received_packet_manager_.peer_largest_observed_packet();
     // A new ack has a diminished largest_observed value.  Error out.
     // If this was an old packet, we wouldn't even have checked.
     return false;
   }
 
-  if (version() <= QUIC_VERSION_15) {
-    if (!ValidateStopWaitingFrame(incoming_ack.sent_info)) {
-      return false;
-    }
-  }
-
   if (!incoming_ack.received_info.missing_packets.empty() &&
       *incoming_ack.received_info.missing_packets.rbegin() >
       incoming_ack.received_info.largest_observed) {
     DLOG(ERROR) << ENDPOINT << "Peer sent missing packet: "
                 << *incoming_ack.received_info.missing_packets.rbegin()
                 << " which is greater than largest observed: "
                 << incoming_ack.received_info.largest_observed;
     return false;
   }
 
@@ skipping 237 matching lines @@
   last_rst_frames_.clear();
   last_ack_frames_.clear();
   last_stop_waiting_frames_.clear();
   last_congestion_frames_.clear();
 }
 
 QuicAckFrame* QuicConnection::CreateAckFrame() {
   QuicAckFrame* outgoing_ack = new QuicAckFrame();
   received_packet_manager_.UpdateReceivedPacketInfo(
       &(outgoing_ack->received_info), clock_->ApproximateNow());
-  UpdateStopWaiting(&(outgoing_ack->sent_info));
   DVLOG(1) << ENDPOINT << "Creating ack frame: " << *outgoing_ack;
   return outgoing_ack;
 }
 
 QuicCongestionFeedbackFrame* QuicConnection::CreateFeedbackFrame() {
   return new QuicCongestionFeedbackFrame(outgoing_congestion_feedback_);
 }
 
 QuicStopWaitingFrame* QuicConnection::CreateStopWaitingFrame() {
   QuicStopWaitingFrame stop_waiting;
@@ skipping 657 matching lines @@
 void QuicConnection::UpdateStopWaiting(QuicStopWaitingFrame* stop_waiting) {
   stop_waiting->least_unacked = GetLeastUnacked();
   stop_waiting->entropy_hash = sent_entropy_manager_.EntropyHash(
       stop_waiting->least_unacked - 1);
 }
 
 void QuicConnection::SendPing() {
   if (retransmission_alarm_->IsSet()) {
     return;
   }
-  if (version() <= QUIC_VERSION_16) {
+  if (version() == QUIC_VERSION_16) {
     // TODO(rch): remove this when we remove version 15 and 16.
     // This is a horrible hideous hack which we should not support.
     IOVector data;
     char c_data[] = "C";
     data.Append(c_data, 1);
     QuicConsumedData consumed_data =
         packet_generator_.ConsumeData(kCryptoStreamId, data, 0, false,
                                       MAY_FEC_PROTECT, NULL);
     if (consumed_data.bytes_consumed == 0) {
       DLOG(ERROR) << "Unable to send ping!?";
@@ skipping 10 matching lines @@
   // method is invoked.  This requires changes SetShouldSendAck
   // to be a no-arg method, and re-jiggering its implementation.
   bool send_feedback = false;
   if (received_packet_manager_.GenerateCongestionFeedback(
           &outgoing_congestion_feedback_)) {
     DVLOG(1) << ENDPOINT << "Sending feedback: "
              << outgoing_congestion_feedback_;
     send_feedback = true;
   }
 
-  packet_generator_.SetShouldSendAck(send_feedback,
-                                     version() > QUIC_VERSION_15);
+  packet_generator_.SetShouldSendAck(send_feedback, true);
 }
 
 void QuicConnection::OnRetransmissionTimeout() {
   if (!sent_packet_manager_.HasUnackedPackets()) {
     return;
   }
 
   sent_packet_manager_.OnRetransmissionTimeout();
   WriteIfNotBlocked();
   // In the TLP case, the SentPacketManager gives the connection the opportunity
@@ skipping 358 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net