Clang format slam.

net/tools/quic/quic_client.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/tools/quic/quic_client.h"
 
 #include <errno.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/epoll.h>
@@ skipping 54 matching lines @@
       initialized_(false),
       packets_dropped_(0),
       overflow_supported_(false),
       supported_versions_(supported_versions),
       print_response_(false),
       initial_flow_control_window_(initial_flow_control_window) {
 }
 
 QuicClient::~QuicClient() {
   if (connected()) {
-    session()->connection()->SendConnectionClosePacket(
-        QUIC_PEER_GOING_AWAY, "");
+    session()->connection()->SendConnectionClosePacket(QUIC_PEER_GOING_AWAY,
+                                                       "");
   }
 }
 
 bool QuicClient::Initialize() {
   DCHECK(!initialized_);
 
   epoll_server_.set_timeout_in_us(50 * 1000);
   crypto_config_.SetDefaults();
 
   int address_family = server_address_.GetSockAddrFamily();
   fd_ = socket(address_family, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
   if (fd_ < 0) {
     LOG(ERROR) << "CreateSocket() failed: " << strerror(errno);
     return false;
   }
 
   int get_overflow = 1;
-  int rc = setsockopt(fd_, SOL_SOCKET, SO_RXQ_OVFL, &get_overflow,
-                      sizeof(get_overflow));
+  int rc = setsockopt(
+      fd_, SOL_SOCKET, SO_RXQ_OVFL, &get_overflow, sizeof(get_overflow));
   if (rc < 0) {
     DLOG(WARNING) << "Socket overflow detection not supported";
   } else {
     overflow_supported_ = true;
   }
 
   if (!QuicSocketUtils::SetReceiveBufferSize(fd_,
                                              TcpReceiver::kReceiveWindowTCP)) {
     return false;
   }
 
   if (!QuicSocketUtils::SetSendBufferSize(fd_,
                                           TcpReceiver::kReceiveWindowTCP)) {
     return false;
   }
 
   int get_local_ip = 1;
   if (address_family == AF_INET) {
-    rc = setsockopt(fd_, IPPROTO_IP, IP_PKTINFO,
-                    &get_local_ip, sizeof(get_local_ip));
+    rc = setsockopt(
+        fd_, IPPROTO_IP, IP_PKTINFO, &get_local_ip, sizeof(get_local_ip));
   } else {
-    rc =  setsockopt(fd_, IPPROTO_IPV6, IPV6_RECVPKTINFO,
-                     &get_local_ip, sizeof(get_local_ip));
+    rc = setsockopt(fd_,
+                    IPPROTO_IPV6,
+                    IPV6_RECVPKTINFO,
+                    &get_local_ip,
+                    sizeof(get_local_ip));
   }
 
   if (rc < 0) {
     LOG(ERROR) << "IP detection not supported" << strerror(errno);
     return false;
   }
 
   if (bind_to_address_.size() != 0) {
     client_address_ = IPEndPoint(bind_to_address_, local_port_);
   } else if (address_family == AF_INET) {
     IPAddressNumber any4;
     CHECK(net::ParseIPLiteralToNumber("0.0.0.0", &any4));
     client_address_ = IPEndPoint(any4, local_port_);
   } else {
     IPAddressNumber any6;
     CHECK(net::ParseIPLiteralToNumber("::", &any6));
     client_address_ = IPEndPoint(any6, local_port_);
   }
 
   sockaddr_storage raw_addr;
   socklen_t raw_addr_len = sizeof(raw_addr);
   CHECK(client_address_.ToSockAddr(reinterpret_cast<sockaddr*>(&raw_addr),
-                           &raw_addr_len));
-  rc = bind(fd_,
-            reinterpret_cast<const sockaddr*>(&raw_addr),
-            sizeof(raw_addr));
+                                   &raw_addr_len));
+  rc =
+      bind(fd_, reinterpret_cast<const sockaddr*>(&raw_addr), sizeof(raw_addr));
   if (rc < 0) {
     LOG(ERROR) << "Bind failed: " << strerror(errno);
     return false;
   }
 
   SockaddrStorage storage;
   if (getsockname(fd_, storage.addr, &storage.addr_len) != 0 ||
       !client_address_.FromSockAddr(storage.addr, storage.addr_len)) {
     LOG(ERROR) << "Unable to get self address.  Error: " << strerror(errno);
   }
