Clang format slam.

net/quic/reliable_quic_stream.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/reliable_quic_stream.h"
 
 #include "base/logging.h"
 #include "net/quic/iovector.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_session.h"
@@ skipping 27 matching lines @@
 class ReliableQuicStream::ProxyAckNotifierDelegate
     : public QuicAckNotifier::DelegateInterface {
  public:
   explicit ProxyAckNotifierDelegate(DelegateInterface* delegate)
       : delegate_(delegate),
         pending_acks_(0),
         wrote_last_data_(false),
         num_original_packets_(0),
         num_original_bytes_(0),
         num_retransmitted_packets_(0),
-        num_retransmitted_bytes_(0) {
-  }
+        num_retransmitted_bytes_(0) {}
 
-  virtual void OnAckNotification(int num_original_packets,
-                                 int num_original_bytes,
-                                 int num_retransmitted_packets,
-                                 int num_retransmitted_bytes,
-                                 QuicTime::Delta delta_largest_observed)
-      OVERRIDE {
+  virtual void OnAckNotification(
+      int num_original_packets,
+      int num_original_bytes,
+      int num_retransmitted_packets,
+      int num_retransmitted_bytes,
+      QuicTime::Delta delta_largest_observed) OVERRIDE {
     DCHECK_LT(0, pending_acks_);
     --pending_acks_;
     num_original_packets_ += num_original_packets;
     num_original_bytes_ += num_original_bytes;
     num_retransmitted_packets_ += num_retransmitted_packets;
     num_retransmitted_bytes_ += num_retransmitted_bytes;
 
     if (wrote_last_data_ && pending_acks_ == 0) {
       delegate_->OnAckNotification(num_original_packets_,
                                    num_original_bytes_,
                                    num_retransmitted_packets_,
                                    num_retransmitted_bytes_,
                                    delta_largest_observed);
     }
   }
 
   void WroteData(bool last_data) {
     DCHECK(!wrote_last_data_);
     ++pending_acks_;
     wrote_last_data_ = last_data;
   }
 
  protected:
   // Delegates are ref counted.
-  virtual ~ProxyAckNotifierDelegate() {
-  }
+  virtual ~ProxyAckNotifierDelegate() {}
 
  private:
   // Original delegate.  delegate_->OnAckNotification will be called when:
   //   wrote_last_data_ == true and pending_acks_ == 0
   scoped_refptr<DelegateInterface> delegate_;
 
   // Number of outstanding acks.
   int pending_acks_;
 
   // True if no pending writes remain.
   bool wrote_last_data_;
 
   // Accumulators.
   int num_original_packets_;
   int num_original_bytes_;
   int num_retransmitted_packets_;
   int num_retransmitted_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyAckNotifierDelegate);
 };
 
 ReliableQuicStream::PendingData::PendingData(
-    string data_in, scoped_refptr<ProxyAckNotifierDelegate> delegate_in)
+    string data_in,
+    scoped_refptr<ProxyAckNotifierDelegate> delegate_in)
     : data(data_in), delegate(delegate_in) {
 }
 
 ReliableQuicStream::PendingData::~PendingData() {
 }
 
 ReliableQuicStream::ReliableQuicStream(QuicStreamId id, QuicSession* session)
     : sequencer_(this),
       id_(id),
       session_(session),
       stream_bytes_read_(0),
       stream_bytes_written_(0),
       stream_error_(QUIC_STREAM_NO_ERROR),
       connection_error_(QUIC_NO_ERROR),
       read_side_closed_(false),
       write_side_closed_(false),
       fin_buffered_(false),
       fin_sent_(false),
       rst_sent_(false),
       is_server_(session_->is_server()),
       flow_controller_(
           session_->connection()->version(),
           id_,
           is_server_,
-          session_->config()->HasReceivedInitialFlowControlWindowBytes() ?
-              session_->config()->ReceivedInitialFlowControlWindowBytes() :
-              kDefaultFlowControlSendWindow,
+          session_->config()->HasReceivedInitialFlowControlWindowBytes()
+              ? session_->config()->ReceivedInitialFlowControlWindowBytes()
+              : kDefaultFlowControlSendWindow,
           session_->connection()->max_flow_control_receive_window_bytes(),
           session_->connection()->max_flow_control_receive_window_bytes()) {
 }
 
 ReliableQuicStream::~ReliableQuicStream() {
 }
 
 bool ReliableQuicStream::OnStreamFrame(const QuicStreamFrame& frame) {
   if (read_side_closed_) {
     DVLOG(1) << ENDPOINT << "Ignoring frame " << frame.stream_id;
@@ skipping 244 matching lines @@
 
 void ReliableQuicStream::OnClose() {
   CloseReadSide();
   CloseWriteSide();
 
   if (!fin_sent_ && !rst_sent_) {
     // For flow control accounting, we must tell the peer how many bytes we have
     // written on this stream before termination. Done here if needed, using a
     // RST frame.
     DVLOG(1) << ENDPOINT << "Sending RST in OnClose: " << id();
-    session_->SendRstStream(id(), QUIC_RST_FLOW_CONTROL_ACCOUNTING,
-                            stream_bytes_written_);
+    session_->SendRstStream(
+        id(), QUIC_RST_FLOW_CONTROL_ACCOUNTING, stream_bytes_written_);
     rst_sent_ = true;
   }
 }
 
 void ReliableQuicStream::OnWindowUpdateFrame(
     const QuicWindowUpdateFrame& frame) {
   if (!flow_controller_.IsEnabled()) {
     DLOG(DFATAL) << "Flow control not enabled! " << version();
     return;
   }
 
   if (flow_controller_.UpdateSendWindowOffset(frame.byte_offset)) {
     // We can write again!
     // TODO(rjshade): This does not respect priorities (e.g. multiple
     //                outstanding POSTs are unblocked on arrival of
     //                SHLO with initial window).
     OnCanWrite();
   }
 }
 
 }  // namespace net