Clang format slam.

net/quic/quic_stream_factory.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_stream_factory.h"
 
 #include <set>
 
 #include "base/cpu.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 39 matching lines @@
   CREATION_ERROR_CONNECTING_SOCKET,
   CREATION_ERROR_SETTING_RECEIVE_BUFFER,
   CREATION_ERROR_SETTING_SEND_BUFFER,
   CREATION_ERROR_MAX
 };
 
 // The initial receive window size for both streams and sessions.
 const int32 kInitialReceiveWindowSize = 10 * 1024 * 1024;  // 10MB
 
 void HistogramCreateSessionFailure(enum CreateSessionFailure error) {
-  UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.CreationError", error,
-                            CREATION_ERROR_MAX);
+  UMA_HISTOGRAM_ENUMERATION(
+      "Net.QuicSession.CreationError", error, CREATION_ERROR_MAX);
 }
 
 bool IsEcdsaSupported() {
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return false;
 #endif
 
   return true;
 }
 
 }  // namespace
 
-QuicStreamFactory::IpAliasKey::IpAliasKey() {}
+QuicStreamFactory::IpAliasKey::IpAliasKey() {
+}
 
-QuicStreamFactory::IpAliasKey::IpAliasKey(IPEndPoint ip_endpoint,
-                                          bool is_https)
-    : ip_endpoint(ip_endpoint),
-      is_https(is_https) {}
+QuicStreamFactory::IpAliasKey::IpAliasKey(IPEndPoint ip_endpoint, bool is_https)
+    : ip_endpoint(ip_endpoint), is_https(is_https) {
+}
 