@@ skipping 15 matching lines @@
 
 bool QuicClient::StartConnect() {
   DCHECK(initialized_);
   DCHECK(!connected());
 
   QuicPacketWriter* writer = CreateQuicPacketWriter();
   if (writer_.get() != writer) {
     writer_.reset(writer);
   }
 
-  session_.reset(new QuicClientSession(
-      server_id_,
-      config_,
-      new QuicConnection(GenerateConnectionId(), server_address_, helper_.get(),
-                         writer_.get(), false, supported_versions_,
-                         initial_flow_control_window_),
-      &crypto_config_));
+  session_.reset(
+      new QuicClientSession(server_id_,
+                            config_,
+                            new QuicConnection(GenerateConnectionId(),
+                                               server_address_,
+                                               helper_.get(),
+                                               writer_.get(),
+                                               false,
+                                               supported_versions_,
+                                               initial_flow_control_window_),
+                            &crypto_config_));
   return session_->CryptoConnect();
 }
 
 bool QuicClient::EncryptionBeingEstablished() {
   return !session_->IsEncryptionEstablished() &&
-      session_->connection()->connected();
+         session_->connection()->connected();
 }
 
 void QuicClient::Disconnect() {
   DCHECK(initialized_);
 
   if (connected()) {
     session()->connection()->SendConnectionClose(QUIC_PEER_GOING_AWAY);
   }
   epoll_server_.UnregisterFD(fd_);
   close(fd_);
   fd_ = -1;
   initialized_ = false;
 }
 
 void QuicClient::SendRequestsAndWaitForResponse(
     const CommandLine::StringVector& args) {
   for (size_t i = 0; i < args.size(); ++i) {
     BalsaHeaders headers;
     headers.SetRequestFirstlineFromStringPieces("GET", args[i], "HTTP/1.1");
     QuicSpdyClientStream* stream = CreateReliableClientStream();
     stream->SendRequest(headers, "", true);
     stream->set_visitor(this);
   }
 
-  while (WaitForEvents()) { }
+  while (WaitForEvents()) {
+  }
 }
 
 QuicSpdyClientStream* QuicClient::CreateReliableClientStream() {
   if (!connected()) {
     return NULL;
   }
 
   return session_->CreateOutgoingDataStream();
 }
 
@@ skipping 45 matching lines @@
   }
 
   if (!print_response_) {
     return;
   }
 
   const BalsaHeaders& headers = client_stream->headers();
   printf("%s\n", headers.first_line().as_string().c_str());
   for (BalsaHeaders::const_header_lines_iterator i =
            headers.header_lines_begin();
-       i != headers.header_lines_end(); ++i) {
-    printf("%s: %s\n", i->first.as_string().c_str(),
+       i != headers.header_lines_end();
+       ++i) {
+    printf("%s: %s\n",
+           i->first.as_string().c_str(),
            i->second.as_string().c_str());
   }
   printf("%s\n", client_stream->data().c_str());
 }
 
 QuicPacketCreator::Options* QuicClient::options() {
   if (session() == NULL) {
     return NULL;
   }
   return session_->options();
 }
 
 bool QuicClient::connected() const {
   return session_.get() && session_->connection() &&
-      session_->connection()->connected();
+         session_->connection()->connected();
 }
 
 QuicConnectionId QuicClient::GenerateConnectionId() {
   return QuicRandom::GetInstance()->RandUint64();
 }
 
 QuicEpollConnectionHelper* QuicClient::CreateQuicConnectionHelper() {
   return new QuicEpollConnectionHelper(&epoll_server_);
 }
 
 QuicPacketWriter* QuicClient::CreateQuicPacketWriter() {
   return new QuicDefaultPacketWriter(fd_);
 }
 
 int QuicClient::ReadPacket(char* buffer,
                            int buffer_len,
                            IPEndPoint* server_address,
                            IPAddressNumber* client_ip) {
   return QuicSocketUtils::ReadPacket(
-      fd_, buffer, buffer_len, overflow_supported_ ? &packets_dropped_ : NULL,
-      client_ip, server_address);
+      fd_,
+      buffer,
+      buffer_len,
+      overflow_supported_ ? &packets_dropped_ : NULL,
+      client_ip,
+      server_address);
 }
 
 bool QuicClient::ReadAndProcessPacket() {
   // Allocate some extra space so we can send an error if the server goes over
   // the limit.
   char buf[2 * kMaxPacketSize];
 
   IPEndPoint server_address;
   IPAddressNumber client_ip;
 
   int bytes_read = ReadPacket(buf, arraysize(buf), &server_address, &client_ip);
 
   if (bytes_read < 0) {
     return false;
   }
 
   QuicEncryptedPacket packet(buf, bytes_read, false);
 
   IPEndPoint client_address(client_ip, client_address_.port());
   session_->connection()->ProcessUdpPacket(
       client_address, server_address, packet);
   return true;
 }
 
 }  // namespace tools
 }  // namespace net