Clang format slam.

net/quic/quic_session.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/quic_session.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_headers_stream.h"
@@ skipping 27 matching lines @@
   virtual void OnRstStream(const QuicRstStreamFrame& frame) OVERRIDE {
     session_->OnRstStream(frame);
     session_->PostProcessAfterData();
   }
 
   virtual void OnGoAway(const QuicGoAwayFrame& frame) OVERRIDE {
     session_->OnGoAway(frame);
     session_->PostProcessAfterData();
   }
 
-  virtual void OnWindowUpdateFrames(const vector<QuicWindowUpdateFrame>& frames)
-      OVERRIDE {
+  virtual void OnWindowUpdateFrames(
+      const vector<QuicWindowUpdateFrame>& frames) OVERRIDE {
     session_->OnWindowUpdateFrames(frames);
     session_->PostProcessAfterData();
   }
 
-  virtual void OnBlockedFrames(const vector<QuicBlockedFrame>& frames)
-      OVERRIDE {
+  virtual void OnBlockedFrames(
+      const vector<QuicBlockedFrame>& frames) OVERRIDE {
     session_->OnBlockedFrames(frames);
     session_->PostProcessAfterData();
   }
 
   virtual void OnCanWrite() OVERRIDE {
     session_->OnCanWrite();
     session_->PostProcessAfterData();
   }
 
   virtual void OnSuccessfulVersionNegotiation(
       const QuicVersion& version) OVERRIDE {
     session_->OnSuccessfulVersionNegotiation(version);
   }
 
-  virtual void OnConnectionClosed(
-      QuicErrorCode error, bool from_peer) OVERRIDE {
+  virtual void OnConnectionClosed(QuicErrorCode error,
+                                  bool from_peer) OVERRIDE {
     session_->OnConnectionClosed(error, from_peer);
     // The session will go away, so don't bother with cleanup.
   }
 
-  virtual void OnWriteBlocked() OVERRIDE {
-    session_->OnWriteBlocked();
-  }
+  virtual void OnWriteBlocked() OVERRIDE { session_->OnWriteBlocked(); }
 
   virtual bool HasPendingWrites() const OVERRIDE {
     return session_->HasPendingWrites();
   }
 
   virtual bool HasPendingHandshake() const OVERRIDE {
     return session_->HasPendingHandshake();
   }
 
   virtual bool HasOpenDataStreams() const OVERRIDE {
     return session_->HasOpenDataStreams();
   }
 
  private:
   QuicSession* session_;
 };
 
-QuicSession::QuicSession(QuicConnection* connection,
-                         const QuicConfig& config)
+QuicSession::QuicSession(QuicConnection* connection, const QuicConfig& config)
     : connection_(connection),
       visitor_shim_(new VisitorShim(this)),
       config_(config),
       max_open_streams_(config_.max_streams_per_connection()),
       next_stream_id_(is_server() ? 2 : 3),
       largest_peer_created_stream_id_(0),
       error_(QUIC_NO_ERROR),
       goaway_received_(false),
       goaway_sent_(false),
       has_pending_handshake_(false) {
-
   connection_->set_visitor(visitor_shim_.get());
   connection_->SetFromConfig(config_);
   if (connection_->connected()) {
     connection_->SetOverallConnectionTimeout(
         config_.max_time_before_crypto_handshake());
   }
   headers_stream_.reset(new QuicHeadersStream(this));
   if (!is_server()) {
     // For version above QUIC v12, the headers stream is stream 3, so the
     // next available local stream ID should be 5.
@@ skipping 46 matching lines @@
   if (!stream) {
     // It's quite possible to receive headers after a stream has been reset.
     return;
   }
   stream->OnStreamHeadersComplete(fin, frame_len);
 }
 
 void QuicSession::OnRstStream(const QuicRstStreamFrame& frame) {
   if (frame.stream_id == kCryptoStreamId) {
     connection()->SendConnectionCloseWithDetails(
-        QUIC_INVALID_STREAM_ID,
-        "Attempt to reset the crypto stream");
+        QUIC_INVALID_STREAM_ID, "Attempt to reset the crypto stream");
     return;
   }
   if (frame.stream_id == kHeadersStreamId) {
     connection()->SendConnectionCloseWithDetails(
-        QUIC_INVALID_STREAM_ID,
-        "Attempt to reset the headers stream");
+        QUIC_INVALID_STREAM_ID, "Attempt to reset the headers stream");
     return;
   }
   QuicDataStream* stream = GetDataStream(frame.stream_id);
   if (!stream) {
     return;  // Errors are handled by GetStream.
   }
 
   stream->OnStreamReset(frame);
 }
 
@@ skipping 56 matching lines @@
 
 void QuicSession::OnCanWrite() {
   // We limit the number of writes to the number of pending streams. If more
   // streams become pending, HasPendingWrites will be true, which will cause
   // the connection to request resumption before yielding to other connections.
   size_t num_writes = write_blocked_streams_.NumBlockedStreams();
   if (num_writes == 0) {
     return;
   }
 
-  QuicConnection::ScopedPacketBundler ack_bundler(
-      connection_.get(), QuicConnection::NO_ACK);
+  QuicConnection::ScopedPacketBundler ack_bundler(connection_.get(),
+                                                  QuicConnection::NO_ACK);
   for (size_t i = 0; i < num_writes; ++i) {
     if (!write_blocked_streams_.HasWriteBlockedStreams()) {
       // Writing one stream removed another?! Something's broken.
       LOG(DFATAL) << "WriteBlockedStream is missing";
       connection_->CloseConnection(QUIC_INTERNAL_ERROR, false);
       return;
     }
     if (!connection_->CanWriteStreamData()) {
       return;
     }
@@ skipping 21 matching lines @@
 bool QuicSession::HasOpenDataStreams() const {
   return GetNumOpenStreams() > 0;
 }
 
 QuicConsumedData QuicSession::WritevData(
     QuicStreamId id,
     const IOVector& data,
     QuicStreamOffset offset,
     bool fin,
     QuicAckNotifier::DelegateInterface* ack_notifier_delegate) {
-  return connection_->SendStreamData(id, data, offset, fin,
-                                     ack_notifier_delegate);
+  return connection_->SendStreamData(
+      id, data, offset, fin, ack_notifier_delegate);
 }
 
 size_t QuicSession::WriteHeaders(
     QuicStreamId id,
     const SpdyHeaderBlock& headers,
     bool fin,
     QuicAckNotifier::DelegateInterface* ack_notifier_delegate) {
   return headers_stream_->WriteHeaders(id, headers, fin, ack_notifier_delegate);
 }
 
@@ skipping 12 matching lines @@
     return;
   }
   goaway_sent_ = true;
   connection_->SendGoAway(error_code, largest_peer_created_stream_id_, reason);
 }
 
 void QuicSession::CloseStream(QuicStreamId stream_id) {
   CloseStreamInner(stream_id, false);
 }
 
-void QuicSession::CloseStreamInner(QuicStreamId stream_id,
-                                   bool locally_reset) {
+void QuicSession::CloseStreamInner(QuicStreamId stream_id, bool locally_reset) {
   DVLOG(1) << ENDPOINT << "Closing stream " << stream_id;
 
   DataStreamMap::iterator it = stream_map_.find(stream_id);
   if (it == stream_map_.end()) {
     DVLOG(1) << ENDPOINT << "Stream is already closed: " << stream_id;
     return;
   }
   QuicDataStream* stream = it->second;
 
   // Tell the stream that a RST has been sent.
@@ skipping 17 matching lines @@
 void QuicSession::OnConfigNegotiated() {
   connection_->SetFromConfig(config_);
   // Tell all streams about the newly received peer receive window.
   if (connection()->version() >= QUIC_VERSION_17 &&
       config_.HasReceivedInitialFlowControlWindowBytes()) {
     // Streams which were created before the SHLO was received (0RTT requests)
     // are now informed of the peer's initial flow control window.
     uint32 new_flow_control_send_window =
         config_.ReceivedInitialFlowControlWindowBytes();
     if (new_flow_control_send_window < kDefaultFlowControlSendWindow) {
-      LOG(ERROR)
-          << "Peer sent us an invalid flow control send window: "
-          << new_flow_control_send_window
-          << ", below default: " << kDefaultFlowControlSendWindow;
+      LOG(ERROR) << "Peer sent us an invalid flow control send window: "
+                 << new_flow_control_send_window
+                 << ", below default: " << kDefaultFlowControlSendWindow;
       connection_->SendConnectionClose(QUIC_FLOW_CONTROL_ERROR);
       return;
     }
     DataStreamMap::iterator it = stream_map_.begin();
     while (it != stream_map_.end()) {
       it->second->flow_controller()->UpdateSendWindowOffset(
           new_flow_control_send_window);
       it++;
     }
   }
 }
 
 void QuicSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
   switch (event) {
     // TODO(satyamshekhar): Move the logic of setting the encrypter/decrypter
     // to QuicSession since it is the glue.
     case ENCRYPTION_FIRST_ESTABLISHED:
       break;
 
     case ENCRYPTION_REESTABLISHED:
       // Retransmit originally packets that were sent, since they can't be
       // decrypted by the peer.
       connection_->RetransmitUnackedPackets(INITIAL_ENCRYPTION_ONLY);
       break;
 
     case HANDSHAKE_CONFIRMED:
-      LOG_IF(DFATAL, !config_.negotiated()) << ENDPOINT
-          << "Handshake confirmed without parameter negotiation.";
+      LOG_IF(DFATAL, !config_.negotiated())
+          << ENDPOINT << "Handshake confirmed without parameter negotiation.";
       // Discard originally encrypted packets, since they can't be decrypted by
       // the peer.
       connection_->NeuterUnencryptedPackets();
       connection_->SetOverallConnectionTimeout(QuicTime::Delta::Infinite());
       max_open_streams_ = config_.max_streams_per_connection();
       break;
 
     default:
       LOG(ERROR) << ENDPOINT << "Got unknown handshake event: " << event;
   }
@@ skipping 79 matching lines @@
         LOG(ERROR) << "Trying to get stream: " << stream_id
                    << ", largest peer created stream: "
                    << largest_peer_created_stream_id_
                    << ", max delta: " << kMaxStreamIdDelta;
         connection()->SendConnectionClose(QUIC_INVALID_STREAM_ID);
       }
       return NULL;
     }
     if (largest_peer_created_stream_id_ == 0) {
       if (is_server()) {
-        largest_peer_created_stream_id_= 3;
+        largest_peer_created_stream_id_ = 3;
       } else {
-        largest_peer_created_stream_id_= 1;
+        largest_peer_created_stream_id_ = 1;
       }
     }
-    for (QuicStreamId id = largest_peer_created_stream_id_ + 2;
-         id < stream_id;
+    for (QuicStreamId id = largest_peer_created_stream_id_ + 2; id < stream_id;
          id += 2) {
       implicitly_created_streams_.insert(id);
     }
     largest_peer_created_stream_id_ = stream_id;
   }
   QuicDataStream* stream = CreateIncomingDataStream(stream_id);
   if (stream == NULL) {
     return NULL;
   }
   ActivateStream(stream);
@@ skipping 13 matching lines @@
     return false;
   }
   if (id % 2 == next_stream_id_ % 2) {
     // Locally created streams are strictly in-order.  If the id is in the
     // range of created streams and it's not active, it must have been closed.
     return id < next_stream_id_;
   }
   // For peer created streams, we also need to consider implicitly created
   // streams.
   return id <= largest_peer_created_stream_id_ &&
-      implicitly_created_streams_.count(id) == 0;
+         implicitly_created_streams_.count(id) == 0;
 }
 
 size_t QuicSession::GetNumOpenStreams() const {
   return stream_map_.size() + implicitly_created_streams_.size();
 }
 
 void QuicSession::MarkWriteBlocked(QuicStreamId id, QuicPriority priority) {
 #ifndef NDEBUG
   ReliableQuicStream* stream = GetStream(id);
   if (stream != NULL) {
@@ skipping 16 matching lines @@
     // TODO(jar): Be sure to use the highest priority for the crypto stream,
     // perhaps by adding a "special" priority for it that is higher than
     // kHighestPriority.
     priority = kHighestPriority;
   }
   write_blocked_streams_.PushBack(id, priority);
 }
 
 bool QuicSession::HasDataToWrite() const {
   return write_blocked_streams_.HasWriteBlockedStreams() ||
-      connection_->HasQueuedData();
+         connection_->HasQueuedData();
 }
 
 bool QuicSession::GetSSLInfo(SSLInfo* ssl_info) const {
   NOTIMPLEMENTED();
   return false;
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 }  // namespace net