Clang format slam.

net/quic/quic_utils.cc

 // Copyright (c) 2012 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/quic_utils.h"
 
 #include <ctype.h>
 
 #include <algorithm>
 
@@ skipping 34 matching lines @@
   const uint128 kPrime(16777216, 315);
   // 144066263297769815596495629667062367629
   const uint128 kOffset(GG_UINT64_C(7809847782465536322),
                         GG_UINT64_C(7113472399480571277));
 
   const uint8* octets = reinterpret_cast<const uint8*>(data);
 
   uint128 hash = kOffset;
 
   for (int i = 0; i < len; ++i) {
-    hash  = hash ^ uint128(0, octets[i]);
+    hash = hash ^ uint128(0, octets[i]);
     hash = hash * kPrime;
   }
 
   return hash;
 }
 
 // static
 bool QuicUtils::FindMutualTag(const QuicTagVector& our_tags_vector,
                               const QuicTag* their_tags,
                               size_t num_their_tags,
@@ skipping 52 matching lines @@
 // static
 void QuicUtils::SerializeUint128Short(uint128 v, uint8* out) {
   const uint64 lo = Uint128Low64(v);
   const uint64 hi = Uint128High64(v);
   // This assumes that the system is little-endian.
   memcpy(out, &lo, sizeof(lo));
   memcpy(out + sizeof(lo), &hi, sizeof(hi) / 2);
 }
 
 #define RETURN_STRING_LITERAL(x) \
-case x: \
-return #x;
+  case x:                        \
+    return #x;
 
 // static
 const char* QuicUtils::StreamErrorToString(QuicRstStreamErrorCode error) {
   switch (error) {
     RETURN_STRING_LITERAL(QUIC_STREAM_NO_ERROR);
     RETURN_STRING_LITERAL(QUIC_STREAM_CONNECTION_ERROR);
     RETURN_STRING_LITERAL(QUIC_ERROR_PROCESSING_STREAM);
     RETURN_STRING_LITERAL(QUIC_MULTIPLE_TERMINATION_OFFSETS);
     RETURN_STRING_LITERAL(QUIC_BAD_APPLICATION_PAYLOAD);
     RETURN_STRING_LITERAL(QUIC_STREAM_PEER_GOING_AWAY);
@@ skipping 126 matching lines @@
   if (ascii) {
     return string(chars, sizeof(chars));
   }
 
   return base::UintToString(orig_tag);
 }
 
 // static
 string QuicUtils::StringToHexASCIIDump(StringPiece in_buffer) {
   int offset = 0;
-  const int kBytesPerLine = 16;   // Max bytes dumped per line
+  const int kBytesPerLine = 16;  // Max bytes dumped per line
   const char* buf = in_buffer.data();
   int bytes_remaining = in_buffer.size();
-  string s;   // our output
+  string s;  // our output
   const char* p = buf;
   while (bytes_remaining > 0) {
     const int line_bytes = std::min(bytes_remaining, kBytesPerLine);
     base::StringAppendF(&s, "0x%04x:  ", offset);  // Do the line header
     for (int i = 0; i < kBytesPerLine; ++i) {
       if (i < line_bytes) {
         base::StringAppendF(&s, "%02x", static_cast<unsigned char>(p[i]));
       } else {
-        s += "  ";    // two-space filler instead of two-space hex digits
+        s += "  ";  // two-space filler instead of two-space hex digits
       }
-      if (i % 2) s += ' ';
+      if (i % 2)
+        s += ' ';
     }
     s += ' ';
     for (int i = 0; i < line_bytes; ++i) {  // Do the ASCII dump
-      s+= (p[i] >  32 && p[i] < 127) ? p[i] : '.';
+      s += (p[i] > 32 && p[i] < 127) ? p[i] : '.';
     }
 
     bytes_remaining -= line_bytes;
     offset += line_bytes;
     p += line_bytes;
     s += '\n';
   }
   return s;
 }
 
 // static
 QuicPriority QuicUtils::LowestPriority() {
   return QuicWriteBlockedList::kLowestPriority;
 }
 
 // static
 QuicPriority QuicUtils::HighestPriority() {
   return QuicWriteBlockedList::kHighestPriority;
 }
 
 }  // namespace net