Cleanup changes: Rename QuicSession::MarkWriteBlocked to

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 <limits>
 
 #include "base/logging.h"
 
@@ skipping 97 matching lines @@
   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.
   internal_node_free_head_ = 0;
-  for (unsigned i = 0; i < max_entries_ - 1; i++)
+  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;
-  for (unsigned i = 0; i < max_entries_ - 1; i++)
+  for (unsigned i = 0; i < max_entries_ - 1; i++) {
     external_node_next_ptr(i) = i + 1;
+  }
   external_node_next_ptr(max_entries_ - 1) = kNil;
 
   // This is the root of the tree.
   internal_node_head_ = kNil;
 }
 
 InsertStatus StrikeRegister::Insert(const uint8 nonce[32],
                                     uint32 current_time_external) {
   // Make space for the insertion if the strike register is full.
   while (external_node_free_head_ == kNil ||
@@ skipping 161 matching lines @@
     CHECK_LT(i, max_entries_);
     CHECK_EQ(free_external_nodes.count(i), 0u);
     free_external_nodes.insert(i);
   }
 
   set<uint32> used_external_nodes;
   set<uint32> used_internal_nodes;
 
   if (internal_node_head_ != kNil &&
       ((internal_node_head_ >> 8) & kExternalFlag) == 0) {
-    vector<pair<unsigned, bool> > bits;
+    vector<pair<unsigned, bool>> bits;
     ValidateTree(internal_node_head_ >> 8, -1, bits, free_internal_nodes,
                  free_external_nodes, &used_internal_nodes,
                  &used_external_nodes);
   }
 }
 
 // static
 uint32 StrikeRegister::TimeFromBytes(const uint8 d[4]) {
   return static_cast<uint32>(d[0]) << 24 |
          static_cast<uint32>(d[1]) << 16 |
@@ skipping 116 matching lines @@
 void StrikeRegister::FreeExternalNode(uint32 index) {
   external_node_next_ptr(index) = external_node_free_head_;
   external_node_free_head_ = index;
 }
 
 void StrikeRegister::FreeInternalNode(uint32 index) {
   internal_nodes_[index].SetNextPtr(internal_node_free_head_);
   internal_node_free_head_ = index;
 }
 
-void StrikeRegister::ValidateTree(
-    uint32 internal_node,
-    int last_bit,
-    const vector<pair<unsigned, bool> >& bits,
-    const set<uint32>& free_internal_nodes,
-    const set<uint32>& free_external_nodes,
-    set<uint32>* used_internal_nodes,
-    set<uint32>* used_external_nodes) {
+void StrikeRegister::ValidateTree(uint32 internal_node,
+                                  int last_bit,
+                                  const vector<pair<unsigned, bool>>& bits,
+                                  const set<uint32>& free_internal_nodes,
+                                  const set<uint32>& free_external_nodes,
+                                  set<uint32>* used_internal_nodes,
+                                  set<uint32>* used_external_nodes) {
   CHECK_LT(internal_node, max_entries_);
   const InternalNode* i = &internal_nodes_[internal_node];
   unsigned bit = 0;
   switch (i->otherbits()) {
     case 0xff & ~(1 << 7):
       bit = 0;
       break;
     case 0xff & ~(1 << 6):
       bit = 1;
       break;
@@ skipping 36 matching lines @@
       for (const pair<unsigned, bool>& pair : bits) {
         unsigned byte = pair.first / 8;
         DCHECK_LE(byte, 0xffu);
         unsigned bit_new = pair.first % 8;
         static const uint8 kMasks[8] =
             {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
         CHECK_EQ((bytes[byte] & kMasks[bit_new]) != 0, pair.second);
       }
     } else {
       uint32 inter = i->child(child);
-      vector<pair<unsigned, bool> > new_bits(bits);
+      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