Clang format slam.

net/quic/quic_client_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_client_session.h"
 
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 24 matching lines @@
   DESTRUCTOR = 0,
   ADD_OBSERVER = 1,
   TRY_CREATE_STREAM = 2,
   CREATE_OUTGOING_RELIABLE_STREAM = 3,
   NOTIFY_FACTORY_OF_SESSION_CLOSED_LATER = 4,
   NOTIFY_FACTORY_OF_SESSION_CLOSED = 5,
   NUM_LOCATIONS = 6,
 };
 
 void RecordUnexpectedOpenStreams(Location location) {
-  UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.UnexpectedOpenStreams", location,
-                            NUM_LOCATIONS);
+  UMA_HISTOGRAM_ENUMERATION(
+      "Net.QuicSession.UnexpectedOpenStreams", location, NUM_LOCATIONS);
 }
 
 void RecordUnexpectedObservers(Location location) {
-  UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.UnexpectedObservers", location,
-                            NUM_LOCATIONS);
+  UMA_HISTOGRAM_ENUMERATION(
+      "Net.QuicSession.UnexpectedObservers", location, NUM_LOCATIONS);
 }
 
 void RecordUnexpectedNotGoingAway(Location location) {
-  UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.UnexpectedNotGoingAway", location,
-                            NUM_LOCATIONS);
+  UMA_HISTOGRAM_ENUMERATION(
+      "Net.QuicSession.UnexpectedNotGoingAway", location, NUM_LOCATIONS);
 }
 
 // Note: these values must be kept in sync with the corresponding values in:
 // tools/metrics/histograms/histograms.xml
 enum HandshakeState {
   STATE_STARTED = 0,
   STATE_ENCRYPTION_ESTABLISHED = 1,
   STATE_HANDSHAKE_CONFIRMED = 2,
   STATE_FAILED = 3,
   NUM_HANDSHAKE_STATES = 4
 };
 
 void RecordHandshakeState(HandshakeState state) {
-  UMA_HISTOGRAM_ENUMERATION("Net.QuicHandshakeState", state,
-                            NUM_HANDSHAKE_STATES);
+  UMA_HISTOGRAM_ENUMERATION(
+      "Net.QuicHandshakeState", state, NUM_HANDSHAKE_STATES);
 }
 
 }  // namespace
 
-QuicClientSession::StreamRequest::StreamRequest() : stream_(NULL) {}
+QuicClientSession::StreamRequest::StreamRequest() : stream_(NULL) {
+}
 
 QuicClientSession::StreamRequest::~StreamRequest() {
   CancelRequest();
 }
 
 int QuicClientSession::StreamRequest::StartRequest(
     const base::WeakPtr<QuicClientSession>& session,
     QuicReliableClientStream** stream,
     const CompletionCallback& callback) {
   session_ = session;
@@ skipping 44 matching lines @@
       read_buffer_(new IOBufferWithSize(kMaxPacketSize)),
       server_info_(server_info.Pass()),
       read_pending_(false),
       num_total_streams_(0),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)),
       logger_(net_log_),
       num_packets_read_(0),
       going_away_(false),
       weak_factory_(this) {
   crypto_stream_.reset(
-      crypto_client_stream_factory ?
-          crypto_client_stream_factory->CreateQuicCryptoClientStream(
-              server_id, this, crypto_config) :
-          new QuicCryptoClientStream(server_id, this,
-                                     new ProofVerifyContextChromium(net_log_),
-                                     crypto_config));
+      crypto_client_stream_factory
+          ? crypto_client_stream_factory->CreateQuicCryptoClientStream(
+                server_id, this, crypto_config)
+          : new QuicCryptoClientStream(server_id,
+                                       this,
+                                       new ProofVerifyContextChromium(net_log_),
+                                       crypto_config));
 
   connection->set_debug_visitor(&logger_);
   // TODO(rch): pass in full host port proxy pair
-  net_log_.BeginEvent(
-      NetLog::TYPE_QUIC_SESSION,
-      NetLog::StringCallback("host", &server_id.host()));
+  net_log_.BeginEvent(NetLog::TYPE_QUIC_SESSION,
+                      NetLog::StringCallback("host", &server_id.host()));
 }
 
 QuicClientSession::~QuicClientSession() {
   if (!streams()->empty())
     RecordUnexpectedOpenStreams(DESTRUCTOR);
   if (!observers_.empty())
     RecordUnexpectedObservers(DESTRUCTOR);
   if (!going_away_)
     RecordUnexpectedNotGoingAway(DESTRUCTOR);
 
-  while (!streams()->empty() ||
-         !observers_.empty() ||
+  while (!streams()->empty() || !observers_.empty() ||
          !stream_requests_.empty()) {
     // The session must be closed before it is destroyed.
     DCHECK(streams()->empty());
     CloseAllStreams(ERR_UNEXPECTED);
     DCHECK(observers_.empty());
     CloseAllObservers(ERR_UNEXPECTED);
 
     connection()->set_debug_visitor(NULL);
     net_log_.EndEvent(NetLog::TYPE_QUIC_SESSION);
 
@@ skipping 29 matching lines @@
   // Don't bother with these histogram during tests, which mock out
   // num_sent_client_hellos().
   if (round_trip_handshakes < 0 || !stream_factory_)
     return;
 
   bool port_selected = stream_factory_->enable_port_selection();
   SSLInfo ssl_info;
   if (!GetSSLInfo(&ssl_info) || !ssl_info.cert) {
     if (port_selected) {
       UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.ConnectSelectPortForHTTP",
-                                  round_trip_handshakes, 0, 3, 4);
+                                  round_trip_handshakes,
+                                  0,
+                                  3,
+                                  4);
     } else {
       UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.ConnectRandomPortForHTTP",
-                                  round_trip_handshakes, 0, 3, 4);
+                                  round_trip_handshakes,
+                                  0,
+                                  3,
+                                  4);
     }
   } else {
     if (port_selected) {
       UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.ConnectSelectPortForHTTPS",
-                                  round_trip_handshakes, 0, 3, 4);
+                                  round_trip_handshakes,
+                                  0,
+                                  3,
+                                  4);
     } else {
       UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.ConnectRandomPortForHTTPS",
-                                  round_trip_handshakes, 0, 3, 4);
+                                  round_trip_handshakes,
+                                  0,
+                                  3,
+                                  4);
     }
   }
 }
 
 void QuicClientSession::OnStreamFrames(
     const std::vector<QuicStreamFrame>& frames) {
   // Record total number of stream frames.
   UMA_HISTOGRAM_COUNTS("Net.QuicNumStreamFramesInPacket", frames.size());
 
   // Record number of frames per stream in packet.
   typedef std::map<QuicStreamId, size_t> FrameCounter;
   FrameCounter frames_per_stream;
   for (size_t i = 0; i < frames.size(); ++i) {
     frames_per_stream[frames[i].stream_id]++;
   }
   for (FrameCounter::const_iterator it = frames_per_stream.begin();
-       it != frames_per_stream.end(); ++it) {
+       it != frames_per_stream.end();
+       ++it) {
     UMA_HISTOGRAM_COUNTS("Net.QuicNumStreamFramesPerStreamInPacket",
                          it->second);
   }
 
   return QuicSession::OnStreamFrames(frames);
 }
 
 void QuicClientSession::AddObserver(Observer* observer) {
   if (going_away_) {
     RecordUnexpectedObservers(ADD_OBSERVER);
@@ skipping 112 matching lines @@
       break;
     case kCC12:
       cipher_suite = 0xcc13;  // TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
       security_bits = 256;
       break;
     default:
       NOTREACHED();
       return false;
   }
   int ssl_connection_status = 0;
+  ssl_connection_status |= (cipher_suite & SSL_CONNECTION_CIPHERSUITE_MASK)
+                           << SSL_CONNECTION_CIPHERSUITE_SHIFT;
   ssl_connection_status |=
-      (cipher_suite & SSL_CONNECTION_CIPHERSUITE_MASK) <<
-       SSL_CONNECTION_CIPHERSUITE_SHIFT;
-  ssl_connection_status |=
-      (SSL_CONNECTION_VERSION_QUIC & SSL_CONNECTION_VERSION_MASK) <<
-       SSL_CONNECTION_VERSION_SHIFT;
+      (SSL_CONNECTION_VERSION_QUIC & SSL_CONNECTION_VERSION_MASK)
+      << SSL_CONNECTION_VERSION_SHIFT;
 
   ssl_info->public_key_hashes = cert_verify_result_->public_key_hashes;
   ssl_info->is_issued_by_known_root =
       cert_verify_result_->is_issued_by_known_root;
 
   ssl_info->connection_status = ssl_connection_status;
   ssl_info->client_cert_sent = false;
   ssl_info->channel_id_sent = false;
   ssl_info->security_bits = security_bits;
   ssl_info->handshake_type = SSLInfo::HANDSHAKE_FULL;
   return true;
 }
 
 int QuicClientSession::CryptoConnect(bool require_confirmation,
                                      const CompletionCallback& callback) {
   require_confirmation_ = require_confirmation;
   RecordHandshakeState(STATE_STARTED);
   if (!crypto_stream_->CryptoConnect()) {
     // TODO(wtc): change crypto_stream_.CryptoConnect() to return a
     // QuicErrorCode and map it to a net error code.
     return ERR_CONNECTION_FAILED;
   }
 
-  bool can_notify = require_confirmation_ ?
-      IsCryptoHandshakeConfirmed() : IsEncryptionEstablished();
+  bool can_notify = require_confirmation_ ? IsCryptoHandshakeConfirmed()
+                                          : IsEncryptionEstablished();
   if (can_notify) {
     return OK;
   }
 
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int QuicClientSession::GetNumSentClientHellos() const {
   return crypto_stream_->num_sent_client_hellos();
 }
 
 bool QuicClientSession::CanPool(const std::string& hostname) const {
   // TODO(rch): When QUIC supports channel ID or client certificates, this
   // logic will need to be revised.
   DCHECK(connection()->connected());
   SSLInfo ssl_info;
   bool unused = false;
   if (!GetSSLInfo(&ssl_info) || !ssl_info.cert) {
     // We can always pool with insecure QUIC sessions.
     return true;
   }
   // Only pool secure QUIC sessions if the cert matches the new hostname.
   return ssl_info.cert->VerifyNameMatch(hostname, &unused);
 }
 
-QuicDataStream* QuicClientSession::CreateIncomingDataStream(
-    QuicStreamId id) {
+QuicDataStream* QuicClientSession::CreateIncomingDataStream(QuicStreamId id) {
   DLOG(ERROR) << "Server push not supported";
   return NULL;
 }
 
 void QuicClientSession::CloseStream(QuicStreamId stream_id) {
   ReliableQuicStream* stream = GetStream(stream_id);
   if (stream) {
-    logger_.UpdateReceivedFrameCounts(
-        stream_id, stream->num_frames_received(),
-        stream->num_duplicate_frames_received());
+    logger_.UpdateReceivedFrameCounts(stream_id,
+                                      stream->num_frames_received(),
+                                      stream->num_duplicate_frames_received());
   }
   QuicSession::CloseStream(stream_id);
   OnClosedStream();
 }
 
 void QuicClientSession::SendRstStream(QuicStreamId id,
                                       QuicRstStreamErrorCode error,
                                       QuicStreamOffset bytes_written) {
   QuicSession::SendRstStream(id, error, bytes_written);
   OnClosedStream();
 }
 
 void QuicClientSession::OnClosedStream() {
   if (GetNumOpenStreams() < get_max_open_streams() &&
-      !stream_requests_.empty() &&
-      crypto_stream_->encryption_established() &&
-      !goaway_received() &&
-      !going_away_ &&
-      connection()->connected()) {
+      !stream_requests_.empty() && crypto_stream_->encryption_established() &&
+      !goaway_received() && !going_away_ && connection()->connected()) {
     StreamRequest* request = stream_requests_.front();
     stream_requests_.pop_front();
     request->OnRequestCompleteSuccess(CreateOutgoingReliableStreamImpl());
   }
 
   if (GetNumOpenStreams() == 0) {
     stream_factory_->OnIdleSession(this);
   }
 }
 
@@ skipping 86 matching lines @@
   state->source_address_token = cached.source_address_token();
   state->server_config_sig = cached.signature();
   state->certs = cached.certs();
 
   server_info_->Persist();
 }
 
 void QuicClientSession::OnProofVerifyDetailsAvailable(
     const ProofVerifyDetails& verify_details) {
   const CertVerifyResult* cert_verify_result_other =
-      &(reinterpret_cast<const ProofVerifyDetailsChromium*>(
-          &verify_details))->cert_verify_result;
+      &(reinterpret_cast<const ProofVerifyDetailsChromium*>(&verify_details))
+           ->cert_verify_result;
   CertVerifyResult* result_copy = new CertVerifyResult;
   result_copy->CopyFrom(*cert_verify_result_other);
   cert_verify_result_.reset(result_copy);
 }
 
 void QuicClientSession::StartReading() {
   if (read_pending_) {
     return;
   }
   read_pending_ = true;
   int rv = socket_->Read(read_buffer_.get(),
                          read_buffer_->size(),
                          base::Bind(&QuicClientSession::OnReadComplete,
                                     weak_factory_.GetWeakPtr()));
   if (rv == ERR_IO_PENDING) {
     num_packets_read_ = 0;
     return;
   }
 
   if (++num_packets_read_ > 32) {
     num_packets_read_ = 0;
     // Data was read, process it.
     // Schedule the work through the message loop to avoid recursive
     // callbacks.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&QuicClientSession::OnReadComplete,
-                   weak_factory_.GetWeakPtr(), rv));
+                   weak_factory_.GetWeakPtr(),
+                   rv));
   } else {
     OnReadComplete(rv);
   }
 }
 
 void QuicClientSession::CloseSessionOnError(int error) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.CloseSessionOnError", -error);
   CloseSessionOnErrorInner(error, QUIC_INTERNAL_ERROR);
   NotifyFactoryOfSessionClosed();
 }
 
 void QuicClientSession::CloseSessionOnErrorInner(int net_error,
                                                  QuicErrorCode quic_error) {
   if (!callback_.is_null()) {
     base::ResetAndReturn(&callback_).Run(net_error);
   }
   CloseAllStreams(net_error);
   CloseAllObservers(net_error);
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_CLOSE_ON_ERROR,
-      NetLog::IntegerCallback("net_error", net_error));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_CLOSE_ON_ERROR,
+                    NetLog::IntegerCallback("net_error", net_error));
 
   connection()->CloseConnection(quic_error, false);
   DCHECK(!connection()->connected());
 }
 
 void QuicClientSession::CloseAllStreams(int net_error) {
   while (!streams()->empty()) {
     ReliableQuicStream* stream = streams()->begin()->second;
     QuicStreamId id = stream->id();
     static_cast<QuicReliableClientStream*>(stream)->OnError(net_error);
@@ skipping 18 matching lines @@
   dict->SetInteger("open_streams", GetNumOpenStreams());
   dict->SetInteger("total_streams", num_total_streams_);
   dict->SetString("peer_address", peer_address().ToString());
   dict->SetString("connection_id", base::Uint64ToString(connection_id()));
   dict->SetBoolean("connected", connection()->connected());
   SSLInfo ssl_info;
   dict->SetBoolean("secure", GetSSLInfo(&ssl_info) && ssl_info.cert);
 
   base::ListValue* alias_list = new base::ListValue();
   for (std::set<HostPortPair>::const_iterator it = aliases.begin();
-       it != aliases.end(); it++) {
+       it != aliases.end();
+       it++) {
     alias_list->Append(new base::StringValue(it->ToString()));
   }
   dict->Set("aliases", alias_list);
 
   return dict;
 }
 
 base::WeakPtr<QuicClientSession> QuicClientSession::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
@@ skipping 59 matching lines @@
     RecordUnexpectedNotGoingAway(NOTIFY_FACTORY_OF_SESSION_CLOSED);
 
   going_away_ = true;
   DCHECK_EQ(0u, GetNumOpenStreams());
   // Will delete |this|.
   if (stream_factory_)
     stream_factory_->OnSessionClosed(this);
 }
 
 }  // namespace net