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_flags.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
-#include "net/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_server_session.h"
 
 using base::StringPiece;
 
 namespace net {
 namespace tools {
 
 // TODO(rtenneti): Remove the duplicated code in this file. Share code with
 // "net/quic/quic_time_wait_list_manager.cc"
 
 // A very simple alarm that just informs the QuicTimeWaitListManager to clean
-// up old connection_ids. This alarm should be unregistered and deleted before
+// up old connection_ids. This alarm should be cancelled  and deleted before
 // the QuicTimeWaitListManager is deleted.
-class ConnectionIdCleanUpAlarm : public EpollAlarm {
+class ConnectionIdCleanUpAlarm : public QuicAlarm::Delegate {
  public:
   explicit ConnectionIdCleanUpAlarm(
       QuicTimeWaitListManager* time_wait_list_manager)
       : time_wait_list_manager_(time_wait_list_manager) {
   }
 
-  int64 OnAlarm() override {
-    EpollAlarm::OnAlarm();
+  QuicTime OnAlarm() override {
     time_wait_list_manager_->CleanUpOldConnectionIds();
     // Let the time wait manager register the alarm at appropriate time.
-    return 0;
+    return QuicTime::Zero();
   }
 
  private:
   // Not owned.
   QuicTimeWaitListManager* time_wait_list_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(ConnectionIdCleanUpAlarm);
 };
 
+
 // This class stores pending public reset packets to be sent to clients.
 // server_address - server address on which a packet what was received for
 //                  a connection_id in time wait state.
 // client_address - address of the client that sent that packet. Needed to send
 //                  the public reset packet back to the client.
 // packet - the pending public reset packet that is to be sent to the client.
 //          created instance takes the ownership of this packet.
 class QuicTimeWaitListManager::QueuedPacket {
  public:
   QueuedPacket(const IPEndPoint& server_address,
@@ skipping 12 matching lines @@
   const IPEndPoint server_address_;
   const IPEndPoint client_address_;
   scoped_ptr<QuicEncryptedPacket> packet_;
 
   DISALLOW_COPY_AND_ASSIGN(QueuedPacket);
 };
 
 QuicTimeWaitListManager::QuicTimeWaitListManager(
     QuicPacketWriter* writer,
     QuicServerSessionVisitor* visitor,
-    EpollServer* epoll_server,
+    QuicConnectionHelperInterface* helper,
     const QuicVersionVector& supported_versions)
-    : epoll_server_(epoll_server),
-      kTimeWaitPeriod_(
+    : time_wait_period_(
           QuicTime::Delta::FromSeconds(FLAGS_quic_time_wait_list_seconds)),
-      connection_id_clean_up_alarm_(new ConnectionIdCleanUpAlarm(this)),
-      clock_(epoll_server_),
+      connection_id_clean_up_alarm_(
+          helper->CreateAlarm(new ConnectionIdCleanUpAlarm(this))),
+      clock_(helper->GetClock()),
       writer_(writer),
       visitor_(visitor) {
   SetConnectionIdCleanUpAlarm();
 }
 
 QuicTimeWaitListManager::~QuicTimeWaitListManager() {
-  connection_id_clean_up_alarm_->UnregisterIfRegistered();
+  connection_id_clean_up_alarm_->Cancel();
   STLDeleteElements(&pending_packets_queue_);
   for (ConnectionIdMap::iterator it = connection_id_map_.begin();
        it != connection_id_map_.end();
        ++it) {
     delete it->second.close_packet;
   }
 }
 
 void QuicTimeWaitListManager::AddConnectionIdToTimeWait(
     QuicConnectionId connection_id,
     QuicVersion version,
     QuicEncryptedPacket* close_packet) {
   int num_packets = 0;
   ConnectionIdMap::iterator it = connection_id_map_.find(connection_id);
   const bool new_connection_id = it == connection_id_map_.end();
   if (!new_connection_id) {  // Replace record if it is reinserted.
     num_packets = it->second.num_packets;
     delete it->second.close_packet;
     connection_id_map_.erase(it);
   }
   TrimTimeWaitListIfNeeded();
   DCHECK_LT(num_connections(),
             static_cast<size_t>(FLAGS_quic_time_wait_list_max_connections));
   ConnectionIdData data(num_packets,
                         version,
-                        clock_.ApproximateNow(),
+                        clock_->ApproximateNow(),
                         close_packet);
   connection_id_map_.insert(std::make_pair(connection_id, data));
   if (new_connection_id) {
     visitor_->OnConnectionAddedToTimeWaitList(connection_id);
   }
 }
 
 bool QuicTimeWaitListManager::IsConnectionIdInTimeWait(
     QuicConnectionId connection_id) const {
   return ContainsKey(connection_id_map_, connection_id);
@@ skipping 110 matching lines @@
     return writer_->IsWriteBlockedDataBuffered();
   } else if (result.status == WRITE_STATUS_ERROR) {
     LOG(WARNING) << "Received unknown error while sending reset packet to "
                  << queued_packet->client_address().ToString() << ": "
                  << strerror(result.error_code);
   }
   return true;
 }
 
 void QuicTimeWaitListManager::SetConnectionIdCleanUpAlarm() {
-  connection_id_clean_up_alarm_->UnregisterIfRegistered();
-  int64 next_alarm_interval;
+  connection_id_clean_up_alarm_->Cancel();
+  QuicTime::Delta next_alarm_interval = QuicTime::Delta::Zero();
   if (!connection_id_map_.empty()) {
     QuicTime oldest_connection_id =
         connection_id_map_.begin()->second.time_added;
-    QuicTime now = clock_.ApproximateNow();
-    if (now.Subtract(oldest_connection_id) < kTimeWaitPeriod_) {
-      next_alarm_interval = oldest_connection_id.Add(kTimeWaitPeriod_)
-                                                .Subtract(now)
-                                                .ToMicroseconds();
+    QuicTime now = clock_->ApproximateNow();
+    if (now.Subtract(oldest_connection_id) < time_wait_period_) {
+      next_alarm_interval = oldest_connection_id.Add(time_wait_period_)
+                                                .Subtract(now);
     } else {
-      LOG(ERROR) << "ConnectionId lingered for longer than kTimeWaitPeriod";
-      next_alarm_interval = 0;
+      LOG(ERROR) << "ConnectionId lingered for longer than time_wait_period_";
     }
   } else {
-    // No connection_ids added so none will expire before kTimeWaitPeriod_.
-    next_alarm_interval = kTimeWaitPeriod_.ToMicroseconds();
+    // No connection_ids added so none will expire before time_wait_period_.
+    next_alarm_interval = time_wait_period_;
   }
 
-  epoll_server_->RegisterAlarmApproximateDelta(
-      next_alarm_interval, connection_id_clean_up_alarm_.get());
+  connection_id_clean_up_alarm_->Set(
+      clock_->ApproximateNow().Add(next_alarm_interval));
 }
 
 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 = clock_.ApproximateNow();
-  QuicTime expiration = now.Subtract(kTimeWaitPeriod_);
+  QuicTime now = clock_->ApproximateNow();
+  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 tools
 }  // namespace net