-QuicStreamFactory::IpAliasKey::~IpAliasKey() {}
+QuicStreamFactory::IpAliasKey::~IpAliasKey() {
+}
 
 bool QuicStreamFactory::IpAliasKey::operator<(
     const QuicStreamFactory::IpAliasKey& other) const {
   if (!(ip_endpoint == other.ip_endpoint)) {
     return ip_endpoint < other.ip_endpoint;
   }
   return is_https < other.is_https;
 }
 
 bool QuicStreamFactory::IpAliasKey::operator==(
     const QuicStreamFactory::IpAliasKey& other) const {
-  return is_https == other.is_https &&
-      ip_endpoint == other.ip_endpoint;
+  return is_https == other.is_https && ip_endpoint == other.ip_endpoint;
 };
 
 // Responsible for creating a new QUIC session to the specified server, and
 // for notifying any associated requests when complete.
 class QuicStreamFactory::Job {
  public:
   Job(QuicStreamFactory* factory,
       HostResolver* host_resolver,
       const HostPortPair& host_port_pair,
       bool is_https,
@@ skipping 10 matching lines @@
   int DoLoop(int rv);
   int DoResolveHost();
   int DoResolveHostComplete(int rv);
   int DoLoadServerInfo();
   int DoLoadServerInfoComplete(int rv);
   int DoConnect();
   int DoConnectComplete(int rv);
 
   void OnIOComplete(int rv);
 
-  CompletionCallback callback() {
-    return callback_;
-  }
+  CompletionCallback callback() { return callback_; }
 
-  const QuicServerId server_id() const {
-    return server_id_;
-  }
+  const QuicServerId server_id() const { return server_id_; }
 
  private:
   enum IoState {
     STATE_NONE,
     STATE_RESOLVE_HOST,
     STATE_RESOLVE_HOST_COMPLETE,
     STATE_LOAD_SERVER_INFO,
     STATE_LOAD_SERVER_INFO_COMPLETE,
     STATE_CONNECT,
     STATE_CONNECT_COMPLETE,
@@ skipping 26 matching lines @@
                             const BoundNetLog& net_log)
     : factory_(factory),
       host_resolver_(host_resolver),
       server_id_(host_port_pair, is_https, privacy_mode),
       is_post_(method == "POST"),
       was_alternate_protocol_recently_broken_(
           was_alternate_protocol_recently_broken),
       server_info_(server_info),
       net_log_(net_log),
       session_(NULL),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+}
 
 QuicStreamFactory::Job::~Job() {
 }
 
 int QuicStreamFactory::Job::Run(const CompletionCallback& callback) {
   io_state_ = STATE_RESOLVE_HOST;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
@@ skipping 74 matching lines @@
   io_state_ = STATE_LOAD_SERVER_INFO;
   return OK;
 }
 
 int QuicStreamFactory::Job::DoLoadServerInfo() {
   io_state_ = STATE_LOAD_SERVER_INFO_COMPLETE;
 
   if (!server_info_)
     return OK;
 
-  return server_info_->WaitForDataReady(
-      base::Bind(&QuicStreamFactory::Job::OnIOComplete,
-                 weak_factory_.GetWeakPtr()));
+  return server_info_->WaitForDataReady(base::Bind(
+      &QuicStreamFactory::Job::OnIOComplete, weak_factory_.GetWeakPtr()));
 }
 
 int QuicStreamFactory::Job::DoLoadServerInfoComplete(int rv) {
   if (server_info_) {
     UMA_HISTOGRAM_TIMES("Net.QuicServerInfo.DiskCacheReadTime",
                         base::TimeTicks::Now() - disk_cache_load_start_time_);
   }
 
   if (rv != OK) {
     server_info_.reset();
   }
 
   io_state_ = STATE_CONNECT;
   return OK;
 }
 
 int QuicStreamFactory::Job::DoConnect() {
   io_state_ = STATE_CONNECT_COMPLETE;
 
-  int rv = factory_->CreateSession(server_id_, server_info_.Pass(),
-                                   address_list_, net_log_, &session_);
+  int rv = factory_->CreateSession(
+      server_id_, server_info_.Pass(), address_list_, net_log_, &session_);
   if (rv != OK) {
     DCHECK(rv != ERR_IO_PENDING);
     DCHECK(!session_);
     return rv;
   }
 
   session_->StartReading();
   if (!session_->connection()->connected()) {
     return ERR_QUIC_PROTOCOL_ERROR;
   }
-  bool require_confirmation =
-      factory_->require_confirmation() || server_id_.is_https() || is_post_ ||
-      was_alternate_protocol_recently_broken_;
-  rv = session_->CryptoConnect(
-      require_confirmation,
-      base::Bind(&QuicStreamFactory::Job::OnIOComplete,
-                 base::Unretained(this)));
+  bool require_confirmation = factory_->require_confirmation() ||
+                              server_id_.is_https() || is_post_ ||
+                              was_alternate_protocol_recently_broken_;
+  rv = session_->CryptoConnect(require_confirmation,
+                               base::Bind(&QuicStreamFactory::Job::OnIOComplete,
+                                          base::Unretained(this)));
   return rv;
 }
 
 int QuicStreamFactory::Job::DoConnectComplete(int rv) {
   if (rv != OK)
     return rv;
 
   DCHECK(!factory_->HasActiveSession(server_id_));
   // There may well now be an active session for this IP.  If so, use the
   // existing session instead.
   AddressList address(session_->connection()->peer_address());
   if (factory_->OnResolution(server_id_, address)) {
     session_->connection()->SendConnectionClose(QUIC_NO_ERROR);
     session_ = NULL;
     return OK;
   }
 
   factory_->ActivateSession(server_id_, session_);
 
   return OK;
 }
 
 QuicStreamRequest::QuicStreamRequest(QuicStreamFactory* factory)
-    : factory_(factory) {}
+    : factory_(factory) {
+}
 
 QuicStreamRequest::~QuicStreamRequest() {
   if (factory_ && !callback_.is_null())
     factory_->CancelRequest(this);
 }
 
 int QuicStreamRequest::Request(const HostPortPair& host_port_pair,
                                bool is_https,
                                PrivacyMode privacy_mode,
                                base::StringPiece method,
                                const BoundNetLog& net_log,
                                const CompletionCallback& callback) {
   DCHECK(!stream_);
   DCHECK(callback_.is_null());
   DCHECK(factory_);
-  int rv = factory_->Create(host_port_pair, is_https, privacy_mode, method,
-                            net_log, this);
+  int rv = factory_->Create(
+      host_port_pair, is_https, privacy_mode, method, net_log, this);
   if (rv == ERR_IO_PENDING) {
     host_port_pair_ = host_port_pair;
     is_https_ = is_https;
     net_log_ = net_log;
     callback_ = callback;
   } else {
     factory_ = NULL;
   }
   if (rv == OK)
     DCHECK(stream_);
@@ skipping 40 matching lines @@
       max_packet_length_(max_packet_length),
       supported_versions_(supported_versions),
       enable_port_selection_(enable_port_selection),
       enable_pacing_(enable_pacing),
       port_seed_(random_generator_->RandUint64()),
       weak_factory_(this) {
   config_.SetDefaults();
   config_.EnablePacing(enable_pacing_);
   if (enable_time_based_loss_detection)
     config_.SetLossDetectionToSend(kTIME);
-  config_.set_idle_connection_state_lifetime(
-      QuicTime::Delta::FromSeconds(30),
-      QuicTime::Delta::FromSeconds(30));
+  config_.set_idle_connection_state_lifetime(QuicTime::Delta::FromSeconds(30),
+                                             QuicTime::Delta::FromSeconds(30));
 
   crypto_config_.SetDefaults();
   crypto_config_.AddCanonicalSuffix(".c.youtube.com");
   crypto_config_.AddCanonicalSuffix(".googlevideo.com");
   crypto_config_.SetProofVerifier(new ProofVerifierChromium(cert_verifier));
   base::CPU cpu;
   if (cpu.has_aesni() && cpu.has_avx())
     crypto_config_.PreferAesGcm();
   if (!IsEcdsaSupported())
     crypto_config_.DisableEcdsa();
@@ skipping 33 matching lines @@
         crypto_config_.LookupOrCreate(server_id);
     DCHECK(cached);
     if (cached->IsEmpty()) {
       quic_server_info = quic_server_info_factory_->GetForServer(server_id);
     }
   }
   bool was_alternate_protocol_recently_broken =
       http_server_properties_ &&
       http_server_properties_->WasAlternateProtocolRecentlyBroken(
           server_id.host_port_pair());
-  scoped_ptr<Job> job(new Job(this, host_resolver_, host_port_pair, is_https,
+  scoped_ptr<Job> job(new Job(this,
+                              host_resolver_,
+                              host_port_pair,
+                              is_https,
                               was_alternate_protocol_recently_broken,
-                              privacy_mode, method, quic_server_info, net_log));
-  int rv = job->Run(base::Bind(&QuicStreamFactory::OnJobComplete,
-                               base::Unretained(this), job.get()));
+                              privacy_mode,
+                              method,
+                              quic_server_info,
+                              net_log));
+  int rv = job->Run(base::Bind(
+      &QuicStreamFactory::OnJobComplete, base::Unretained(this), job.get()));
 
   if (rv == ERR_IO_PENDING) {
     active_requests_[request] = job.get();
     job_requests_map_[job.get()].insert(request);
     active_jobs_[server_id] = job.release();
   }
   if (rv == OK) {
     DCHECK(HasActiveSession(server_id));
     request->set_stream(CreateIfSessionExists(server_id, net_log));
   }
   return rv;
 }
 
-bool QuicStreamFactory::OnResolution(
-    const QuicServerId& server_id,
-    const AddressList& address_list) {
+bool QuicStreamFactory::OnResolution(const QuicServerId& server_id,
+                                     const AddressList& address_list) {
   DCHECK(!HasActiveSession(server_id));
   for (size_t i = 0; i < address_list.size(); ++i) {
     const IPEndPoint& address = address_list[i];
     const IpAliasKey ip_alias_key(address, server_id.is_https());
     if (!ContainsKey(ip_aliases_, ip_alias_key))
       continue;
 
     const SessionSet& sessions = ip_aliases_[ip_alias_key];
-    for (SessionSet::const_iterator i = sessions.begin();
-         i != sessions.end(); ++i) {
+    for (SessionSet::const_iterator i = sessions.begin(); i != sessions.end();
+         ++i) {
       QuicClientSession* session = *i;
       if (!session->CanPool(server_id.host()))
         continue;
       active_sessions_[server_id] = session;
       session_aliases_[session].insert(server_id);
       return true;
     }
   }
   return false;
 }
 
 void QuicStreamFactory::OnJobComplete(Job* job, int rv) {
   if (rv == OK) {
     require_confirmation_ = false;
 
     // Create all the streams, but do not notify them yet.
     for (RequestSet::iterator it = job_requests_map_[job].begin();
-         it != job_requests_map_[job].end() ; ++it) {
+         it != job_requests_map_[job].end();
+         ++it) {
       DCHECK(HasActiveSession(job->server_id()));
-      (*it)->set_stream(CreateIfSessionExists(job->server_id(),
-                                              (*it)->net_log()));
+      (*it)->set_stream(
+          CreateIfSessionExists(job->server_id(), (*it)->net_log()));
     }
   }
   while (!job_requests_map_[job].empty()) {
     RequestSet::iterator it = job_requests_map_[job].begin();
     QuicStreamRequest* request = *it;
     job_requests_map_[job].erase(it);
     active_requests_.erase(request);
     // Even though we're invoking callbacks here, we don't need to worry
     // about |this| being deleted, because the factory is owned by the
     // profile which can not be deleted via callbacks.
@@ skipping 10 matching lines @@
 scoped_ptr<QuicHttpStream> QuicStreamFactory::CreateIfSessionExists(
     const QuicServerId& server_id,
     const BoundNetLog& net_log) {
   if (!HasActiveSession(server_id)) {
     DVLOG(1) << "No active session";
     return scoped_ptr<QuicHttpStream>();
   }
 
   QuicClientSession* session = active_sessions_[server_id];
   DCHECK(session);
-  return scoped_ptr<QuicHttpStream>(
-      new QuicHttpStream(session->GetWeakPtr()));
+  return scoped_ptr<QuicHttpStream>(new QuicHttpStream(session->GetWeakPtr()));
 }
 
 void QuicStreamFactory::OnIdleSession(QuicClientSession* session) {
 }
 
 void QuicStreamFactory::OnSessionGoingAway(QuicClientSession* session) {
   const AliasSet& aliases = session_aliases_[session];
   for (AliasSet::const_iterator it = aliases.begin(); it != aliases.end();
        ++it) {
     DCHECK(active_sessions_.count(*it));
@@ skipping 44 matching lines @@
     all_sessions_.begin()->first->CloseSessionOnError(error);
     DCHECK_NE(initial_size, all_sessions_.size());
   }
   DCHECK(all_sessions_.empty());
 }
 
 base::Value* QuicStreamFactory::QuicStreamFactoryInfoToValue() const {
   base::ListValue* list = new base::ListValue();
 
   for (SessionMap::const_iterator it = active_sessions_.begin();
-       it != active_sessions_.end(); ++it) {
+       it != active_sessions_.end();
+       ++it) {
     const QuicServerId& server_id = it->first;
     QuicClientSession* session = it->second;
     const AliasSet& aliases = session_aliases_.find(session)->second;
     // Only add a session to the list once.
     if (server_id == *aliases.begin()) {
       std::set<HostPortPair> hosts;
       for (AliasSet::const_iterator alias_it = aliases.begin();
-           alias_it != aliases.end(); ++alias_it) {
+           alias_it != aliases.end();
+           ++alias_it) {
         hosts.insert(alias_it->host_port_pair());
       }
       list->Append(session->GetInfoAsValue(hosts));
     }
   }
   return list;
 }
 
 void QuicStreamFactory::ClearCachedStatesInCryptoConfig() {
   crypto_config_.ClearCachedStates();
@@ skipping 14 matching lines @@
   // untrusted.
   //
   // We should not flush the sessions if we added trust to a cert.
   //
   // Since the OnCACertChanged method doesn't tell us what
   // kind of change it is, we have to flush the socket
   // pools to be safe.
   CloseAllSessions(ERR_CERT_DATABASE_CHANGED);
 }
 
-bool QuicStreamFactory::HasActiveSession(
-    const QuicServerId& server_id) const {
+bool QuicStreamFactory::HasActiveSession(const QuicServerId& server_id) const {
   return ContainsKey(active_sessions_, server_id);
 }
 
-int QuicStreamFactory::CreateSession(
-    const QuicServerId& server_id,
-    scoped_ptr<QuicServerInfo> server_info,
-    const AddressList& address_list,
-    const BoundNetLog& net_log,
-    QuicClientSession** session) {
+int QuicStreamFactory::CreateSession(const QuicServerId& server_id,
+                                     scoped_ptr<QuicServerInfo> server_info,
+                                     const AddressList& address_list,
+                                     const BoundNetLog& net_log,
+                                     QuicClientSession** session) {
   bool enable_port_selection = enable_port_selection_;
-  if (enable_port_selection &&
-      ContainsKey(gone_away_aliases_, server_id)) {
+  if (enable_port_selection && ContainsKey(gone_away_aliases_, server_id)) {
     // Disable port selection when the server is going away.
     // There is no point in trying to return to the same server, if
     // that server is no longer handling requests.
     enable_port_selection = false;
     gone_away_aliases_.erase(server_id);
   }
 
   QuicConnectionId connection_id = random_generator_->RandUint64();
   IPEndPoint addr = *address_list.begin();
   scoped_refptr<PortSuggester> port_suggester =
       new PortSuggester(server_id.host_port_pair(), port_seed_);
-  DatagramSocket::BindType bind_type = enable_port_selection ?
-      DatagramSocket::RANDOM_BIND :  // Use our callback.
-      DatagramSocket::DEFAULT_BIND;  // Use OS to randomize.
+  DatagramSocket::BindType bind_type =
+      enable_port_selection ? DatagramSocket::RANDOM_BIND
+                            :            // Use our callback.
+          DatagramSocket::DEFAULT_BIND;  // Use OS to randomize.
   scoped_ptr<DatagramClientSocket> socket(
       client_socket_factory_->CreateDatagramClientSocket(
           bind_type,
           base::Bind(&PortSuggester::SuggestPort, port_suggester),
-          net_log.net_log(), net_log.source()));
+          net_log.net_log(),
+          net_log.source()));
   int rv = socket->Connect(addr);
   if (rv != OK) {
     HistogramCreateSessionFailure(CREATION_ERROR_CONNECTING_SOCKET);
     return rv;
   }
   UMA_HISTOGRAM_COUNTS("Net.QuicEphemeralPortsSuggested",
                        port_suggester->call_count());
   if (enable_port_selection) {
     DCHECK_LE(1u, port_suggester->call_count());
   } else {
@@ skipping 18 matching lines @@
     HistogramCreateSessionFailure(CREATION_ERROR_SETTING_SEND_BUFFER);
     return rv;
   }
 
   scoped_ptr<QuicDefaultPacketWriter> writer(
       new QuicDefaultPacketWriter(socket.get()));
 
   if (!helper_.get()) {
     helper_.reset(new QuicConnectionHelper(
         base::MessageLoop::current()->message_loop_proxy().get(),
-        clock_.get(), random_generator_));
+        clock_.get(),
+        random_generator_));
   }
 
-  QuicConnection* connection =
-      new QuicConnection(connection_id, addr, helper_.get(), writer.get(),
-                         false, supported_versions_, kInitialReceiveWindowSize);
+  QuicConnection* connection = new QuicConnection(connection_id,
+                                                  addr,
+                                                  helper_.get(),
+                                                  writer.get(),
+                                                  false,
+                                                  supported_versions_,
+                                                  kInitialReceiveWindowSize);
   writer->SetConnection(connection);
   connection->options()->max_packet_length = max_packet_length_;
 
   InitializeCachedStateInCryptoConfig(server_id, server_info);
 
   QuicConfig config = config_;
   if (http_server_properties_) {
     const HttpServerProperties::NetworkStats* stats =
         http_server_properties_->GetServerNetworkStats(
             server_id.host_port_pair());
     if (stats != NULL) {
       config.SetInitialRoundTripTimeUsToSend(stats->srtt.InMicroseconds());
     }
   }
 
-  *session = new QuicClientSession(
-      connection, socket.Pass(), writer.Pass(), this,
-      quic_crypto_client_stream_factory_, server_info.Pass(), server_id,
-      config, &crypto_config_, net_log.net_log());
+  *session = new QuicClientSession(connection,
+                                   socket.Pass(),
+                                   writer.Pass(),
+                                   this,
+                                   quic_crypto_client_stream_factory_,
+                                   server_info.Pass(),
+                                   server_id,
+                                   config,
+                                   &crypto_config_,
+                                   net_log.net_log());
   all_sessions_[*session] = server_id;  // owning pointer
   return OK;
 }
 
 bool QuicStreamFactory::HasActiveJob(const QuicServerId& key) const {
   return ContainsKey(active_jobs_, key);
 }
 
-void QuicStreamFactory::ActivateSession(
-    const QuicServerId& server_id,
-    QuicClientSession* session) {
+void QuicStreamFactory::ActivateSession(const QuicServerId& server_id,
+                                        QuicClientSession* session) {
   DCHECK(!HasActiveSession(server_id));
   active_sessions_[server_id] = session;
   session_aliases_[session].insert(server_id);
   const IpAliasKey ip_alias_key(session->connection()->peer_address(),
                                 server_id.is_https());
   DCHECK(!ContainsKey(ip_aliases_[ip_alias_key], session));
   ip_aliases_[ip_alias_key].insert(session);
 }
 
 void QuicStreamFactory::InitializeCachedStateInCryptoConfig(
@@ skipping 13 matching lines @@
                           server_info->state().server_config_sig,
                           clock_->WallNow()))
     return;
 
   if (!server_id.is_https()) {
     // Don't check the certificates for insecure QUIC.
     cached->SetProofValid();
   }
 }
 
-void QuicStreamFactory::ProcessGoingAwaySession(
-    QuicClientSession* session,
-    const QuicServerId& server_id) {
+void QuicStreamFactory::ProcessGoingAwaySession(QuicClientSession* session,
+                                                const QuicServerId& server_id) {
   if (!http_server_properties_)
     return;
 
   const QuicConnectionStats& stats = session->connection()->GetStats();
   if (!session->IsCryptoHandshakeConfirmed()) {
     // TODO(rch):  In the special case where the session has received no
     // packets from the peer, we should consider blacklisting this
     // differently so that we still race TCP but we don't consider the
     // session connected until the handshake has been confirmed.
     HistogramBrokenAlternateProtocolLocation(
         BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_STREAM_FACTORY);
     http_server_properties_->SetBrokenAlternateProtocol(
         server_id.host_port_pair());
     UMA_HISTOGRAM_COUNTS("Net.QuicHandshakeNotConfirmedNumPacketsReceived",
                          stats.packets_received);
     return;
   }
 
   HttpServerProperties::NetworkStats network_stats;
   network_stats.srtt = base::TimeDelta::FromMicroseconds(stats.srtt_us);
   network_stats.bandwidth_estimate = stats.estimated_bandwidth;
   http_server_properties_->SetServerNetworkStats(server_id.host_port_pair(),
                                                  network_stats);
 }
 
 }  // namespace net