Doing early validation of quic config, to change a potential

net/quic/crypto/strike_register.cc

 // 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.
 
 #include "net/quic/crypto/strike_register.h"
 
 #include "base/logging.h"
 
 using std::pair;
 using std::set;
@@ skipping 42 matching lines @@
   //   <24 bits> right child
   //   <8 bits> other-bits
   uint32 data_[2];
 };
 
 // kCreationTimeFromInternalEpoch contains the number of seconds between the
 // start of the internal epoch and the creation time. This allows us
 // to consider times that are before the creation time.
 static const uint32 kCreationTimeFromInternalEpoch = 63115200.0;  // 2 years.
 
+void StrikeRegister::ValidateStrikeRegisterConfig(unsigned max_entries) {
+  // We only have 23 bits of index available.
+  CHECK_LT(max_entries, 1u << 23);
+  CHECK_GT(max_entries, 1u);           // There must be at least two entries.
+  CHECK_EQ(sizeof(InternalNode), 8u);  // in case of compiler changes.
+}
+
 StrikeRegister::StrikeRegister(unsigned max_entries,
                                uint32 current_time,
                                uint32 window_secs,
                                const uint8 orbit[8],
                                StartupType startup)
     : max_entries_(max_entries),
       window_secs_(window_secs),
       internal_epoch_(current_time > kCreationTimeFromInternalEpoch
                           ? current_time - kCreationTimeFromInternalEpoch
                           : 0),
       // The horizon is initially set |window_secs| into the future because, if
       // we just crashed, then we may have accepted nonces in the span
       // [current_time...current_time+window_secs) and so we conservatively
       // reject the whole timespan unless |startup| tells us otherwise.
       horizon_(ExternalTimeToInternal(current_time) + window_secs),
       horizon_valid_(startup == DENY_REQUESTS_AT_STARTUP) {
   memcpy(orbit_, orbit, sizeof(orbit_));
 
-  // We only have 23 bits of index available.
-  CHECK_LT(max_entries, 1u << 23);
-  CHECK_GT(max_entries, 1u);           // There must be at least two entries.
-  CHECK_EQ(sizeof(InternalNode), 8u);  // in case of compiler changes.
+  ValidateStrikeRegisterConfig(max_entries);
   internal_nodes_ = new InternalNode[max_entries];
   external_nodes_.reset(new uint8[kExternalNodeSize * max_entries]);
 
   Reset();
 }
 
 StrikeRegister::~StrikeRegister() { delete[] internal_nodes_; }
 
 void StrikeRegister::Reset() {
   // Thread a free list through all of the internal nodes.
@@ skipping 356 matching lines @@
       CHECK_EQ(free_internal_nodes.count(inter), 0u);
       CHECK_EQ(used_internal_nodes->count(inter), 0u);
       used_internal_nodes->insert(inter);
       ValidateTree(inter, bit, bits, free_internal_nodes, free_external_nodes,
                    used_internal_nodes, used_external_nodes);
     }
   }
 }
 
 }  // namespace net