Clang format slam.

net/quic/test_tools/quic_test_packet_maker.cc

 // Copyright 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/test_tools/quic_test_packet_maker.h"
 
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
@@ skipping 32 matching lines @@
 }
 
 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckAndRstPacket(
     QuicPacketSequenceNumber num,
     bool include_version,
     QuicStreamId stream_id,
     QuicRstStreamErrorCode error_code,
     QuicPacketSequenceNumber largest_received,
     QuicPacketSequenceNumber least_unacked,
     bool send_feedback) {
-
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = include_version;
   header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
   header.packet_sequence_number = num;
   header.entropy_flag = false;
   header.fec_flag = false;
   header.fec_group = 0;
 
@@ skipping 103 matching lines @@
     bool should_include_version,
     bool fin,
     const SpdyHeaderBlock& headers) {
   InitializeHeader(sequence_number, should_include_version);
   SpdySynStreamIR syn_stream(stream_id);
   syn_stream.set_name_value_block(headers);
   syn_stream.set_fin(fin);
   syn_stream.set_priority(0);
   scoped_ptr<SpdySerializedFrame> spdy_frame(
       spdy_request_framer_.SerializeSynStream(syn_stream));
-  QuicStreamFrame frame(kHeadersStreamId, false, 0,
-                        MakeIOVector(base::StringPiece(spdy_frame->data(),
-                                                       spdy_frame->size())));
+  QuicStreamFrame frame(
+      kHeadersStreamId,
+      false,
+      0,
+      MakeIOVector(base::StringPiece(spdy_frame->data(), spdy_frame->size())));
   return MakePacket(header_, QuicFrame(&frame));
 }
 
 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeResponseHeadersPacket(
     QuicPacketSequenceNumber sequence_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     const SpdyHeaderBlock& headers) {
   InitializeHeader(sequence_number, should_include_version);
   SpdySynReplyIR syn_reply(stream_id);
   syn_reply.set_name_value_block(headers);
   syn_reply.set_fin(fin);
   scoped_ptr<SpdySerializedFrame> spdy_frame(
       spdy_response_framer_.SerializeSynReply(syn_reply));
-  QuicStreamFrame frame(kHeadersStreamId, false, 0,
-                        MakeIOVector(base::StringPiece(spdy_frame->data(),
-                                                       spdy_frame->size())));
+  QuicStreamFrame frame(
+      kHeadersStreamId,
+      false,
+      0,
+      MakeIOVector(base::StringPiece(spdy_frame->data(), spdy_frame->size())));
   return MakePacket(header_, QuicFrame(&frame));
 }
 
 SpdyHeaderBlock QuicTestPacketMaker::GetRequestHeaders(
     const std::string& method,
     const std::string& scheme,
     const std::string& path) {
   SpdyHeaderBlock headers;
   headers[":method"] = method;
   headers[":host"] = "www.google.com";
@@ skipping 32 matching lines @@
   header_.public_header.version_flag = should_include_version;
   header_.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
   header_.packet_sequence_number = sequence_number;
   header_.fec_group = 0;
   header_.entropy_flag = false;
   header_.fec_flag = false;
 }
 
 }  // namespace test
 }  // namespace net