Clang format slam.

net/spdy/fuzzing/hpack_fuzz_util.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/fuzzing/hpack_fuzz_util.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/rand_util.h"
@@ skipping 18 matching lines @@
 const size_t kValueLengthMean = 15;
 const size_t kValueLengthMax = 75;
 
 }  //  namespace
 
 using base::StringPiece;
 using base::RandBytesAsString;
 using std::map;
 using std::string;
 
-HpackFuzzUtil::GeneratorContext::GeneratorContext() {}
-HpackFuzzUtil::GeneratorContext::~GeneratorContext() {}
+HpackFuzzUtil::GeneratorContext::GeneratorContext() {
+}
+HpackFuzzUtil::GeneratorContext::~GeneratorContext() {
+}
 
-HpackFuzzUtil::Input::Input() : offset(0) {}
-HpackFuzzUtil::Input::~Input() {}
+HpackFuzzUtil::Input::Input() : offset(0) {
+}
+HpackFuzzUtil::Input::~Input() {
+}
 
-HpackFuzzUtil::FuzzerContext::FuzzerContext() {}
-HpackFuzzUtil::FuzzerContext::~FuzzerContext() {}
+HpackFuzzUtil::FuzzerContext::FuzzerContext() {
+}
+HpackFuzzUtil::FuzzerContext::~FuzzerContext() {
+}
 
 // static
 void HpackFuzzUtil::InitializeGeneratorContext(GeneratorContext* context) {
   // Seed the generator with common header fixtures.
   context->names.push_back(":authority");
   context->names.push_back(":path");
   context->names.push_back(":status");
   context->names.push_back("cookie");
   context->names.push_back("content-type");
   context->names.push_back("cache-control");
@@ skipping 12 matching lines @@
   context->values.push_back("had=a;very_shiny=nose");
   context->values.push_back("and\0if\0you\0ever\1saw\0it;");
   context->values.push_back("u; would=even;say-it\xffglows");
 }
 
 // static
 map<string, string> HpackFuzzUtil::NextGeneratedHeaderSet(
     GeneratorContext* context) {
   map<string, string> headers;
 
-  size_t header_count = 1 + SampleExponential(kHeaderCountMean,
-                                              kHeaderCountMax);
+  size_t header_count =
+      1 + SampleExponential(kHeaderCountMean, kHeaderCountMax);
   for (size_t j = 0; j != header_count; ++j) {
-    size_t name_index = SampleExponential(kHeaderIndexMean,
-                                          kHeaderIndexMax);
-    size_t value_index = SampleExponential(kHeaderIndexMean,
-                                           kHeaderIndexMax);
+    size_t name_index = SampleExponential(kHeaderIndexMean, kHeaderIndexMax);
+    size_t value_index = SampleExponential(kHeaderIndexMean, kHeaderIndexMax);
     string name, value;
     if (name_index >= context->names.size()) {
-      context->names.push_back(
-          RandBytesAsString(1 + SampleExponential(kNameLengthMean,
-                                                  kNameLengthMax)));
+      context->names.push_back(RandBytesAsString(
+          1 + SampleExponential(kNameLengthMean, kNameLengthMax)));
       name = context->names.back();
     } else {
       name = context->names[name_index];
     }
     if (value_index >= context->values.size()) {
-      context->values.push_back(
-          RandBytesAsString(1 + SampleExponential(kValueLengthMean,
-                                                  kValueLengthMax)));
+      context->values.push_back(RandBytesAsString(
+          1 + SampleExponential(kValueLengthMean, kValueLengthMax)));
       value = context->values.back();
     } else {
       value = context->values[value_index];
     }
     headers[name] = value;
   }
   return headers;
 }
 
 // static
 size_t HpackFuzzUtil::SampleExponential(size_t mean, size_t sanity_bound) {
   return std::min<size_t>(-std::log(base::RandDouble()) * mean, sanity_bound);
 }
 
 // static
-bool HpackFuzzUtil::NextHeaderBlock(Input* input,
-                                    StringPiece* out) {
+bool HpackFuzzUtil::NextHeaderBlock(Input* input, StringPiece* out) {
   CHECK_LE(input->offset, input->input.size());
   if (input->remaining() == 0) {
     return false;
   }
   CHECK_LE(sizeof(uint32), input->remaining());
 
   size_t length = ntohl(*reinterpret_cast<const uint32*>(input->ptr()));
   input->offset += sizeof(uint32);
 
   CHECK_LE(length, input->remaining());
@@ skipping 13 matching lines @@
   context->first_stage.reset(new HpackDecoder(ObtainHpackHuffmanTable()));
   context->second_stage.reset(new HpackEncoder(ObtainHpackHuffmanTable()));
   context->third_stage.reset(new HpackDecoder(ObtainHpackHuffmanTable()));
 }
 
 // static
 bool HpackFuzzUtil::RunHeaderBlockThroughFuzzerStages(FuzzerContext* context,
                                                       StringPiece input_block) {
   // First stage: Decode the input header block. This may fail on invalid input.
   if (!context->first_stage->HandleControlFrameHeadersData(
-      1, input_block.data(), input_block.size())) {
+          1, input_block.data(), input_block.size())) {
     return false;
   }
   if (!context->first_stage->HandleControlFrameHeadersComplete(1)) {
     return false;
   }
   // Second stage: Re-encode the decoded header block. This must succeed.
   string second_stage_out;
   CHECK(context->second_stage->EncodeHeaderSet(
       context->first_stage->decoded_block(), &second_stage_out));
 
   // Third stage: Expect a decoding of the re-encoded block to succeed.
   CHECK(context->third_stage->HandleControlFrameHeadersData(
       1, second_stage_out.data(), second_stage_out.length()));
   CHECK(context->third_stage->HandleControlFrameHeadersComplete(1));
   return true;
 }
 
 // static
-void HpackFuzzUtil::FlipBits(uint8* buffer, size_t buffer_length,
+void HpackFuzzUtil::FlipBits(uint8* buffer,
+                             size_t buffer_length,
                              size_t flip_per_thousand) {
   uint64 buffer_bit_length = buffer_length * 8u;
   uint64 bits_to_flip = flip_per_thousand * (1 + buffer_bit_length / 1024);
 
   // Iteratively identify & flip offsets in the buffer bit-sequence.
   for (uint64 i = 0; i != bits_to_flip; ++i) {
     uint64 bit_offset = base::RandUint64() % buffer_bit_length;
     buffer[bit_offset / 8u] ^= (1 << (bit_offset % 8u));
   }
 }
 
 }  // namespace net