Clang format slam.

net/spdy/hpack_huffman_table.cc

 // Copyright 2014 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/spdy/hpack_huffman_table.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
@@ skipping 12 matching lines @@
 // Maximum number of bits to index in successive decode tables.
 const uint8 kDecodeTableBranchBits = 6;
 
 bool SymbolLengthAndIdCompare(const HpackHuffmanSymbol& a,
                               const HpackHuffmanSymbol& b) {
   if (a.length == b.length) {
     return a.id < b.id;
   }
   return a.length < b.length;
 }
-bool SymbolIdCompare(const HpackHuffmanSymbol& a,
-                     const HpackHuffmanSymbol& b) {
+bool SymbolIdCompare(const HpackHuffmanSymbol& a, const HpackHuffmanSymbol& b) {
   return a.id < b.id;
 }
 
 }  // namespace
 
 HpackHuffmanTable::DecodeEntry::DecodeEntry()
-  : next_table_index(0), length(0), symbol_id(0) {
+    : next_table_index(0), length(0), symbol_id(0) {
 }
 HpackHuffmanTable::DecodeEntry::DecodeEntry(uint8 next_table_index,
                                             uint8 length,
                                             uint16 symbol_id)
-  : next_table_index(next_table_index), length(length), symbol_id(symbol_id) {
+    : next_table_index(next_table_index), length(length), symbol_id(symbol_id) {
 }
 size_t HpackHuffmanTable::DecodeTable::size() const {
   return size_t(1) << indexed_length;
 }
 
-HpackHuffmanTable::HpackHuffmanTable() {}
+HpackHuffmanTable::HpackHuffmanTable() {
+}
 
-HpackHuffmanTable::~HpackHuffmanTable() {}
+HpackHuffmanTable::~HpackHuffmanTable() {
+}
 
 bool HpackHuffmanTable::Initialize(const HpackHuffmanSymbol* input_symbols,
                                    size_t symbol_count) {
   CHECK(!IsInitialized());
 
   std::vector<Symbol> symbols(symbol_count);
   // Validate symbol id sequence, and copy into |symbols|.
   for (size_t i = 0; i != symbol_count; i++) {
     if (i != input_symbols[i].id) {
       failed_symbol_id_ = i;
       return false;
     }
     symbols[i] = input_symbols[i];
   }
   // Order on length and ID ascending, to verify symbol codes are canonical.
   std::sort(symbols.begin(), symbols.end(), SymbolLengthAndIdCompare);
   if (symbols[0].code != 0) {
     failed_symbol_id_ = 0;
     return false;
   }
   for (size_t i = 1; i != symbols.size(); i++) {
-    unsigned code_shift = 32 - symbols[i-1].length;
-    uint32 code = symbols[i-1].code + (1 << code_shift);
+    unsigned code_shift = 32 - symbols[i - 1].length;
+    uint32 code = symbols[i - 1].code + (1 << code_shift);
 
     if (code != symbols[i].code) {
       failed_symbol_id_ = symbols[i].id;
       return false;
     }
-    if (code < symbols[i-1].code) {
+    if (code < symbols[i - 1].code) {
       // An integer overflow occurred. This implies the input
       // lengths do not represent a valid Huffman code.
       failed_symbol_id_ = symbols[i].id;
       return false;
     }
   }
   if (symbols.back().length < 8) {
     // At least one code (such as an EOS symbol) must be 8 bits or longer.
     // Without this, some inputs will not be encodable in a whole number
     // of bytes.
@@ skipping 19 matching lines @@
 
 void HpackHuffmanTable::BuildDecodeTables(const std::vector<Symbol>& symbols) {
   AddDecodeTable(0, kDecodeTableRootBits);
   // We wish to maximize the flatness of the DecodeTable hierarchy (subject to
   // the |kDecodeTableBranchBits| constraint), and to minimize the size of
   // child tables. To achieve this, we iterate in order of descending code
   // length. This ensures that child tables are visited with their longest
   // entry first, and that the child can therefore be minimally sized to hold
   // that entry without fear of introducing unneccesary branches later.
   for (std::vector<Symbol>::const_reverse_iterator it = symbols.rbegin();
-       it != symbols.rend(); ++it) {
+       it != symbols.rend();
+       ++it) {
     uint8 table_index = 0;
     while (true) {
       const DecodeTable table = decode_tables_[table_index];
 
       // Mask and shift the portion of the code being indexed into low bits.
       uint32 index = (it->code << table.prefix_length);
       index = index >> (32 - table.indexed_length);
 
       CHECK_LT(index, table.size());
       DecodeEntry entry = Entry(table, index);
 
       uint8 total_indexed = table.prefix_length + table.indexed_length;
       if (total_indexed >= it->length) {
         // We're writing a terminal entry.
         entry.length = it->length;
         entry.symbol_id = it->id;
         entry.next_table_index = table_index;
         SetEntry(table, index, entry);
         break;
       }
 
       if (entry.length == 0) {
         // First visit to this placeholder. We need to create a new table.
         CHECK_EQ(entry.next_table_index, 0);
         entry.length = it->length;
-        entry.next_table_index = AddDecodeTable(
-            total_indexed,  // Becomes the new table prefix.
-            std::min<uint8>(kDecodeTableBranchBits,
-                            entry.length - total_indexed));
+        entry.next_table_index =
+            AddDecodeTable(total_indexed,  // Becomes the new table prefix.
+                           std::min<uint8>(kDecodeTableBranchBits,
+                                           entry.length - total_indexed));
         SetEntry(table, index, entry);
       }
       CHECK_NE(entry.next_table_index, table_index);
       table_index = entry.next_table_index;
     }
   }
   // Fill shorter table entries into the additional entry spots they map to.
   for (size_t i = 0; i != decode_tables_.size(); i++) {
     const DecodeTable& table = decode_tables_[i];
     uint8 total_indexed = table.prefix_length + table.indexed_length;
@@ skipping 151 matching lines @@
       bits = bits << entry.length;
       bits_available -= entry.length;
     }
     peeked_success = in->PeekBits(&bits_available, &bits);
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace net