Land Recent QUIC changes

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 19 matching lines @@
   void SetCritByte(uint8 critbyte) {
     data_[0] &= 0xffffff00;
     data_[0] |= critbyte;
   }
 
   void SetOtherBits(uint8 otherbits) {
     data_[1] &= 0xffffff00;
     data_[1] |= otherbits;
   }
 
-  void SetNextPtr(uint32 next) {
-    data_[0] = next;
-  }
+  void SetNextPtr(uint32 next) { data_[0] = next; }
 
-  uint32 next() const {
-    return data_[0];
-  }
+  uint32 next() const { return data_[0]; }
 
-  uint32 child(unsigned n) const {
-    return data_[n] >> 8;
-  }
+  uint32 child(unsigned n) const { return data_[n] >> 8; }
 
-  uint8 critbyte() const {
-    return data_[0];
-  }
+  uint8 critbyte() const { return data_[0]; }
 
-  uint8 otherbits() const {
-    return data_[1];
-  }
+  uint8 otherbits() const { return data_[1]; }
 
   // These bytes are organised thus:
   //   <24 bits> left child
   //   <8 bits> crit-byte
   //   <24 bits> right child
   //   <8 bits> other-bits
   uint32 data_[2];
 };
 
 StrikeRegister::StrikeRegister(unsigned max_entries,
@@ skipping 12 matching lines @@
   // 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.
   internal_nodes_ = new InternalNode[max_entries];
   external_nodes_.reset(new uint8[kExternalNodeSize * max_entries]);
 
   Reset();
 }
 
-StrikeRegister::~StrikeRegister() {
-  delete[] internal_nodes_;
-}
+StrikeRegister::~StrikeRegister() { delete[] internal_nodes_; }
 
 void StrikeRegister::Reset() {
   // Thread a free list through all of the internal nodes.
   internal_node_free_head_ = 0;
   for (unsigned i = 0; i < max_entries_ - 1; i++)
     internal_nodes_[i].SetNextPtr(i + 1);
   internal_nodes_[max_entries_ - 1].SetNextPtr(kNil);
 
   // Also thread a free list through the external nodes.
   external_node_free_head_ = 0;
@@ skipping 131 matching lines @@
         node->otherbits() > new_other_bits) {
       break;
     }
     if (node->critbyte() == differing_byte &&
         node->otherbits() == new_other_bits) {
       CHECK(false);
     }
 
     uint8 c = value[node->critbyte()];
     const int direction =
-      (1 + static_cast<unsigned>(node->otherbits() | c)) >> 8;
+        (1 + static_cast<unsigned>(node->otherbits() | c)) >> 8;
     where_index = &node->data_[direction];
   }
 
   inode->SetChild(newdirection ^ 1, *where_index >> 8);
   *where_index = (*where_index & 0xff) | (internal_node_index << 8);
 
   return true;
 }
 
 void StrikeRegister::Validate() {
@@ skipping 36 matching lines @@
 uint32 StrikeRegister::BestMatch(const uint8 v[24]) const {
   if (internal_node_head_ == kNil) {
     return kNil;
   }
 
   uint32 next = internal_node_head_ >> 8;
   while ((next & kExternalFlag) == 0) {
     InternalNode* node = &internal_nodes_[next];
     uint8 b = v[node->critbyte()];
     unsigned direction =
-      (1 + static_cast<unsigned>(node->otherbits() | b)) >> 8;
+        (1 + static_cast<unsigned>(node->otherbits() | b)) >> 8;
     next = node->child(direction);
   }
 
   return next & ~kExternalFlag;
 }
 
 uint32& StrikeRegister::external_node_next_ptr(unsigned i) {
   return *reinterpret_cast<uint32*>(&external_nodes_[i * kExternalNodeSize]);
 }
 
@@ skipping 27 matching lines @@
   // DropNode should never be called on an empty tree.
   DCHECK(internal_node_head_ != kNil);
 
   // An internal node in a crit-bit tree always has exactly two children.
   // This means that, if we are removing an external node (which is one of
   // those children), then we also need to remove an internal node. In order
   // to do that we keep pointers to the parent (wherep) and grandparent
   // (whereq) when walking down the tree.
 
   uint32 p = internal_node_head_ >> 8, *wherep = &internal_node_head_,
-             *whereq = NULL;
+         *whereq = NULL;
   while ((p & kExternalFlag) == 0) {
     whereq = wherep;
     InternalNode* inode = &internal_nodes_[p];
     // We always go left, towards the smallest element, exploiting the fact
     // that the timestamp is big-endian and at the start of the value.
     wherep = &inode->data_[0];
     p = (*wherep) >> 8;
   }
 
   const uint32 ext_index = p & ~kExternalFlag;
@@ skipping 72 matching lines @@
 
   CHECK_EQ(free_internal_nodes.count(internal_node), 0u);
 
   for (unsigned child = 0; child < 2; child++) {
     if (i->child(child) & kExternalFlag) {
       uint32 ext = i->child(child) & ~kExternalFlag;
       CHECK_EQ(free_external_nodes.count(ext), 0u);
       CHECK_EQ(used_external_nodes->count(ext), 0u);
       used_external_nodes->insert(ext);
       const uint8* bytes = external_node(ext);
-      for (vector<pair<unsigned, bool> >::const_iterator
-           i = bits.begin(); i != bits.end(); i++) {
+      for (vector<pair<unsigned, bool> >::const_iterator i = bits.begin();
+           i != bits.end(); i++) {
         unsigned byte = i->first / 8;
         DCHECK_LE(byte, 0xffu);
         unsigned bit = i->first % 8;
         static const uint8 kMasks[8] =
             {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
         CHECK_EQ((bytes[byte] & kMasks[bit]) != 0, i->second);
       }
     } else {
       uint32 inter = i->child(child);
       vector<pair<unsigned, bool> > new_bits(bits);
       new_bits.push_back(pair<unsigned, bool>(bit, child != 0));
       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