Clang format slam.

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 74 matching lines @@
       horizon_valid_(startup == DENY_REQUESTS_AT_STARTUP) {
   memcpy(orbit_, orbit, sizeof(orbit_));
 
   ValidateStrikeRegisterConfig(max_entries);
   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 157 matching lines @@
     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;
-    ValidateTree(internal_node_head_ >> 8, -1, bits, free_internal_nodes,
-                 free_external_nodes, &used_internal_nodes,
+    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 |
-         static_cast<uint32>(d[2]) << 8 |
-         static_cast<uint32>(d[3]);
+  return static_cast<uint32>(d[0]) << 24 | static_cast<uint32>(d[1]) << 16 |
+         static_cast<uint32>(d[2]) << 8 | static_cast<uint32>(d[3]);
 }
 
 uint32 StrikeRegister::ExternalTimeToInternal(uint32 external_time) {
   return external_time - internal_epoch_;
 }
 
 uint32 StrikeRegister::BestMatch(const uint8 v[24]) const {
   if (internal_node_head_ == kNil) {
     return kNil;
   }
@@ skipping 83 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):
+    case 0xff & ~(1 << 7) :
       bit = 0;
       break;
-    case 0xff & ~(1 << 6):
+    case 0xff & ~(1 << 6) :
       bit = 1;
       break;
-    case 0xff & ~(1 << 5):
+    case 0xff & ~(1 << 5) :
       bit = 2;
       break;
-    case 0xff & ~(1 << 4):
+    case 0xff & ~(1 << 4) :
       bit = 3;
       break;
-    case 0xff & ~(1 << 3):
+    case 0xff & ~(1 << 3) :
       bit = 4;
       break;
-    case 0xff & ~(1 << 2):
+    case 0xff & ~(1 << 2) :
       bit = 5;
       break;
-    case 0xff & ~(1 << 1):
+    case 0xff & ~(1 << 1) :
       bit = 6;
       break;
     case 0xff & ~1:
       bit = 7;
       break;
     default:
       CHECK(false);
   }
 
   bit += 8 * i->critbyte();
   if (last_bit > -1) {
     CHECK_GT(bit, static_cast<unsigned>(last_bit));
   }
 
   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++) {
+           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};
+        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);
+      ValidateTree(inter,
+                   bit,
+                   bits,
+                   free_internal_nodes,
+                   free_external_nodes,
+                   used_internal_nodes,
+                   used_external_nodes);
     }
   }
 }
 
 }  // namespace net