* Removed QuicTag kQuicVersion1

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 <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 51 matching lines @@
   return delta <= kMaxPacketGap;
 }
 
 }  // namespace
 
 #define ENDPOINT (is_server_ ? "Server: " : " Client: ")
 
 QuicConnection::QuicConnection(QuicGuid guid,
                                IPEndPoint address,
                                QuicConnectionHelperInterface* helper,
-                               bool is_server)
-    : framer_(kQuicVersion1,
+                               bool is_server,
+                               QuicVersion version)
+    : framer_(version,
               helper->GetClock()->ApproximateNow(),
               is_server),
       helper_(helper),
       encryption_level_(ENCRYPTION_NONE),
       clock_(helper->GetClock()),
       random_generator_(helper->GetRandomGenerator()),
       guid_(guid),
       peer_address_(address),
       largest_seen_packet_with_ack_(0),
       peer_largest_observed_packet_(0),
@@ skipping 42 matching lines @@
   STLDeleteValues(&unacked_packets_);
   STLDeleteValues(&group_map_);
   for (QueuedPacketList::iterator it = queued_packets_.begin();
        it != queued_packets_.end(); ++it) {
     delete it->packet;
   }
   DLOG(INFO) << ENDPOINT << "write_blocked: " << write_blocked_;
 }
 
 bool QuicConnection::SelectMutualVersion(
-    const QuicTagVector& available_versions) {
-  // TODO(satyamshekhar): Make this generic.
-  if (std::find(available_versions.begin(), available_versions.end(),
-                kQuicVersion1) == available_versions.end()) {
-    return false;
+    const QuicVersionVector& available_versions) {
+  // Try to find the highest mutual version by iterating over supported
+  // versions, starting with the highest, and breaking out of the loop once we
+  // find a matching version in the provided available_versions vector.
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kSupportedQuicVersions); ++i) {
+    const QuicVersion& version = kSupportedQuicVersions[i];
+    if (std::find(available_versions.begin(), available_versions.end(),
+                  version) != available_versions.end()) {
+      framer_.set_version(version);
+      return true;
+    }
   }
 
-  // Right now we only support kQuicVersion1 so it's okay not to
-  // update the framer version. When we start supporting more
-  // versions please update.
-  return true;
+  return false;
 }
 
 void QuicConnection::OnError(QuicFramer* framer) {
   // Packets that we cannot decrypt are dropped.
   // TODO(rch): add stats to measure this.
   if (!connected_ || framer->error() == QUIC_DECRYPTION_FAILURE) {
     return;
   }
   SendConnectionClose(framer->error());
 }
 
 void QuicConnection::OnPacket() {
 }
 
 void QuicConnection::OnPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   if (debug_visitor_) {
     debug_visitor_->OnPublicResetPacket(packet);
   }
   CloseConnection(QUIC_PUBLIC_RESET, true);
 }
 
-bool QuicConnection::OnProtocolVersionMismatch(QuicTag received_version) {
+bool QuicConnection::OnProtocolVersionMismatch(QuicVersion received_version) {
   // TODO(satyamshekhar): Implement no server state in this mode.
   if (!is_server_) {
     LOG(DFATAL) << ENDPOINT << "Framer called OnProtocolVersionMismatch. "
                 << "Closing connection.";
     CloseConnection(QUIC_INTERNAL_ERROR, false);
     return false;
   }
   DCHECK_NE(version(), received_version);
 
   if (debug_visitor_) {
@@ skipping 18 matching lines @@
 
     case NEGOTIATED_VERSION:
       // Might be old packets that were sent by the client before the version
       // was negotiated. Drop these.
       return false;
 
     default:
       DCHECK(false);
   }
 
-  // Right now we only support kQuicVersion1 so it's okay not to
-  // update the framer version. When we start supporting more
-  // versions please update.
   version_negotiation_state_ = NEGOTIATED_VERSION;
+
+  // Store the new version.
+  framer_.set_version(received_version);
+
   // TODO(satyamshekhar): Store the sequence number of this packet and close the
   // connection if we ever received a packet with incorrect version and whose
   // sequence number is greater.
   return true;
 }
 
 // Handles version negotiation for client connection.
 void QuicConnection::OnVersionNegotiationPacket(
     const QuicVersionNegotiationPacket& packet) {
   if (is_server_) {
@@ skipping 468 matching lines @@
     SendAck();
   } else if (!last_stream_frames_.empty()) {
     // TODO(alyssar) this case should really be "if the packet contained any
     // non-ack frame", rather than "if the packet contained a stream frame"
     helper_->SetAckAlarm(congestion_manager_.DefaultRetransmissionTime());
   }
   send_ack_in_response_to_packet_ = !send_ack_in_response_to_packet_;
 }
 
 void QuicConnection::SendVersionNegotiationPacket() {
-  QuicTagVector supported_versions;
-  supported_versions.push_back(kQuicVersion1);
+  QuicVersionVector supported_versions;
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kSupportedQuicVersions); ++i) {
+    supported_versions.push_back(kSupportedQuicVersions[i]);
+  }
   QuicEncryptedPacket* encrypted =
       packet_creator_.SerializeVersionNegotiationPacket(supported_versions);
   // TODO(satyamshekhar): implement zero server state negotiation.
   int error;
   helper_->WritePacketToWire(*encrypted, &error);
   delete encrypted;
 }
 
 QuicConsumedData QuicConnection::SendStreamData(QuicStreamId id,
                                                 base::StringPiece data,
@@ skipping 852 matching lines @@
     if (connection_timeout < timeout) {
       timeout = connection_timeout;
     }
   }
 
   helper_->SetTimeoutAlarm(timeout);
   return false;
 }
 
 }  // namespace net