Clang format slam.

net/quic/crypto/crypto_handshake_message.h

 // 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.
 
 #ifndef NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_MESSAGE_H_
 #define NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_MESSAGE_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 19 matching lines @@
 
   // GetSerialized returns the serialized form of this message and caches the
   // result. Subsequently altering the message does not invalidate the cache.
   const QuicData& GetSerialized() const;
 
   // MarkDirty invalidates the cache created by |GetSerialized|.
   void MarkDirty();
 
   // SetValue sets an element with the given tag to the raw, memory contents of
   // |v|.
-  template<class T> void SetValue(QuicTag tag, const T& v) {
+  template <class T>
+  void SetValue(QuicTag tag, const T& v) {
     tag_value_map_[tag] =
         std::string(reinterpret_cast<const char*>(&v), sizeof(v));
   }
 
   // SetVector sets an element with the given tag to the raw contents of an
   // array of elements in |v|.
-  template<class T> void SetVector(QuicTag tag, const std::vector<T>& v) {
+  template <class T>
+  void SetVector(QuicTag tag, const std::vector<T>& v) {
     if (v.empty()) {
       tag_value_map_[tag] = std::string();
     } else {
       tag_value_map_[tag] = std::string(reinterpret_cast<const char*>(&v[0]),
                                         v.size() * sizeof(T));
     }
   }
 
   // Returns the message tag.
   QuicTag tag() const { return tag_; }
   // Sets the message tag.
   void set_tag(QuicTag tag) { tag_ = tag; }
 
   const QuicTagValueMap& tag_value_map() const { return tag_value_map_; }
 
   // SetTaglist sets an element with the given tag to contain a list of tags,
   // passed as varargs. The argument list must be terminated with a 0 element.
   void SetTaglist(QuicTag tag, ...);
 
   void SetStringPiece(QuicTag tag, base::StringPiece value);
 
   // Erase removes a tag/value, if present, from the message.
   void Erase(QuicTag tag);
 
   // GetTaglist finds an element with the given tag containing zero or more
   // tags. If such a tag doesn't exist, it returns false. Otherwise it sets
   // |out_tags| and |out_len| to point to the array of tags and returns true.
   // The array points into the CryptoHandshakeMessage and is valid only for as
   // long as the CryptoHandshakeMessage exists and is not modified.
-  QuicErrorCode GetTaglist(QuicTag tag, const QuicTag** out_tags,
+  QuicErrorCode GetTaglist(QuicTag tag,
+                           const QuicTag** out_tags,
                            size_t* out_len) const;
 
   bool GetStringPiece(QuicTag tag, base::StringPiece* out) const;
 
   // GetNthValue24 interprets the value with the given tag to be a series of
   // 24-bit, length prefixed values and it returns the subvalue with the given
   // index.
   QuicErrorCode GetNthValue24(QuicTag tag,
                               unsigned index,
                               base::StringPiece* out) const;
@@ skipping 38 matching lines @@
   size_t minimum_size_;
 
   // The serialized form of the handshake message. This member is constructed
   // lasily.
   mutable scoped_ptr<QuicData> serialized_;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_MESSAGE_H_