Narrow the strike register window in both directions when tracking many

net/quic/crypto/strike_register.h

 // Copyright (c) 2013 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.
 
 #ifndef NET_QUIC_CRYPTO_STRIKE_REGISTER_H_
 #define NET_QUIC_CRYPTO_STRIKE_REGISTER_H_
 
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 98 matching lines @@
   //   d) already in the set of observed nonces
   // and returns false if any of these are true. It is also free to return
   // false for other reasons as it's always safe to reject an nonce.
   //
   // nonces are:
   //   4 bytes of timestamp (UNIX epoch seconds)
   //   8 bytes of orbit value (a cluster id)
   //   20 bytes of random data
   //
   // Otherwise, it inserts |nonce| into the observed set and returns true.
-  bool Insert(const uint8 nonce[32], const uint32 current_time);
+  bool Insert(const uint8 nonce[32], uint32 current_time);
 
   // orbit returns a pointer to the 8-byte orbit value for this
   // strike-register.
   const uint8* orbit() const;
 
   // Time window for which the strike register has complete information.
-  uint32 EffectiveWindowSecs(const uint32 current_time_external) const;
+  uint32 GetCurrentValidWindowSecs(uint32 current_time_external) const;
 
   // This is a debugging aid which checks the tree for sanity.
   void Validate();
 
  private:
   class InternalNode;
 
   // TimeFromBytes returns a big-endian uint32 from |d|.
   static uint32 TimeFromBytes(const uint8 d[4]);
 
+  // Range of internal times for which the strike register has
+  // complete information.  A nonce is within the valid range of the
+  // strike register if:
+  //   valid_range.first <= nonce_time_internal <= valid_range.second
+  std::pair<uint32, uint32> GetValidRange(uint32 current_time_internal) const;
+
   // ExternalTimeToInternal converts an external time value into an internal
   // time value using |internal_epoch_|.
   uint32 ExternalTimeToInternal(uint32 external_time) const;
 
   // BestMatch returns either kNil, or an external node index which could
   // possibly match |v|.
   uint32 BestMatch(const uint8 v[24]) const;
 
   // external_node_next_ptr returns the 'next' pointer embedded in external
   // node |i|. This is used to thread a free list through the external nodes.
@@ skipping 20 matching lines @@
                     const std::set<uint32>& free_external_nodes,
                     std::set<uint32>* used_internal_nodes,
                     std::set<uint32>* used_external_nodes);
 
   const uint32 max_entries_;
   const uint32 window_secs_;
   // internal_epoch_ contains the external time value of the start of internal
   // time.
   const uint32 internal_epoch_;
   uint8 orbit_[8];
+  // The strike register will reject nonces with internal times < |horizon_| .
   uint32 horizon_;
 
   uint32 internal_node_free_head_;
   uint32 external_node_free_head_;
   uint32 internal_node_head_;
   // internal_nodes_ can't be a scoped_ptr because the type isn't defined in
   // this header.
   InternalNode* internal_nodes_;
   scoped_ptr<uint8[]> external_nodes_;
 
   DISALLOW_COPY_AND_ASSIGN(StrikeRegister);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CRYPTO_STRIKE_REGISTER_H_