Land Recent QUIC changes.

net/tools/quic/quic_time_wait_list_manager.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/tools/quic/quic_time_wait_list_manager.h"
 
 #include <errno.h>
 
 #include "base/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_clock.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 
+using std::make_pair;
+
 namespace net {
 namespace tools {
 
 namespace {
 
 // Time period for which the guid should live in time wait state..
 const int kTimeWaitSeconds = 5;
 
 }  // namespace
 
@@ skipping 53 matching lines @@
   const IPEndPoint server_address_;
   const IPEndPoint client_address_;
   scoped_ptr<QuicEncryptedPacket> packet_;
 
   DISALLOW_COPY_AND_ASSIGN(QueuedPacket);
 };
 
 QuicTimeWaitListManager::QuicTimeWaitListManager(
     QuicPacketWriter* writer,
     EpollServer* epoll_server)
-    : framer_(kQuicVersion1,
+    : framer_(QUIC_VERSION_6,
               QuicTime::Zero(),  // unused
               true),
       epoll_server_(epoll_server),
       kTimeWaitPeriod_(QuicTime::Delta::FromSeconds(kTimeWaitSeconds)),
       guid_clean_up_alarm_(new GuidCleanUpAlarm(this)),
       clock_(epoll_server),
       writer_(writer),
       is_write_blocked_(false) {
   framer_.set_visitor(this);
   SetGuidCleanUpAlarm();
 }
 
 QuicTimeWaitListManager::~QuicTimeWaitListManager() {
   guid_clean_up_alarm_->UnregisterIfRegistered();
   STLDeleteElements(&time_ordered_guid_list_);
   STLDeleteElements(&pending_packets_queue_);
 }
 
-void QuicTimeWaitListManager::AddGuidToTimeWait(QuicGuid guid) {
+void QuicTimeWaitListManager::AddGuidToTimeWait(QuicGuid guid,
+                                                QuicVersion version) {
   DCHECK(!IsGuidInTimeWait(guid));
   // Initialize the guid with 0 packets received.
-  guid_map_.insert(std::make_pair(guid, 0));
+  GuidData data(0, version);
+  guid_map_.insert(make_pair(guid, data));
   time_ordered_guid_list_.push_back(new GuidAddTime(guid,
                                                     clock_.ApproximateNow()));
 }
 
 bool QuicTimeWaitListManager::IsGuidInTimeWait(QuicGuid guid) const {
   return guid_map_.find(guid) != guid_map_.end();
 }
 
 void QuicTimeWaitListManager::ProcessPacket(
     const IPEndPoint& server_address,
     const IPEndPoint& client_address,
     QuicGuid guid,
     const QuicEncryptedPacket& packet) {
   DCHECK(IsGuidInTimeWait(guid));
   server_address_ = server_address;
   client_address_ = client_address;
-  // TODO(satyamshekhar): Also store the version of protocol for and
-  // update the protocol version of the framer before processing.
+
+  // Set the framer to the appropriate version for this GUID, before processing.
+  QuicVersion version = GetQuicVersionFromGuid(guid);
+  framer_.set_version(version);
+
   framer_.ProcessPacket(packet);
 }
 
+QuicVersion QuicTimeWaitListManager::GetQuicVersionFromGuid(QuicGuid guid) {
+  GuidMapIterator it = guid_map_.find(guid);
+  DCHECK(it != guid_map_.end());
+  return (it->second).version;
+}
+
 bool QuicTimeWaitListManager::OnCanWrite() {
   is_write_blocked_ = false;
   while (!is_write_blocked_ && !pending_packets_queue_.empty()) {
     QueuedPacket* queued_packet = pending_packets_queue_.front();
     WriteToWire(queued_packet);
     if (!is_write_blocked_) {
       pending_packets_queue_.pop_front();
       delete queued_packet;
     }
   }
 
   return !is_write_blocked_;
 }
 
 void QuicTimeWaitListManager::OnError(QuicFramer* framer) {
   DLOG(INFO) << QuicUtils::ErrorToString(framer->error());
 }
 
 bool QuicTimeWaitListManager::OnProtocolVersionMismatch(
-    QuicTag received_version) {
+    QuicVersion received_version) {
   // Drop such packets whose version don't match.
   return false;
 }
 
 bool QuicTimeWaitListManager::OnStreamFrame(const QuicStreamFrame& frame) {
   return false;
 }
 
 bool QuicTimeWaitListManager::OnAckFrame(const QuicAckFrame& frame) {
   return false;
@@ skipping 17 matching lines @@
 bool QuicTimeWaitListManager::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
   return false;
 }
 
 bool QuicTimeWaitListManager::OnPacketHeader(const QuicPacketHeader& header) {
   // TODO(satyamshekhar): Think about handling packets from different client
   // addresses.
   GuidMapIterator it = guid_map_.find(header.public_header.guid);
   DCHECK(it != guid_map_.end());
   // Increment the received packet count.
-  ++(it->second);
-  if (ShouldSendPublicReset(it->second)) {
+  ++((it->second).num_packets);
+  if (ShouldSendPublicReset((it->second).num_packets)) {
     // We don't need the packet anymore. Just tell the client what sequence
     // number we rejected.
     SendPublicReset(server_address_,
                     client_address_,
                     header.public_header.guid,
                     header.packet_sequence_number);
   }
   // Never process the body of the packet in time wait state.
   return false;
 }
@@ skipping 92 matching lines @@
     // This guid has lived its age, retire it now.
     guid_map_.erase(oldest_guid->guid);
     time_ordered_guid_list_.pop_front();
     delete oldest_guid;
   }
   SetGuidCleanUpAlarm();
 }
 
 }  // namespace tools
 }  // namespace net