Clang format slam.

net/quic/quic_connection.h

 // 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.
 //
 // The entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 142 matching lines @@
   // Called when a StopWaitingFrame has been parsed.
   virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {}
 
   // Called when a Ping has been parsed.
   virtual void OnPingFrame(const QuicPingFrame& frame) {}
 
   // Called when a RstStreamFrame has been parsed.
   virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) {}
 
   // Called when a ConnectionCloseFrame has been parsed.
-  virtual void OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) {}
+  virtual void OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) {}
 
   // Called when a public reset packet has been received.
   virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) {}
 
   // Called when a version negotiation packet has been received.
   virtual void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) {}
 
   // Called after a packet has been successfully parsed which results
   // in the revival of a packet via FEC.
@@ skipping 15 matching lines @@
   // notify |delegate| when the alarm fires.  Caller takes ownership
   // of the new alarm, which will not yet be "set" to fire.
   virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) = 0;
 };
 
 class NET_EXPORT_PRIVATE QuicConnection
     : public QuicFramerVisitorInterface,
       public QuicBlockedWriterInterface,
       public QuicPacketGenerator::DelegateInterface {
  public:
-  enum PacketType {
-    NORMAL,
-    QUEUED,
-    CONNECTION_CLOSE
-  };
+  enum PacketType { NORMAL, QUEUED, CONNECTION_CLOSE };
 
   enum AckBundling {
     NO_ACK = 0,
     SEND_ACK = 1,
     BUNDLE_PENDING_ACK = 2,
   };
 
   // Constructs a new QuicConnection for |connection_id| and |address|.
   // |helper| and |writer| must outlive this connection.
   QuicConnection(QuicConnectionId connection_id,
@@ skipping 24 matching lines @@
 
   // Send a RST_STREAM frame to the peer.
   virtual void SendRstStream(QuicStreamId id,
                              QuicRstStreamErrorCode error,
                              QuicStreamOffset bytes_written);
 
   // Send a BLOCKED frame to the peer.
   virtual void SendBlocked(QuicStreamId id);
 
   // Send a WINDOW_UPDATE frame to the peer.
-  virtual void SendWindowUpdate(QuicStreamId id,
-                                QuicStreamOffset byte_offset);
+  virtual void SendWindowUpdate(QuicStreamId id, QuicStreamOffset byte_offset);
 
   // Sends the connection close packet without affecting the state of the
   // connection.  This should only be called if the session is actively being
   // destroyed: otherwise call SendConnectionCloseWithDetails instead.
   virtual void SendConnectionClosePacket(QuicErrorCode error,
                                          const std::string& details);
 
   // Sends a connection close frame to the peer, and closes the connection by
   // calling CloseConnection(notifying the visitor as it does so).
   virtual void SendConnectionClose(QuicErrorCode error);
@@ skipping 342 matching lines @@
   QuicFecGroup* GetFecGroup();
 
   // Closes any FEC groups protecting packets before |sequence_number|.
   void CloseFecGroupsBefore(QuicPacketSequenceNumber sequence_number);
 
   // Sets the ping alarm to the appropriate value, if any.
   void SetPingAlarm();
 
   QuicFramer framer_;
   QuicConnectionHelperInterface* helper_;  // Not owned.
-  QuicPacketWriter* writer_;  // Not owned.
+  QuicPacketWriter* writer_;               // Not owned.
   EncryptionLevel encryption_level_;
   const QuicClock* clock_;
   QuicRandom* random_generator_;
 
   const QuicConnectionId connection_id_;
   // Address on the last successfully processed packet received from the
   // client.
   IPEndPoint self_address_;
   IPEndPoint peer_address_;
 
   bool last_packet_revived_;  // True if the last packet was revived from FEC.
-  size_t last_size_;  // Size of the last received packet.
+  size_t last_size_;          // Size of the last received packet.
   EncryptionLevel last_decrypted_packet_level_;
   QuicPacketHeader last_header_;
   std::vector<QuicStreamFrame> last_stream_frames_;
   std::vector<QuicAckFrame> last_ack_frames_;
   std::vector<QuicCongestionFeedbackFrame> last_congestion_frames_;
   std::vector<QuicStopWaitingFrame> last_stop_waiting_frames_;
   std::vector<QuicRstStreamFrame> last_rst_frames_;
   std::vector<QuicGoAwayFrame> last_goaway_frames_;
   std::vector<QuicWindowUpdateFrame> last_window_update_frames_;
   std::vector<QuicBlockedFrame> last_blocked_frames_;
@@ skipping 105 matching lines @@
 
   // Initial flow control receive window size for new streams.
   uint32 max_flow_control_receive_window_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_