Clang format slam.

net/tools/flip_server/spdy_interface.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/flip_server/spdy_interface.h"
 
 #include <algorithm>
 #include <string>
 
 #include "net/spdy/spdy_framer.h"
@@ skipping 33 matching lines @@
       client_output_list_(connection->output_list()),
       client_output_ordering_(connection),
       next_outgoing_stream_id_(2),
       epoll_server_(epoll_server),
       acceptor_(acceptor),
       memory_cache_(memory_cache),
       close_on_error_(false) {
   buffered_spdy_framer_->set_visitor(this);
 }
 
-SpdySM::~SpdySM() { }
+SpdySM::~SpdySM() {
+}
 
 void SpdySM::InitSMConnection(SMConnectionPoolInterface* connection_pool,
                               SMInterface* sm_interface,
                               EpollServer* epoll_server,
                               int fd,
                               std::string server_ip,
                               std::string server_port,
                               std::string remote_ip,
                               bool use_ssl) {
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Initializing server connection.";
   connection_->InitSMConnection(connection_pool,
                                 sm_interface,
                                 epoll_server,
                                 fd,
                                 server_ip,
                                 server_port,
                                 remote_ip,
                                 use_ssl);
 }
 
 SMInterface* SpdySM::NewConnectionInterface() {
-  SMConnection* server_connection =
-      SMConnection::NewSMConnection(epoll_server_,
-                                    NULL,
-                                    memory_cache_,
-                                    acceptor_,
-                                    "http_conn: ");
+  SMConnection* server_connection = SMConnection::NewSMConnection(
+      epoll_server_, NULL, memory_cache_, acceptor_, "http_conn: ");
   if (server_connection == NULL) {
     LOG(ERROR) << "SpdySM: Could not create server connection";
     return NULL;
   }
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Creating new HTTP interface";
   SMInterface* sm_http_interface =
       new HttpSM(server_connection, this, memory_cache_, acceptor_);
   return sm_http_interface;
 }
 
@@ skipping 79 matching lines @@
     host_string = host->second;
     path_string = path->second;
     version_string = "HTTP/1.1";
   }
 
   if (scheme->second.compare("https") == 0) {
     *is_https_scheme = true;
   }
 
   if (acceptor_->flip_handler_type_ == FLIP_HANDLER_SPDY_SERVER) {
-    VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Request: " << method->second
-            << " " << path_string;
-    std::string filename = EncodeURL(path_string,
-                                     host_string,
-                                     method->second);
+    VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Request: " << method->second << " "
+            << path_string;
+    std::string filename = EncodeURL(path_string, host_string, method->second);
     NewStream(stream_id, priority, filename);
   } else {
     http_data +=
         method->second + " " + path_string + " " + version_string + "\r\n";
     VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Request: " << method->second << " "
             << path_string << " " << version_string;
-    http_data += "Host: " + (*is_https_scheme ?
-                             acceptor_->https_server_ip_ :
-                             acceptor_->http_server_ip_) + "\r\n";
+    http_data += "Host: " + (*is_https_scheme ? acceptor_->https_server_ip_
+                                              : acceptor_->http_server_ip_) +
+                 "\r\n";
     for (SpdyHeaderBlock::const_iterator i = headers.begin();
-         i != headers.end(); ++i) {
-      if ((i->first.size() > 0 && i->first[0] == ':') ||
-          i->first == "host" ||
-          i == method ||
-          i == host ||
-          i == path ||
-          i == scheme ||
-          i == version ||
-          i == url) {
+         i != headers.end();
+         ++i) {
+      if ((i->first.size() > 0 && i->first[0] == ':') || i->first == "host" ||
+          i == method || i == host || i == path || i == scheme ||
+          i == version || i == url) {
         // Ignore the entry.
       } else {
         http_data += i->first + ": " + i->second + "\r\n";
         VLOG(2) << ACCEPTOR_CLIENT_IDENT << i->first.c_str() << ":"
                 << i->second.c_str();
       }
     }
     if (forward_ip_header_.length()) {
       // X-Client-Cluster-IP header
-      http_data += forward_ip_header_ + ": " +
-          connection_->client_ip() + "\r\n";
+      http_data +=
+          forward_ip_header_ + ": " + connection_->client_ip() + "\r\n";
     }
     http_data += "\r\n";
   }
 
   VLOG(3) << ACCEPTOR_CLIENT_IDENT << "SpdySM: HTTP Request:\n" << http_data;
   return 1;
 }
 
 void SpdySM::OnStreamFrameData(SpdyStreamId stream_id,
                                const char* data,
@@ skipping 68 matching lines @@
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnRstStream(" << stream_id
           << ")";
   client_output_ordering_.RemoveStreamId(stream_id);
 }
 
 size_t SpdySM::ProcessReadInput(const char* data, size_t len) {
   DCHECK(buffered_spdy_framer_);
   return buffered_spdy_framer_->ProcessInput(data, len);
 }
 
-size_t SpdySM::ProcessWriteInput(const char* data, size_t len) { return 0; }
+size_t SpdySM::ProcessWriteInput(const char* data, size_t len) {
+  return 0;
+}
 
 bool SpdySM::MessageFullyRead() const {
   DCHECK(buffered_spdy_framer_);
   return buffered_spdy_framer_->MessageFullyRead();
 }
 
 bool SpdySM::Error() const {
   DCHECK(buffered_spdy_framer_);
   return close_on_error_ || buffered_spdy_framer_->HasError();
 }
@@ skipping 51 matching lines @@
     }
   } else {
     AddToOutputOrder(mci);
   }
 }
 
 void SpdySM::AddToOutputOrder(const MemCacheIter& mci) {
   client_output_ordering_.AddToOutputOrder(mci);
 }
 
