Land Recent QUIC Changes until 03/22/2015.

net/quic/quic_time_wait_list_manager.cc

 // Copyright 2014 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_time_wait_list_manager.h"
 
 #include <errno.h>
 
 #include "base/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 63 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(QueuedPacket);
 };
 
 QuicTimeWaitListManager::QuicTimeWaitListManager(
     QuicPacketWriter* writer,
     QuicServerSessionVisitor* visitor,
     QuicConnectionHelperInterface* helper,
     const QuicVersionVector& supported_versions)
     : helper_(helper),
-      kTimeWaitPeriod_(
+      time_wait_period_(
           QuicTime::Delta::FromSeconds(FLAGS_quic_time_wait_list_seconds)),
       connection_id_clean_up_alarm_(
           helper_->CreateAlarm(new ConnectionIdCleanUpAlarm(this))),
       writer_(writer),
       visitor_(visitor) {
   SetConnectionIdCleanUpAlarm();
 }
 
 QuicTimeWaitListManager::~QuicTimeWaitListManager() {
   connection_id_clean_up_alarm_->Cancel();
@@ skipping 152 matching lines @@
   return true;
 }
 
 void QuicTimeWaitListManager::SetConnectionIdCleanUpAlarm() {
   connection_id_clean_up_alarm_->Cancel();
   QuicTime now = helper_->GetClock()->ApproximateNow();
   QuicTime next_alarm_time = now;
   if (!connection_id_map_.empty()) {
     QuicTime oldest_connection_id =
         connection_id_map_.begin()->second.time_added;
-    if (now.Subtract(oldest_connection_id) < kTimeWaitPeriod_) {
-      next_alarm_time = oldest_connection_id.Add(kTimeWaitPeriod_);
+    if (now.Subtract(oldest_connection_id) < time_wait_period_) {
+      next_alarm_time = oldest_connection_id.Add(time_wait_period_);
     } else {
       LOG(ERROR) << "ConnectionId lingered for longer than kTimeWaitPeriod";
     }
   } else {
-    // No connection_ids added so none will expire before kTimeWaitPeriod_.
-    next_alarm_time = now.Add(kTimeWaitPeriod_);
+    // No connection_ids added so none will expire before time_wait_period_.
+    next_alarm_time = now.Add(time_wait_period_);
   }
 
   connection_id_clean_up_alarm_->Set(next_alarm_time);
 }
 
 bool QuicTimeWaitListManager::MaybeExpireOldestConnection(
     QuicTime expiration_time) {
   if (connection_id_map_.empty()) {
     return false;
   }
   ConnectionIdMap::iterator it = connection_id_map_.begin();
   QuicTime oldest_connection_id_time = it->second.time_added;
   if (oldest_connection_id_time > expiration_time) {
     // Too recent, don't retire.
     return false;
   }
   // This connection_id has lived its age, retire it now.
   const QuicConnectionId connection_id = it->first;
   delete it->second.close_packet;
   connection_id_map_.erase(it);
   visitor_->OnConnectionRemovedFromTimeWaitList(connection_id);
   return true;
 }
 
 void QuicTimeWaitListManager::CleanUpOldConnectionIds() {
   QuicTime now = helper_->GetClock()->ApproximateNow();
-  QuicTime expiration = now.Subtract(kTimeWaitPeriod_);
+  QuicTime expiration = now.Subtract(time_wait_period_);
 
   while (MaybeExpireOldestConnection(expiration)) {
   }
 
   SetConnectionIdCleanUpAlarm();
 }
 
 void QuicTimeWaitListManager::TrimTimeWaitListIfNeeded() {
   if (FLAGS_quic_time_wait_list_max_connections < 0) {
     return;
   }
   while (num_connections() >=
          static_cast<size_t>(FLAGS_quic_time_wait_list_max_connections)) {
     MaybeExpireOldestConnection(QuicTime::Infinite());
   }
 }
 
 }  // namespace net