Clang format slam.

net/quic/crypto/crypto_handshake_message.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/crypto_handshake_message.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_socket_address_coder.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using base::StringPrintf;
 using std::string;
 using std::vector;
 
 namespace net {
 
-CryptoHandshakeMessage::CryptoHandshakeMessage()
-    : tag_(0),
-      minimum_size_(0) {}
+CryptoHandshakeMessage::CryptoHandshakeMessage() : tag_(0), minimum_size_(0) {
+}
 
 CryptoHandshakeMessage::CryptoHandshakeMessage(
     const CryptoHandshakeMessage& other)
     : tag_(other.tag_),
       tag_value_map_(other.tag_value_map_),
       minimum_size_(other.minimum_size_) {
   // Don't copy serialized_. scoped_ptr doesn't have a copy constructor.
   // The new object can lazily reconstruct serialized_.
 }
 
-CryptoHandshakeMessage::~CryptoHandshakeMessage() {}
+CryptoHandshakeMessage::~CryptoHandshakeMessage() {
+}
 
 CryptoHandshakeMessage& CryptoHandshakeMessage::operator=(
     const CryptoHandshakeMessage& other) {
   tag_ = other.tag_;
   tag_value_map_ = other.tag_value_map_;
   // Don't copy serialized_. scoped_ptr doesn't have an assignment operator.
   // However, invalidate serialized_.
   serialized_.reset();
   minimum_size_ = other.minimum_size_;
   return *this;
@@ skipping 129 matching lines @@
                                                 uint32* out) const {
   return GetPOD(tag, out, sizeof(uint32));
 }
 
 QuicErrorCode CryptoHandshakeMessage::GetUint64(QuicTag tag,
                                                 uint64* out) const {
   return GetPOD(tag, out, sizeof(uint64));
 }
 
 size_t CryptoHandshakeMessage::size() const {
-  size_t ret = sizeof(QuicTag) +
-               sizeof(uint16) /* number of entries */ +
+  size_t ret = sizeof(QuicTag) + sizeof(uint16) /* number of entries */ +
                sizeof(uint16) /* padding */;
   ret += (sizeof(QuicTag) + sizeof(uint32) /* end offset */) *
          tag_value_map_.size();
   for (QuicTagValueMap::const_iterator i = tag_value_map_.begin();
-       i != tag_value_map_.end(); ++i) {
+       i != tag_value_map_.end();
+       ++i) {
     ret += i->second.size();
   }
 
   return ret;
 }
 
 void CryptoHandshakeMessage::set_minimum_size(size_t min_bytes) {
   if (min_bytes == minimum_size_) {
     return;
   }
   serialized_.reset();
   minimum_size_ = min_bytes;
 }
 
 size_t CryptoHandshakeMessage::minimum_size() const {
   return minimum_size_;
 }
 
 string CryptoHandshakeMessage::DebugString() const {
   return DebugStringInternal(0);
 }
 
-QuicErrorCode CryptoHandshakeMessage::GetPOD(
-    QuicTag tag, void* out, size_t len) const {
+QuicErrorCode CryptoHandshakeMessage::GetPOD(QuicTag tag,
+                                             void* out,
+                                             size_t len) const {
   QuicTagValueMap::const_iterator it = tag_value_map_.find(tag);
   QuicErrorCode ret = QUIC_NO_ERROR;
 
   if (it == tag_value_map_.end()) {
     ret = QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
   } else if (it->second.size() != len) {
     ret = QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
 
   if (ret != QUIC_NO_ERROR) {
     memset(out, 0, len);
     return ret;
   }
 
   memcpy(out, it->second.data(), len);
   return ret;
 }
 
 string CryptoHandshakeMessage::DebugStringInternal(size_t indent) const {
   string ret = string(2 * indent, ' ') + QuicUtils::TagToString(tag_) + "<\n";
   ++indent;
   for (QuicTagValueMap::const_iterator it = tag_value_map_.begin();
-       it != tag_value_map_.end(); ++it) {
+       it != tag_value_map_.end();
+       ++it) {
     ret += string(2 * indent, ' ') + QuicUtils::TagToString(it->first) + ": ";
 
     bool done = false;
     switch (it->first) {
       case kICSL:
       case kIFCW:
       case kIRTT:
       case kKATO:
       case kMSPC:
       case kSWND:
@@ skipping 60 matching lines @@
       ret += "0x" + base::HexEncode(it->second.data(), it->second.size());
     }
     ret += "\n";
   }
   --indent;
   ret += string(2 * indent, ' ') + ">";
   return ret;
 }
 
 }  // namespace net