-void SpdySM::SendEOF(uint32 stream_id) { SendEOFImpl(stream_id); }
+void SpdySM::SendEOF(uint32 stream_id) {
+  SendEOFImpl(stream_id);
+}
 
 void SpdySM::SendErrorNotFound(uint32 stream_id) {
   SendErrorNotFoundImpl(stream_id);
 }
 
 size_t SpdySM::SendSynStream(uint32 stream_id, const BalsaHeaders& headers) {
   return SendSynStreamImpl(stream_id, headers);
 }
 
 size_t SpdySM::SendSynReply(uint32 stream_id, const BalsaHeaders& headers) {
@@ skipping 96 matching lines @@
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending SynStreamheader "
           << stream_id;
   return df_size;
 }
 
 size_t SpdySM::SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers) {
   SpdyHeaderBlock block;
   CopyHeaders(block, headers);
   if (spdy_version() == SPDY2) {
     block["status"] = headers.response_code().as_string() + " " +
-        headers.response_reason_phrase().as_string();
+                      headers.response_reason_phrase().as_string();
     block["version"] = headers.response_version().as_string();
   } else {
     block[":status"] = headers.response_code().as_string() + " " +
-        headers.response_reason_phrase().as_string();
+                       headers.response_reason_phrase().as_string();
     block[":version"] = headers.response_version().as_string();
   }
 
   DCHECK(buffered_spdy_framer_);
   SpdyFrame* fsrcf = buffered_spdy_framer_->CreateSynReply(
       stream_id, CONTROL_FLAG_NONE, &block);
   size_t df_size = fsrcf->size();
   EnqueueDataFrame(new SpdyFrameDataFrame(fsrcf));
 
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending SynReplyheader "
@@ skipping 107 matching lines @@
   }
 }
 
 void SpdySM::CreateFramer(SpdyMajorVersion spdy_version) {
   DCHECK(!buffered_spdy_framer_);
   buffered_spdy_framer_.reset(new BufferedSpdyFramer(spdy_version, true));
   buffered_spdy_framer_->set_visitor(this);
 }
 
 }  // namespace net