Format and Refactor Flip Server.

Apply clang-format, remove std::cout and so on.
This CL does not change the behavior.

BUG=NONE
R=tyoshino@chromium.org

Review URL: https://codereview.chromium.org/93793004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@239672 0039d316-1c4b-4281-b951-d872f2087c98

34 files changed, 634 insertions, 784 deletions

diff --git a/net/tools/flip_server/acceptor_thread.cc b/net/tools/flip_server/acceptor_thread.cc
index ed8a3ec..5dfece1 100644
--- a/net/tools/flip_server/acceptor_thread.cc
+++ b/net/tools/flip_server/acceptor_thread.cc
@@ -20,7 +20,7 @@
 
 namespace net {
 
-SMAcceptorThread::SMAcceptorThread(FlipAcceptor *acceptor,
+SMAcceptorThread::SMAcceptorThread(FlipAcceptor* acceptor,
                                    MemoryCache* memory_cache)
     : SimpleThread("SMAcceptorThread"),
       acceptor_(acceptor),
@@ -48,7 +48,7 @@ SMAcceptorThread::SMAcceptorThread(FlipAcceptor *acceptor,
 
 SMAcceptorThread::~SMAcceptorThread() {
   for (std::vector<SMConnection*>::iterator i =
-       allocated_server_connections_.begin();
+           allocated_server_connections_.begin();
        i != allocated_server_connections_.end();
        ++i) {
     delete *i;
@@ -57,10 +57,8 @@ SMAcceptorThread::~SMAcceptorThread() {
 }
 
 SMConnection* SMAcceptorThread::NewConnection() {
-  SMConnection* server =
-    SMConnection::NewSMConnection(&epoll_server_, ssl_state_,
-                                  memory_cache_, acceptor_,
-                                  "client_conn: ");
+  SMConnection* server = SMConnection::NewSMConnection(
+      &epoll_server_, ssl_state_, memory_cache_, acceptor_, "client_conn: ");
   allocated_server_connections_.push_back(server);
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "Acceptor: Making new server.";
   return server;
@@ -81,12 +79,15 @@ void SMAcceptorThread::InitWorker() {
 }
 
 void SMAcceptorThread::HandleConnection(int server_fd,
-                                        struct sockaddr_in *remote_addr) {
+                                        struct sockaddr_in* remote_addr) {
   int on = 1;
   int rc;
   if (acceptor_->disable_nagle_) {
-    rc = setsockopt(server_fd, IPPROTO_TCP,  TCP_NODELAY,
-                    reinterpret_cast<char*>(&on), sizeof(on));
+    rc = setsockopt(server_fd,
+                    IPPROTO_TCP,
+                    TCP_NODELAY,
+                    reinterpret_cast<char*>(&on),
+                    sizeof(on));
     if (rc < 0) {
       close(server_fd);
       LOG(ERROR) << "setsockopt() failed fd=" << server_fd;
@@ -128,7 +129,7 @@ void SMAcceptorThread::AcceptFromListenFD() {
         break;
       }
       VLOG(1) << ACCEPTOR_CLIENT_IDENT << " Accepted connection";
-      HandleConnection(fd, (struct sockaddr_in *)&address);
+      HandleConnection(fd, (struct sockaddr_in*)&address);
     }
   } else {
     while (true) {
@@ -144,7 +145,7 @@ void SMAcceptorThread::AcceptFromListenFD() {
         break;
       }
       VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Accepted connection";
-      HandleConnection(fd, (struct sockaddr_in *)&address);
+      HandleConnection(fd, (struct sockaddr_in*)&address);
     }
   }
 }
@@ -162,7 +163,7 @@ void SMAcceptorThread::HandleConnectionIdleTimeout() {
   //                is already in-order.
   std::list<SMConnection*>::iterator iter = active_server_connections_.begin();
   while (iter != active_server_connections_.end()) {
-    SMConnection *conn = *iter;
+    SMConnection* conn = *iter;
     int elapsed_time = (cur_time - conn->last_read_time_);
     if (elapsed_time > idle_socket_timeout_s_) {
       conn->Cleanup("Connection idle timeout reached.");
@@ -208,5 +209,3 @@ void SMAcceptorThread::SMConnectionDone(SMConnection* sc) {
 }
 
 }  // namespace net
-
-
diff --git a/net/tools/flip_server/acceptor_thread.h b/net/tools/flip_server/acceptor_thread.h
index 7c758d9..bcaa43e 100644
--- a/net/tools/flip_server/acceptor_thread.h
+++ b/net/tools/flip_server/acceptor_thread.h
@@ -28,25 +28,25 @@ struct SSLState;
 //    a bool cross threads - especially one which only is set once...
 class Notification {
  public:
-   explicit Notification(bool value) : value_(value) {}
-
-   void Notify() {
-     base::AutoLock al(lock_);
-     value_ = true;
-   }
-   bool HasBeenNotified() {
-     base::AutoLock al(lock_);
-     return value_;
-   }
-   bool value_;
-   base::Lock lock_;
+  explicit Notification(bool value) : value_(value) {}
+
+  void Notify() {
+    base::AutoLock al(lock_);
+    value_ = true;
+  }
+  bool HasBeenNotified() {
+    base::AutoLock al(lock_);
+    return value_;
+  }
+  bool value_;
+  base::Lock lock_;
 };
 
 class SMAcceptorThread : public base::SimpleThread,
                          public EpollCallbackInterface,
                          public SMConnectionPoolInterface {
  public:
-  SMAcceptorThread(FlipAcceptor *acceptor, MemoryCache* memory_cache);
+  SMAcceptorThread(FlipAcceptor* acceptor, MemoryCache* memory_cache);
   virtual ~SMAcceptorThread();
 
   // EpollCallbackInteface interface
@@ -65,7 +65,7 @@ class SMAcceptorThread : public base::SimpleThread,
   SMConnection* NewConnection();
   SMConnection* FindOrMakeNewSMConnection();
   void InitWorker();
-  void HandleConnection(int server_fd, struct sockaddr_in *remote_addr);
+  void HandleConnection(int server_fd, struct sockaddr_in* remote_addr);
   void AcceptFromListenFD();
 
   // Notify the Accept thread that it is time to terminate.
diff --git a/net/tools/flip_server/constants.h b/net/tools/flip_server/constants.h
index cc07d61..5516509 100644
--- a/net/tools/flip_server/constants.h
+++ b/net/tools/flip_server/constants.h
@@ -15,8 +15,7 @@ const int kSSLSegmentSize = (1 * kMSS) - kSSLOverhead;
 const int kSpdySegmentSize = kSSLSegmentSize - kSpdyOverhead;
 
 #define ACCEPTOR_CLIENT_IDENT \
-    acceptor_->listen_ip_ << ":" \
-    << acceptor_->listen_port_ << " "
+  acceptor_->listen_ip_ << ":" << acceptor_->listen_port_ << " "
 
 #define IPV4_PRINTABLE_FORMAT(IP) (((IP)>>0)&0xff), (((IP)>>8)&0xff), \
                                   (((IP)>>16)&0xff), (((IP)>>24)&0xff)
diff --git a/net/tools/flip_server/create_listener.cc b/net/tools/flip_server/create_listener.cc
index 21867a9..c1c0896 100644
--- a/net/tools/flip_server/create_listener.cc
+++ b/net/tools/flip_server/create_listener.cc
@@ -4,17 +4,16 @@
 
 #include "net/tools/flip_server/create_listener.h"
 
-#include <arpa/inet.h>   // for inet_ntop
-#include <errno.h>       // for strerror
-#include <netdb.h>       // for getaddrinfo and getnameinfo
-#include <netinet/in.h>  // for IPPROTO_*, etc.
-#include <stdlib.h>      // for EXIT_FAILURE
-#include <netinet/tcp.h> // For TCP_NODELAY
-#include <sys/socket.h>  // for getaddrinfo and getnameinfo
-#include <sys/types.h>   // "
+#include <arpa/inet.h>
+#include <errno.h>
 #include <fcntl.h>
-#include <unistd.h>      // for exit()
-#include <ostream>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #include "base/logging.h"
 
@@ -24,20 +23,15 @@ namespace net {
 // alloc'd by getaddrinfo
 class AddrinfoGuard {
  protected:
-  struct addrinfo * addrinfo_ptr_;
- public:
+  struct addrinfo* addrinfo_ptr_;
 
-  explicit AddrinfoGuard(struct addrinfo* addrinfo_ptr) :
-    addrinfo_ptr_(addrinfo_ptr) {}
+ public:
+  explicit AddrinfoGuard(struct addrinfo* addrinfo_ptr)
+      : addrinfo_ptr_(addrinfo_ptr) {}
 
-  ~AddrinfoGuard() {
-    freeaddrinfo(addrinfo_ptr_);
-  }
+  ~AddrinfoGuard() { freeaddrinfo(addrinfo_ptr_); }
 };
 
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
 // Summary:
 //   Closes a socket, with option to attempt it multiple times.
 //   Why do this? Well, if the system-call gets interrupted, close
@@ -53,7 +47,7 @@ class AddrinfoGuard {
 // Side-effects:
 //   sets *fd to -1 if socket was closed.
 //
-bool CloseSocket(int *fd, int tries) {
+bool CloseSocket(int* fd, int tries) {
   for (int i = 0; i < tries; ++i) {
     if (!close(*fd)) {
       *fd = -1;
@@ -63,32 +57,28 @@ bool CloseSocket(int *fd, int tries) {
   return false;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
 // Sets an FD to be nonblocking.
 void FlipSetNonBlocking(int fd) {
   DCHECK_GE(fd, 0);
 
   int fcntl_return = fcntl(fd, F_GETFL, 0);
-  CHECK_NE(fcntl_return, -1)
-    << "error doing fcntl(fd, F_GETFL, 0) fd: " << fd
-    << " errno=" << errno;
+  CHECK_NE(fcntl_return, -1) << "error doing fcntl(fd, F_GETFL, 0) fd: " << fd
+                             << " errno=" << errno;
 
   if (fcntl_return & O_NONBLOCK)
     return;
 
   fcntl_return = fcntl(fd, F_SETFL, fcntl_return | O_NONBLOCK);
   CHECK_NE(fcntl_return, -1)
-    << "error doing fcntl(fd, F_SETFL, fcntl_return) fd: " << fd
-    << " errno=" << errno;
+      << "error doing fcntl(fd, F_SETFL, fcntl_return) fd: " << fd
+      << " errno=" << errno;
 }
 
 int SetDisableNagle(int fd) {
   int on = 1;
   int rc;
-  rc = setsockopt(fd, IPPROTO_TCP,  TCP_NODELAY,
-                  reinterpret_cast<char*>(&on), sizeof(on));
+  rc = setsockopt(
+      fd, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*>(&on), sizeof(on));
   if (rc < 0) {
     close(fd);
     LOG(FATAL) << "setsockopt() TCP_NODELAY: failed on fd " << fd;
@@ -106,17 +96,19 @@ int CreateListeningSocket(const std::string& host,
                           bool reuseport,
                           bool wait_for_iface,
                           bool disable_nagle,
-                          int * listen_fd ) {
+                          int* listen_fd) {
   // start out by assuming things will fail.
   *listen_fd = -1;
 
   const char* node = NULL;
   const char* service = NULL;
 
-  if (!host.empty()) node = host.c_str();
-  if (!port.empty()) service = port.c_str();
+  if (!host.empty())
+    node = host.c_str();
+  if (!port.empty())
+    service = port.c_str();
 
-  struct addrinfo *results = 0;
+  struct addrinfo* results = 0;
   struct addrinfo hints;
   memset(&hints, 0, sizeof(hints));
 
@@ -129,21 +121,21 @@ int CreateListeningSocket(const std::string& host,
   hints.ai_socktype = SOCK_STREAM;
 
   int err = 0;
-  if ((err=getaddrinfo(node, service, &hints, &results))) {
+  if ((err = getaddrinfo(node, service, &hints, &results))) {
     // gai_strerror -is- threadsafe, so we get to use it here.
-    LOG(ERROR) << "getaddrinfo " << " for (" << host << ":" << port
-                  << ") " << gai_strerror(err) << "\n";
+    LOG(ERROR) << "getaddrinfo "
+               << " for (" << host << ":" << port << ") " << gai_strerror(err)
+               << "\n";
     return -1;
   }
   // this will delete the addrinfo memory when we return from this function.
   AddrinfoGuard addrinfo_guard(results);
 
-  int sock = socket(results->ai_family,
-                    results->ai_socktype,
-                    results->ai_protocol);
+  int sock =
+      socket(results->ai_family, results->ai_socktype, results->ai_protocol);
   if (sock == -1) {
-    LOG(ERROR) << "Unable to create socket for (" << host << ":"
-      << port << "): " << strerror(errno) << "\n";
+    LOG(ERROR) << "Unable to create socket for (" << host << ":" << port
+               << "): " << strerror(errno) << "\n";
     return -1;
   }
 
@@ -151,8 +143,11 @@ int CreateListeningSocket(const std::string& host,
     // set SO_REUSEADDR on the listening socket.
     int on = 1;
     int rc;
-    rc = setsockopt(sock, SOL_SOCKET,  SO_REUSEADDR,
-                    reinterpret_cast<char *>(&on), sizeof(on));
+    rc = setsockopt(sock,
+                    SOL_SOCKET,
+                    SO_REUSEADDR,
+                    reinterpret_cast<char*>(&on),
+                    sizeof(on));
     if (rc < 0) {
       close(sock);
       LOG(FATAL) << "setsockopt() failed fd=" << listen_fd << "\n";
@@ -165,8 +160,11 @@ int CreateListeningSocket(const std::string& host,
     // set SO_REUSEADDR on the listening socket.
     int on = 1;
     int rc;
-    rc = setsockopt(sock, SOL_SOCKET,  SO_REUSEPORT,
-                    reinterpret_cast<char *>(&on), sizeof(on));
+    rc = setsockopt(sock,
+                    SOL_SOCKET,
+                    SO_REUSEPORT,
+                    reinterpret_cast<char*>(&on),
+                    sizeof(on));
     if (rc < 0) {
       close(sock);
       LOG(FATAL) << "setsockopt() failed fd=" << listen_fd << "\n";
@@ -177,21 +175,21 @@ int CreateListeningSocket(const std::string& host,
     // If we are waiting for the interface to be raised, such as in an
     // HA environment, ignore reporting any errors.
     int saved_errno = errno;
-    if ( !wait_for_iface || errno != EADDRNOTAVAIL) {
-      LOG(ERROR) << "Bind was unsuccessful for (" << host << ":"
-        << port << "): " << strerror(errno) << "\n";
+    if (!wait_for_iface || errno != EADDRNOTAVAIL) {
+      LOG(ERROR) << "Bind was unsuccessful for (" << host << ":" << port
+                 << "): " << strerror(errno) << "\n";
     }
     // if we knew that we were not multithreaded, we could do the following:
     // " : " << strerror(errno) << "\n";
     if (CloseSocket(&sock, 100)) {
-      if ( saved_errno == EADDRNOTAVAIL ) {
+      if (saved_errno == EADDRNOTAVAIL) {
         return -3;
       }
       return -2;
     } else {
       // couldn't even close the dang socket?!
       LOG(ERROR) << "Unable to close the socket.. Considering this a fatal "
-                      "error, and exiting\n";
+                    "error, and exiting\n";
       exit(EXIT_FAILURE);
       return -1;
     }
@@ -205,8 +203,8 @@ int CreateListeningSocket(const std::string& host,
 
   if (listen(sock, backlog)) {
     // listen was unsuccessful.
-    LOG(ERROR) << "Listen was unsuccessful for (" << host << ":"
-      << port << "): " << strerror(errno) << "\n";
+    LOG(ERROR) << "Listen was unsuccessful for (" << host << ":" << port
+               << "): " << strerror(errno) << "\n";
     // if we knew that we were not multithreaded, we could do the following:
     // " : " << strerror(errno) << "\n";
 
@@ -216,7 +214,7 @@ int CreateListeningSocket(const std::string& host,
     } else {
       // couldn't even close the dang socket?!
       LOG(FATAL) << "Unable to close the socket.. Considering this a fatal "
-                      "error, and exiting\n";
+                    "error, and exiting\n";
     }
   }
 
@@ -226,11 +224,11 @@ int CreateListeningSocket(const std::string& host,
   return 0;
 }
 
-int CreateConnectedSocket( int *connect_fd,
-                           const std::string& host,
-                           const std::string& port,
-                           bool is_numeric_host_address,
-                           bool disable_nagle ) {
+int CreateConnectedSocket(int* connect_fd,
+                          const std::string& host,
+                          const std::string& port,
+                          bool is_numeric_host_address,
+                          bool disable_nagle) {
   const char* node = NULL;
   const char* service = NULL;
 
@@ -240,7 +238,7 @@ int CreateConnectedSocket( int *connect_fd,
   if (!port.empty())
     service = port.c_str();
 
-  struct addrinfo *results = 0;
+  struct addrinfo* results = 0;
   struct addrinfo hints;
   memset(&hints, 0, sizeof(hints));
 
@@ -252,25 +250,24 @@ int CreateConnectedSocket( int *connect_fd,
   hints.ai_socktype = SOCK_STREAM;
 
   int err = 0;
-  if ((err=getaddrinfo(node, service, &hints, &results))) {
+  if ((err = getaddrinfo(node, service, &hints, &results))) {
     // gai_strerror -is- threadsafe, so we get to use it here.
-    LOG(ERROR) << "getaddrinfo for (" << node << ":" << service << "): "
-               << gai_strerror(err);
+    LOG(ERROR) << "getaddrinfo for (" << node << ":" << service
+               << "): " << gai_strerror(err);
     return -1;
   }
   // this will delete the addrinfo memory when we return from this function.
   AddrinfoGuard addrinfo_guard(results);
 
-  int sock = socket(results->ai_family,
-                    results->ai_socktype,
-                    results->ai_protocol);
+  int sock =
+      socket(results->ai_family, results->ai_socktype, results->ai_protocol);
   if (sock == -1) {
     LOG(ERROR) << "Unable to create socket for (" << node << ":" << service
-               << "): " << strerror( errno );
+               << "): " << strerror(errno);
     return -1;
   }
 
-  FlipSetNonBlocking( sock );
+  FlipSetNonBlocking(sock);
 
   if (disable_nagle) {
     if (!SetDisableNagle(sock)) {
@@ -279,11 +276,11 @@ int CreateConnectedSocket( int *connect_fd,
   }
 
   int ret_val = 0;
-  if ( connect( sock, results->ai_addr, results->ai_addrlen ) ) {
-    if ( errno != EINPROGRESS ) {
+  if (connect(sock, results->ai_addr, results->ai_addrlen)) {
+    if (errno != EINPROGRESS) {
       LOG(ERROR) << "Connect was unsuccessful for (" << node << ":" << service
                  << "): " << strerror(errno);
-      close( sock );
+      close(sock);
       return -1;
     }
   } else {
diff --git a/net/tools/flip_server/create_listener.h b/net/tools/flip_server/create_listener.h
index a3f5a87..8ab619c 100644
--- a/net/tools/flip_server/create_listener.h
+++ b/net/tools/flip_server/create_listener.h
@@ -44,9 +44,9 @@ int CreateListeningSocket(const std::string& host,
                           bool reuseport,
                           bool wait_for_iface,
                           bool disable_nagle,
-                          int * listen_fd);
+                          int* listen_fd);
 
-int CreateConnectedSocket(int *connect_fd,
+int CreateConnectedSocket(int* connect_fd,
                           const std::string& host,
                           const std::string& port,
                           bool is_numeric_host_address,
diff --git a/net/tools/flip_server/flip_config.cc b/net/tools/flip_server/flip_config.cc
index c32937c..8be1fe0 100644
--- a/net/tools/flip_server/flip_config.cc
+++ b/net/tools/flip_server/flip_config.cc
@@ -23,7 +23,7 @@ FlipAcceptor::FlipAcceptor(enum FlipHandlerType flip_handler_type,
                            int accepts_per_wake,
                            bool reuseport,
                            bool wait_for_iface,
-                           void *memory_cache)
+                           void* memory_cache)
     : flip_handler_type_(flip_handler_type),
       listen_ip_(listen_ip),
       listen_port_(listen_port),
@@ -58,16 +58,15 @@ FlipAcceptor::FlipAcceptor(enum FlipHandlerType flip_handler_type,
                                     wait_for_iface,
                                     disable_nagle_,
                                     &listen_fd_);
-    if ( ret == 0 ) {
+    if (ret == 0) {
       break;
-    } else if ( ret == -3 && wait_for_iface ) {
+    } else if (ret == -3 && wait_for_iface) {
       // Binding error EADDRNOTAVAIL was encounted. We need
       // to wait for the interfaces to raised. try again.
       usleep(200000);
     } else {
       LOG(ERROR) << "Unable to create listening socket for: ret = " << ret
-                 << ": " << listen_ip_.c_str() << ":"
-                 << listen_port_.c_str();
+                 << ": " << listen_ip_.c_str() << ":" << listen_port_.c_str();
       return;
     }
   }
@@ -82,15 +81,14 @@ FlipAcceptor::FlipAcceptor(enum FlipHandlerType flip_handler_type,
     VLOG(1) << "\tType         : HTTP Server";
   VLOG(1) << "\tIP           : " << listen_ip_;
   VLOG(1) << "\tPort         : " << listen_port_;
-  VLOG(1) << "\tHTTP Server  : " << http_server_ip_ << ":"
-          << http_server_port_;
+  VLOG(1) << "\tHTTP Server  : " << http_server_ip_ << ":" << http_server_port_;
   VLOG(1) << "\tHTTPS Server : " << https_server_ip_ << ":"
           << https_server_port_;
-  VLOG(1) << "\tSSL          : "
-          << (ssl_cert_filename.size()?"true":"false");
+  VLOG(1) << "\tSSL          : " << (ssl_cert_filename.size() ? "true"
+                                                              : "false");
   VLOG(1) << "\tCertificate  : " << ssl_cert_filename;
   VLOG(1) << "\tKey          : " << ssl_key_filename;
-  VLOG(1) << "\tSpdy Only    : " << (spdy_only?"true":"false");
+  VLOG(1) << "\tSpdy Only    : " << (spdy_only ? "true" : "false");
 }
 
 FlipAcceptor::~FlipAcceptor() {}
@@ -98,8 +96,7 @@ FlipAcceptor::~FlipAcceptor() {}
 FlipConfig::FlipConfig()
     : server_think_time_in_s_(0),
       log_destination_(logging::LOG_TO_SYSTEM_DEBUG_LOG),
-      wait_for_iface_(false) {
-}
+      wait_for_iface_(false) {}
 
 FlipConfig::~FlipConfig() {}
 
@@ -118,7 +115,7 @@ void FlipConfig::AddAcceptor(enum FlipHandlerType flip_handler_type,
                              int accepts_per_wake,
                              bool reuseport,
                              bool wait_for_iface,
-                             void *memory_cache) {
+                             void* memory_cache) {
   // TODO(mbelshe): create a struct FlipConfigArgs{} for the arguments.
   acceptors_.push_back(new FlipAcceptor(flip_handler_type,
                                         listen_ip,
@@ -138,4 +135,4 @@ void FlipConfig::AddAcceptor(enum FlipHandlerType flip_handler_type,
                                         memory_cache));
 }
 
-}  // namespace
+}  // namespace net
diff --git a/net/tools/flip_server/flip_config.h b/net/tools/flip_server/flip_config.h
index 454c4bf..90a4199 100644
--- a/net/tools/flip_server/flip_config.h
+++ b/net/tools/flip_server/flip_config.h
@@ -2,10 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef NET_TOOLS_FLIP_PROXY_CONFIG_H
-#define NET_TOOLS_FLIP_PROXY_CONFIG_H
+#ifndef NET_TOOLS_FLIP_SERVER_FLIP_CONFIG_H_
+#define NET_TOOLS_FLIP_SERVER_FLIP_CONFIG_H_
 
-#include <arpa/inet.h>  // in_addr_t
+#include <arpa/inet.h>
 
 #include <string>
 #include <vector>
@@ -16,9 +16,9 @@
 namespace net {
 
 enum FlipHandlerType {
-    FLIP_HANDLER_PROXY,
-    FLIP_HANDLER_SPDY_SERVER,
-    FLIP_HANDLER_HTTP_SERVER
+  FLIP_HANDLER_PROXY,
+  FLIP_HANDLER_SPDY_SERVER,
+  FLIP_HANDLER_HTTP_SERVER
 };
 
 class FlipAcceptor {
@@ -38,7 +38,7 @@ class FlipAcceptor {
                int accepts_per_wake,
                bool reuseport,
                bool wait_for_iface,
-               void *memory_cache);
+               void* memory_cache);
   ~FlipAcceptor();
 
   enum FlipHandlerType flip_handler_type_;
@@ -81,7 +81,7 @@ class FlipConfig {
                    int accepts_per_wake,
                    bool reuseport,
                    bool wait_for_iface,
-                   void *memory_cache);
+                   void* memory_cache);
 
   std::vector<FlipAcceptor*> acceptors_;
   double server_think_time_in_s_;
@@ -93,7 +93,6 @@ class FlipConfig {
   int idle_socket_timeout_s_;
 };
 
-}  // namespace
-
-#endif  // NET_TOOLS_FLIP_PROXY_CONFIG_H
+}  // namespace net
 
+#endif  // NET_TOOLS_FLIP_SERVER_FLIP_CONFIG_H_
diff --git a/net/tools/flip_server/flip_in_mem_edsm_server.cc b/net/tools/flip_server/flip_in_mem_edsm_server.cc
index 79f3e5b..ef1cefd 100644
--- a/net/tools/flip_server/flip_in_mem_edsm_server.cc
+++ b/net/tools/flip_server/flip_in_mem_edsm_server.cc
@@ -4,10 +4,10 @@
 
 #include <errno.h>
 #include <signal.h>
+#include <stdio.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 
-#include <iostream>
 #include <string>
 #include <vector>
 
@@ -25,9 +25,6 @@
 #include "net/tools/flip_server/spdy_interface.h"
 #include "net/tools/flip_server/streamer_interface.h"
 
-using std::cout;
-using std::cerr;
-
 // If true, then disables the nagle algorithm);
 bool FLAGS_disable_nagle = true;
 
@@ -55,20 +52,18 @@ double FLAGS_server_think_time_in_s = 0;
 
 net::FlipConfig g_proxy_config;
 
-////////////////////////////////////////////////////////////////////////////////
-
-std::vector<std::string> &split(const std::string &s,
+std::vector<std::string>& split(const std::string& s,
                                 char delim,
-                                std::vector<std::string> &elems) {
+                                std::vector<std::string>& elems) {
   std::stringstream ss(s);
   std::string item;
-  while(std::getline(ss, item, delim)) {
+  while (std::getline(ss, item, delim)) {
     elems.push_back(item);
   }
   return elems;
 }
 
-std::vector<std::string> split(const std::string &s, char delim) {
+std::vector<std::string> split(const std::string& s, char delim) {
   std::vector<std::string> elems;
   return split(s, delim, elems);
 }
@@ -85,8 +80,7 @@ bool GotQuitFromStdin() {
     VLOG(1) << "scanning string: \"" << maybequit << "\"";
   }
   return (maybequit.size() > 1 &&
-          (maybequit.c_str()[0] == 'q' ||
-           maybequit.c_str()[0] == 'Q'));
+          (maybequit.c_str()[0] == 'q' || maybequit.c_str()[0] == 'Q'));
 }
 
 const char* BoolToStr(bool b) {
@@ -95,13 +89,10 @@ const char* BoolToStr(bool b) {
   return "false";
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 static bool wantExit = false;
 static bool wantLogClose = false;
-void SignalHandler(int signum)
-{
-  switch(signum) {
+void SignalHandler(int signum) {
+  switch (signum) {
     case SIGTERM:
     case SIGINT:
       wantExit = true;
@@ -112,36 +103,39 @@ void SignalHandler(int signum)
   }
 }
 
-static int OpenPidFile(const char *pidfile)
-{
+static int OpenPidFile(const char* pidfile) {
   int fd;
   struct stat pid_stat;
   int ret;
 
   fd = open(pidfile, O_RDWR | O_CREAT, 0600);
   if (fd == -1) {
-      cerr << "Could not open pid file '" << pidfile << "' for reading.\n";
-      exit(1);
+    fprintf(stderr, "Could not open pid file '%s' for reading.\n", pidfile);
+    exit(1);
   }
 
   ret = flock(fd, LOCK_EX | LOCK_NB);
   if (ret == -1) {
     if (errno == EWOULDBLOCK) {
-      cerr << "Flip server is already running.\n";
+      fprintf(stderr, "Flip server is already running.\n");
     } else {
-      cerr << "Error getting lock on pid file: " << strerror(errno) << "\n";
+      perror("Error getting lock on pid file");
     }
     exit(1);
   }
 
   if (fstat(fd, &pid_stat) == -1) {
-    cerr << "Could not stat pid file '" << pidfile << "': " << strerror(errno)
-         << "\n";
+    fprintf(
+        stderr, "Could not stat pid file '%s': %s\n", pidfile, strerror(errno));
+    exit(1);
   }
   if (pid_stat.st_size != 0) {
     if (ftruncate(fd, pid_stat.st_size) == -1) {
-      cerr << "Could not truncate pid file '" << pidfile << "': "
-           << strerror(errno) << "\n";
+      fprintf(stderr,
+              "Could not truncate pid file '%s': %s\n",
+              pidfile,
+              strerror(errno));
+      exit(1);
     }
   }
 
@@ -149,7 +143,7 @@ static int OpenPidFile(const char *pidfile)
   snprintf(pid_str, sizeof(pid_str), "%d", getpid());
   int bytes = static_cast<int>(strlen(pid_str));
   if (write(fd, pid_str, strlen(pid_str)) != bytes) {
-    cerr << "Could not write pid file: " << strerror(errno) << "\n";
+    perror("Could not write pid file");
     close(fd);
     exit(1);
   }
@@ -157,8 +151,7 @@ static int OpenPidFile(const char *pidfile)
   return fd;
 }
 
-int main (int argc, char**argv)
-{
+int main(int argc, char** argv) {
   unsigned int i = 0;
   bool wait_for_iface = false;
   int pidfile_fd;
@@ -172,40 +165,41 @@ int main (int argc, char**argv)
   CommandLine cl(argc, argv);
 
   if (cl.HasSwitch("help") || argc < 2) {
-    cout << argv[0] << " <options>\n";
-    cout << "  Proxy options:\n";
-    cout << "\t--proxy<1..n>=\"<listen ip>,<listen port>,"
-         << "<ssl cert filename>,\n"
-         << "\t               <ssl key filename>,<http server ip>,"
-         << "<http server port>,\n"
-         << "\t               [https server ip],[https server port],"
-         << "<spdy only 0|1>\"\n";
-    cout << "\t  * The https server ip and port may be left empty if they are"
-         << " the same as\n"
-         << "\t    the http server fields.\n";
-    cout << "\t  * spdy only prevents non-spdy https connections from being"
-         << " passed\n"
-         << "\t    through the proxy listen ip:port.\n";
-    cout << "\t--forward-ip-header=<header name>\n";
-    cout << "\n  Server options:\n";
-    cout << "\t--spdy-server=\"<listen ip>,<listen port>,[ssl cert filename],"
-         << "\n\t               [ssl key filename]\"\n";
-    cout << "\t--http-server=\"<listen ip>,<listen port>,[ssl cert filename],"
-         << "\n\t               [ssl key filename]\"\n";
-    cout << "\t  * Leaving the ssl cert and key fields empty will disable ssl"
-         << " for the\n"
-         << "\t    http and spdy flip servers\n";
-    cout << "\n  Global options:\n";
-    cout << "\t--logdest=<file|system|both>\n";
-    cout << "\t--logfile=<logfile>\n";
-    cout << "\t--wait-for-iface\n";
-    cout << "\t  * The flip server will block until the listen ip has been"
-         << " raised.\n";
-    cout << "\t--ssl-session-expiry=<seconds> (default is 300)\n";
-    cout << "\t--ssl-disable-compression\n";
-    cout << "\t--idle-timeout=<seconds> (default is 300)\n";
-    cout << "\t--pidfile=<filepath> (default /var/run/flip-server.pid)\n";
-    cout << "\t--help\n";
+    printf("%s <options>\n", argv[0]);
+    printf("  Proxy options:\n");
+    printf(
+        "\t--proxy<1..n>=\"<listen ip>,<listen port>,"
+        "<ssl cert filename>,\n"
+        "\t               <ssl key filename>,<http server ip>,"
+        "<http server port>,\n"
+        "\t               [https server ip],[https server port],"
+        "<spdy only 0|1>\"\n"
+        "\t  * The https server ip and port may be left empty if they are"
+        " the same as\n"
+        "\t    the http server fields.\n"
+        "\t  * spdy only prevents non-spdy https connections from being"
+        " passed\n"
+        "\t    through the proxy listen ip:port.\n"
+        "\t--forward-ip-header=<header name>\n"
+        "\n  Server options:\n"
+        "\t--spdy-server=\"<listen ip>,<listen port>,[ssl cert filename],"
+        "\n\t               [ssl key filename]\"\n"
+        "\t--http-server=\"<listen ip>,<listen port>,[ssl cert filename],"
+        "\n\t               [ssl key filename]\"\n"
+        "\t  * Leaving the ssl cert and key fields empty will disable ssl"
+        " for the\n"
+        "\t    http and spdy flip servers\n"
+        "\n  Global options:\n"
+        "\t--logdest=<file|system|both>\n"
+        "\t--logfile=<logfile>\n"
+        "\t--wait-for-iface\n"
+        "\t  * The flip server will block until the listen ip has been"
+        " raised.\n"
+        "\t--ssl-session-expiry=<seconds> (default is 300)\n"
+        "\t--ssl-disable-compression\n"
+        "\t--idle-timeout=<seconds> (default is 300)\n"
+        "\t--pidfile=<filepath> (default /var/run/flip-server.pid)\n"
+        "\t--help\n");
     exit(0);
   }
 
@@ -263,7 +257,7 @@ int main (int argc, char**argv)
 
   if (cl.HasSwitch("idle-timeout")) {
     g_proxy_config.idle_socket_timeout_s_ =
-      atoi(cl.GetSwitchValueASCII("idle-timeout").c_str());
+        atoi(cl.GetSwitchValueASCII("idle-timeout").c_str());
   }
 
   if (cl.HasSwitch("force_spdy"))
@@ -279,17 +273,19 @@ int main (int argc, char**argv)
   LOG(INFO) << "Logging destination     : " << g_proxy_config.log_destination_;
   LOG(INFO) << "Log file                : " << g_proxy_config.log_filename_;
   LOG(INFO) << "Forward IP Header       : "
-            << (net::SpdySM::forward_ip_header().length() ?
-               net::SpdySM::forward_ip_header() : "<disabled>");
-  LOG(INFO) << "Wait for interfaces     : " << (wait_for_iface?"true":"false");
+            << (net::SpdySM::forward_ip_header().length()
+                    ? net::SpdySM::forward_ip_header()
+                    : "<disabled>");
+  LOG(INFO) << "Wait for interfaces     : " << (wait_for_iface ? "true"
+                                                               : "false");
   LOG(INFO) << "Accept backlog size     : " << FLAGS_accept_backlog_size;
   LOG(INFO) << "Accepts per wake        : " << FLAGS_accepts_per_wake;
-  LOG(INFO) << "Disable nagle           : "
-            << (FLAGS_disable_nagle?"true":"false");
-  LOG(INFO) << "Reuseport               : "
-            << (FLAGS_reuseport?"true":"false");
-  LOG(INFO) << "Force SPDY              : "
-            << (FLAGS_force_spdy?"true":"false");
+  LOG(INFO) << "Disable nagle           : " << (FLAGS_disable_nagle ? "true"
+                                                                    : "false");
+  LOG(INFO) << "Reuseport               : " << (FLAGS_reuseport ? "true"
+                                                                : "false");
+  LOG(INFO) << "Force SPDY              : " << (FLAGS_force_spdy ? "true"
+                                                                 : "false");
   LOG(INFO) << "SSL session expiry      : "
             << g_proxy_config.ssl_session_expiry_;
   LOG(INFO) << "SSL disable compression : "
@@ -312,10 +308,14 @@ int main (int argc, char**argv)
     // If wait_for_iface is enabled, then this call will block
     // indefinitely until the interface is raised.
     g_proxy_config.AddAcceptor(net::FLIP_HANDLER_PROXY,
-                               valueArgs[0], valueArgs[1],
-                               valueArgs[2], valueArgs[3],
-                               valueArgs[4], valueArgs[5],
-                               valueArgs[6], valueArgs[7],
+                               valueArgs[0],
+                               valueArgs[1],
+                               valueArgs[2],
+                               valueArgs[3],
+                               valueArgs[4],
+                               valueArgs[5],
+                               valueArgs[6],
+                               valueArgs[7],
                                spdy_only,
                                FLAGS_accept_backlog_size,
                                FLAGS_disable_nagle,
@@ -380,11 +380,10 @@ int main (int argc, char**argv)
   std::vector<net::SMAcceptorThread*> sm_worker_threads_;
 
   for (i = 0; i < g_proxy_config.acceptors_.size(); i++) {
-    net::FlipAcceptor *acceptor = g_proxy_config.acceptors_[i];
+    net::FlipAcceptor* acceptor = g_proxy_config.acceptors_[i];
 
-    sm_worker_threads_.push_back(
-        new net::SMAcceptorThread(acceptor,
-                                  (net::MemoryCache *)acceptor->memory_cache_));
+    sm_worker_threads_.push_back(new net::SMAcceptorThread(
+        acceptor, (net::MemoryCache*)acceptor->memory_cache_));
     // Note that spdy_memory_cache is not threadsafe, it is merely
     // thread compatible. Thus, if ever we are to spawn multiple threads,
     // we either must make the MemoryCache threadsafe, or use
@@ -400,7 +399,7 @@ int main (int argc, char**argv)
   while (!wantExit) {
     // Close logfile when HUP signal is received. Logging system will
     // automatically reopen on next log message.
-    if ( wantLogClose ) {
+    if (wantLogClose) {
       wantLogClose = false;
       VLOG(1) << "HUP received, reopening log file.";
       logging::CloseLogFile();
@@ -414,7 +413,7 @@ int main (int argc, char**argv)
       }
       break;
     }
-    usleep(1000*10);  // 10 ms
+    usleep(1000 * 10);  // 10 ms
   }
 
   unlink(PIDFILE);
diff --git a/net/tools/flip_server/flip_test_utils.cc b/net/tools/flip_server/flip_test_utils.cc
index d9846cf..c99d7d6 100644
--- a/net/tools/flip_server/flip_test_utils.cc
+++ b/net/tools/flip_server/flip_test_utils.cc
@@ -6,10 +6,8 @@
 
 namespace net {
 
-MockSMInterface::MockSMInterface() {
-}
+MockSMInterface::MockSMInterface() {}
 
-MockSMInterface::~MockSMInterface() {
-}
+MockSMInterface::~MockSMInterface() {}
 
 }  // namespace net
diff --git a/net/tools/flip_server/flip_test_utils.h b/net/tools/flip_server/flip_test_utils.h
index 8a10b95..0a61a60 100644
--- a/net/tools/flip_server/flip_test_utils.h
+++ b/net/tools/flip_server/flip_test_utils.h
@@ -19,14 +19,15 @@ class MockSMInterface : public SMInterface {
   virtual ~MockSMInterface();
 
   MOCK_METHOD2(InitSMInterface, void(SMInterface*, int32));
-  MOCK_METHOD8(InitSMConnection, void(SMConnectionPoolInterface*,
-                                      SMInterface*,
-                                      EpollServer*,
-                                      int,
-                                      std::string,
-                                      std::string,
-                                      std::string,
-                                      bool));
+  MOCK_METHOD8(InitSMConnection,
+               void(SMConnectionPoolInterface*,
+                    SMInterface*,
+                    EpollServer*,
+                    int,
+                    std::string,
+                    std::string,
+                    std::string,
+                    bool));
   MOCK_METHOD2(ProcessReadInput, size_t(const char*, size_t));
   MOCK_METHOD2(ProcessWriteInput, size_t(const char*, size_t));
   MOCK_METHOD1(SetStreamID, void(uint32 stream_id));
diff --git a/net/tools/flip_server/http_interface.cc b/net/tools/flip_server/http_interface.cc
index 78c42cc..b939c5f 100644
--- a/net/tools/flip_server/http_interface.cc
+++ b/net/tools/flip_server/http_interface.cc
@@ -46,18 +46,19 @@ void HttpSM::ProcessBodyData(const char* input, size_t size) {
 void HttpSM::ProcessHeaders(const BalsaHeaders& headers) {
   if (acceptor_->flip_handler_type_ == FLIP_HANDLER_HTTP_SERVER) {
     std::string host =
-      UrlUtilities::GetUrlHost(headers.GetHeader("Host").as_string());
+        UrlUtilities::GetUrlHost(headers.GetHeader("Host").as_string());
     std::string method = headers.request_method().as_string();
-    VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Received Request: "
-            << headers.request_uri().as_string() << " " << method;
-    std::string filename = EncodeURL(headers.request_uri().as_string(),
-                                host, method);
+    VLOG(1) << ACCEPTOR_CLIENT_IDENT
+            << "Received Request: " << headers.request_uri().as_string() << " "
+            << method;
+    std::string filename =
+        EncodeURL(headers.request_uri().as_string(), host, method);
     NewStream(stream_id_, 0, filename);
     stream_id_ += 2;
   } else {
     VLOG(1) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Received Response from "
-            << connection_->server_ip_ << ":"
-            << connection_->server_port_ << " ";
+            << connection_->server_ip_ << ":" << connection_->server_port_
+            << " ";
     sm_spdy_interface_->SendSynReply(stream_id_, headers);
   }
 }
@@ -72,17 +73,11 @@ void HttpSM::MessageDone() {
   }
 }
 
-void HttpSM::HandleHeaderError(BalsaFrame* framer) {
-  HandleError();
-}
+void HttpSM::HandleHeaderError(BalsaFrame* framer) { HandleError(); }
 
-void HttpSM::HandleChunkingError(BalsaFrame* framer) {
-  HandleError();
-}
+void HttpSM::HandleChunkingError(BalsaFrame* framer) { HandleError(); }
 
-void HttpSM::HandleBodyError(BalsaFrame* framer) {
-  HandleError();
-}
+void HttpSM::HandleBodyError(BalsaFrame* framer) { HandleError(); }
 
 void HttpSM::HandleError() {
   VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Error detected";
@@ -92,8 +87,7 @@ void HttpSM::AddToOutputOrder(const MemCacheIter& mci) {
   output_ordering_.AddToOutputOrder(mci);
 }
 
-void HttpSM::InitSMInterface(SMInterface* sm_spdy_interface,
-                             int32 server_idx) {
+void HttpSM::InitSMInterface(SMInterface* sm_spdy_interface, int32 server_idx) {
   sm_spdy_interface_ = sm_spdy_interface;
   server_idx_ = server_idx;
 }
@@ -141,29 +135,24 @@ bool HttpSM::MessageFullyRead() const {
   return http_framer_->MessageFullyRead();
 }
 
-void HttpSM::SetStreamID(uint32 stream_id) {
-  stream_id_ = stream_id;
-}
+void HttpSM::SetStreamID(uint32 stream_id) { stream_id_ = stream_id; }
 
-bool HttpSM::Error() const {
-  return http_framer_->Error();
-}
+bool HttpSM::Error() const { return http_framer_->Error(); }
 
 const char* HttpSM::ErrorAsString() const {
   return BalsaFrameEnums::ErrorCodeToString(http_framer_->ErrorCode());
 }
 
 void HttpSM::Reset() {
-  VLOG(1) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Reset: stream "
-          << stream_id_;
+  VLOG(1) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Reset: stream " << stream_id_;
   http_framer_->Reset();
 }
 
 void HttpSM::ResetForNewConnection() {
   if (acceptor_->flip_handler_type_ == FLIP_HANDLER_PROXY) {
     VLOG(1) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Server connection closing "
-      << "to: " << connection_->server_ip_ << ":"
-      << connection_->server_port_ << " ";
+            << "to: " << connection_->server_ip_ << ":"
+            << connection_->server_port_ << " ";
   }
   // Message has not been fully read, either it is incomplete or the
   // server is closing the connection to signal message end.
@@ -186,11 +175,10 @@ void HttpSM::Cleanup() {
   }
 }
 
-int HttpSM::PostAcceptHook() {
-  return 1;
-}
+int HttpSM::PostAcceptHook() { return 1; }
 
-void HttpSM::NewStream(uint32 stream_id, uint32 priority,
+void HttpSM::NewStream(uint32 stream_id,
+                       uint32 priority,
                        const std::string& filename) {
   MemCacheIter mci;
   mci.stream_id = stream_id;
@@ -223,8 +211,11 @@ size_t HttpSM::SendSynReply(uint32 stream_id, const BalsaHeaders& headers) {
   return SendSynReplyImpl(stream_id, headers);
 }
 
-void HttpSM::SendDataFrame(uint32 stream_id, const char* data, int64 len,
-                   uint32 flags, bool compress) {
+void HttpSM::SendDataFrame(uint32 stream_id,
+                           const char* data,
+                           int64 len,
+                           uint32 flags,
+                           bool compress) {
   SendDataFrameImpl(stream_id, data, len, flags, compress);
 }
 
@@ -283,8 +274,11 @@ size_t HttpSM::SendSynStreamImpl(uint32 stream_id,
   return df_size;
 }
 
-void HttpSM::SendDataFrameImpl(uint32 stream_id, const char* data, int64 len,
-                       uint32 flags, bool compress) {
+void HttpSM::SendDataFrameImpl(uint32 stream_id,
+                               const char* data,
+                               int64 len,
+                               uint32 flags,
+                               bool compress) {
   char chunk_buf[128];
   snprintf(chunk_buf, sizeof(chunk_buf), "%x\r\n", (unsigned int)len);
   std::string chunk_description(chunk_buf);
@@ -313,8 +307,8 @@ void HttpSM::GetOutput() {
     return;
   }
   if (!mci->transformed_header) {
-    mci->bytes_sent = SendSynReply(mci->stream_id,
-                                   *(mci->file_data->headers()));
+    mci->bytes_sent =
+        SendSynReply(mci->stream_id, *(mci->file_data->headers()));
     mci->transformed_header = true;
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: GetOutput transformed "
             << "header stream_id: [" << mci->stream_id << "]";
@@ -334,7 +328,9 @@ void HttpSM::GetOutput() {
 
   SendDataFrame(mci->stream_id,
                 mci->file_data->body().data() + mci->body_bytes_consumed,
-                num_to_write, 0, true);
+                num_to_write,
+                0,
+                true);
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: GetOutput SendDataFrame["
           << mci->stream_id << "]: " << num_to_write;
   mci->body_bytes_consumed += num_to_write;
diff --git a/net/tools/flip_server/http_interface.h b/net/tools/flip_server/http_interface.h
index 867e342..30b7979 100644
--- a/net/tools/flip_server/http_interface.h
+++ b/net/tools/flip_server/http_interface.h
@@ -22,8 +22,7 @@ class EpollServer;
 class FlipAcceptor;
 class MemoryCache;
 
-class HttpSM : public BalsaVisitorInterface,
-               public SMInterface {
+class HttpSM : public BalsaVisitorInterface, public SMInterface {
  public:
   HttpSM(SMConnection* connection,
          SMInterface* sm_spdy_interface,
@@ -33,10 +32,10 @@ class HttpSM : public BalsaVisitorInterface,
 
  private:
   // BalsaVisitorInterface:
-  virtual void ProcessBodyInput(const char *input, size_t size) OVERRIDE {}
-  virtual void ProcessBodyData(const char *input, size_t size) OVERRIDE;
-  virtual void ProcessHeaderInput(const char *input, size_t size) OVERRIDE {}
-  virtual void ProcessTrailerInput(const char *input, size_t size) OVERRIDE {}
+  virtual void ProcessBodyInput(const char* input, size_t size) OVERRIDE {}
+  virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE;
+  virtual void ProcessHeaderInput(const char* input, size_t size) OVERRIDE {}
+  virtual void ProcessTrailerInput(const char* input, size_t size) OVERRIDE {}
   virtual void ProcessHeaders(const BalsaHeaders& headers) OVERRIDE;
   virtual void ProcessRequestFirstLine(const char* line_input,
                                        size_t line_length,
@@ -46,17 +45,17 @@ class HttpSM : public BalsaVisitorInterface,
                                        size_t request_uri_length,
                                        const char* version_input,
                                        size_t version_length) OVERRIDE {}
-  virtual void ProcessResponseFirstLine(const char *line_input,
+  virtual void ProcessResponseFirstLine(const char* line_input,
                                         size_t line_length,
-                                        const char *version_input,
+                                        const char* version_input,
                                         size_t version_length,
-                                        const char *status_input,
+                                        const char* status_input,
                                         size_t status_length,
-                                        const char *reason_input,
+                                        const char* reason_input,
                                         size_t reason_length) OVERRIDE {}
   virtual void ProcessChunkLength(size_t chunk_length) OVERRIDE {}
-  virtual void ProcessChunkExtensions(const char *input,
-                                      size_t size) OVERRIDE {}
+  virtual void ProcessChunkExtensions(const char* input, size_t size) OVERRIDE {
+  }
   virtual void HeaderDone() OVERRIDE {}
   virtual void MessageDone() OVERRIDE;
   virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE;
@@ -95,7 +94,8 @@ class HttpSM : public BalsaVisitorInterface,
   virtual void Cleanup() OVERRIDE;
   virtual int PostAcceptHook() OVERRIDE;
 
-  virtual void NewStream(uint32 stream_id, uint32 priority,
+  virtual void NewStream(uint32 stream_id,
+                         uint32 priority,
                          const std::string& filename) OVERRIDE;
   virtual void SendEOF(uint32 stream_id) OVERRIDE;
   virtual void SendErrorNotFound(uint32 stream_id) OVERRIDE;
@@ -103,8 +103,11 @@ class HttpSM : public BalsaVisitorInterface,
                                const BalsaHeaders& headers) OVERRIDE;
   virtual size_t SendSynReply(uint32 stream_id,
                               const BalsaHeaders& headers) OVERRIDE;
-  virtual void SendDataFrame(uint32 stream_id, const char* data, int64 len,
-                             uint32 flags, bool compress) OVERRIDE;
+  virtual void SendDataFrame(uint32 stream_id,
+                             const char* data,
+                             int64 len,
+                             uint32 flags,
+                             bool compress) OVERRIDE;
 
  private:
   void SendEOFImpl(uint32 stream_id);
@@ -112,8 +115,11 @@ class HttpSM : public BalsaVisitorInterface,
   void SendOKResponseImpl(uint32 stream_id, const std::string& output);
   size_t SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers);
   size_t SendSynStreamImpl(uint32 stream_id, const BalsaHeaders& headers);
-  void SendDataFrameImpl(uint32 stream_id, const char* data, int64 len,
-                         uint32 flags, bool compress);
+  void SendDataFrameImpl(uint32 stream_id,
+                         const char* data,
+                         int64 len,
+                         uint32 flags,
+                         bool compress);
   void EnqueueDataFrame(DataFrame* df);
   virtual void GetOutput() OVERRIDE;
 
diff --git a/net/tools/flip_server/http_interface_test.cc b/net/tools/flip_server/http_interface_test.cc
index c6e3c64..969607b 100644
--- a/net/tools/flip_server/http_interface_test.cc
+++ b/net/tools/flip_server/http_interface_test.cc
@@ -40,14 +40,15 @@ class MockSMConnection : public SMConnection {
                      log_prefix) {}
 
   MOCK_METHOD0(Cleanup, void());
-  MOCK_METHOD8(InitSMConnection, void(SMConnectionPoolInterface*,
-                                      SMInterface*,
-                                      EpollServer*,
-                                      int,
-                                      std::string,
-                                      std::string,
-                                      std::string,
-                                      bool));
+  MOCK_METHOD8(InitSMConnection,
+               void(SMConnectionPoolInterface*,
+                    SMInterface*,
+                    EpollServer*,
+                    int,
+                    std::string,
+                    std::string,
+                    std::string,
+                    bool));
 };
 
 class FlipHttpSMTest : public ::testing::Test {
@@ -167,10 +168,11 @@ TEST_F(FlipHttpSMTest, InitSMConnection) {
 }
 
 TEST_F(FlipHttpSMTest, ProcessReadInput) {
-  std::string data = "HTTP/1.1 200 OK\r\n"
+  std::string data =
+      "HTTP/1.1 200 OK\r\n"
       "Content-Length: 14\r\n\r\n"
       "hello, world\r\n";
-  testing::MockFunction<void(int)> checkpoint;
+  testing::MockFunction<void(int)> checkpoint;  // NOLINT
   {
     InSequence s;
     EXPECT_CALL(*mock_another_interface_, SendSynReply(_, _));
@@ -205,7 +207,7 @@ TEST_F(FlipHttpSMTest, ProcessWriteInput) {
 
 TEST_F(FlipHttpSMTest, Reset) {
   std::string data = "HTTP/1.1 200 OK\r\n\r\n";
-  testing::MockFunction<void(int)> checkpoint;
+  testing::MockFunction<void(int)> checkpoint;  // NOLINT
   {
     InSequence s;
     EXPECT_CALL(*mock_another_interface_, SendSynReply(_, _));
@@ -228,7 +230,7 @@ TEST_F(FlipHttpSMTest, Reset) {
 
 TEST_F(FlipHttpSMTest, ResetForNewConnection) {
   std::string data = "HTTP/1.1 200 OK\r\n\r\n";
-  testing::MockFunction<void(int)> checkpoint;
+  testing::MockFunction<void(int)> checkpoint;  // NOLINT
   {
     InSequence s;
     EXPECT_CALL(*mock_another_interface_, SendSynReply(_, _));
@@ -264,7 +266,8 @@ TEST_F(FlipHttpSMTest, NewStream) {
 }
 
 TEST_F(FlipHttpSMTest, NewStreamError) {
-  std::string syn_reply = "HTTP/1.1 404 Not Found\r\n"
+  std::string syn_reply =
+      "HTTP/1.1 404 Not Found\r\n"
       "transfer-encoding: chunked\r\n\r\n";
   std::string body = "e\r\npage not found\r\n";
   uint32 stream_id = 4;
@@ -284,7 +287,8 @@ TEST_F(FlipHttpSMTest, NewStreamError) {
 }
 
 TEST_F(FlipHttpSMTest, SendErrorNotFound) {
-  std::string syn_reply = "HTTP/1.1 404 Not Found\r\n"
+  std::string syn_reply =
+      "HTTP/1.1 404 Not Found\r\n"
       "transfer-encoding: chunked\r\n\r\n";
   std::string body = "e\r\npage not found\r\n";
   uint32 stream_id = 13;
@@ -314,7 +318,8 @@ TEST_F(FlipHttpSMTest, SendErrorNotFound) {
 }
 
 TEST_F(FlipHttpSMTest, SendSynStream) {
-  std::string expected = "GET / HTTP/1.0\r\n"
+  std::string expected =
+      "GET / HTTP/1.0\r\n"
       "key1: value1\r\n\r\n";
   BalsaHeaders headers;
   headers.SetResponseFirstlineFromStringPieces("GET", "/path", "HTTP/1.0");
@@ -326,7 +331,8 @@ TEST_F(FlipHttpSMTest, SendSynStream) {
 }
 
 TEST_F(FlipHttpSMTest, SendSynReply) {
-  std::string expected = "HTTP/1.1 200 OK\r\n"
+  std::string expected =
+      "HTTP/1.1 200 OK\r\n"
       "key1: value1\r\n\r\n";
   BalsaHeaders headers;
   headers.SetResponseFirstlineFromStringPieces("HTTP/1.1", "200", "OK");
@@ -409,9 +415,7 @@ TEST_F(FlipHttpSMHttpTest, ProcessHeaders) {
 
   BalsaHeaders headers;
   headers.AppendHeader("Host", "example.com");
-  headers.SetRequestFirstlineFromStringPieces("GET",
-                                              "/path/file",
-                                              "HTTP/1.0");
+  headers.SetRequestFirstlineFromStringPieces("GET", "/path/file", "HTTP/1.0");
   uint32 stream_id = 133;
   interface_->SetStreamID(stream_id);
   ASSERT_FALSE(HasStream(stream_id));
diff --git a/net/tools/flip_server/http_message_constants.cc b/net/tools/flip_server/http_message_constants.cc
index e60fb1c..a4a8b4d 100644
--- a/net/tools/flip_server/http_message_constants.cc
+++ b/net/tools/flip_server/http_message_constants.cc
@@ -92,55 +92,12 @@ const char* get_http_status_message(int status_message) {
   return "unknown";
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 const int http_status_codes[] = {
-  100,
-  101,
-  200,
-  201,
-  202,
-  203,
-  204,
-  205,
-  206,
-  300,
-  301,
-  302,
-  303,
-  304,
-  305,
-  307,
-  400,
-  401,
-  402,
-  403,
-  404,
-  405,
-  406,
-  407,
-  408,
-  409,
-  410,
-  411,
-  412,
-  413,
-  414,
-  415,
-  416,
-  417,
-  500,
-  501,
-  502,
-  503,
-  504,
-  505
-};
-
-////////////////////////////////////////////////////////////////////////////////
+    100, 101, 200, 201, 202, 203, 204, 205, 206, 300, 301, 302, 303, 304,
+    305, 307, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411,
+    412, 413, 414, 415, 416, 417, 500, 501, 502, 503, 504, 505};
 
-const int http_status_code_count = sizeof(http_status_codes) /
-                                   sizeof(http_status_codes[0]);
+const int http_status_code_count =
+    sizeof(http_status_codes) / sizeof(http_status_codes[0]);
 
 }  // namespace net
-
diff --git a/net/tools/flip_server/loadtime_measurement.h b/net/tools/flip_server/loadtime_measurement.h
index b46217e..ccbb2e5 100644
--- a/net/tools/flip_server/loadtime_measurement.h
+++ b/net/tools/flip_server/loadtime_measurement.h
@@ -44,7 +44,7 @@ class LoadtimeMeasurement {
     }
     if (action.find("get_total_iteration") == 0) {
       char buffer[16];
-      snprintf(buffer, 16, "%d", num_urls_);
+      snprintf(buffer, sizeof(buffer), "%d", num_urls_);
       output.append(buffer, strlen(buffer));
       return;
     }
@@ -60,7 +60,8 @@ class LoadtimeMeasurement {
     }
     if (action.find("test_complete") == 0) {
       for (std::map<std::string, int>::const_iterator it = loadtimes_.begin();
-           it != loadtimes_.end(); ++it) {
+           it != loadtimes_.end();
+           ++it) {
         LOG(INFO) << it->first << " " << it->second;
       }
       loadtimes_.clear();
@@ -99,7 +100,8 @@ class LoadtimeMeasurement {
     close(fd);
   }
 
-  void split_string(std::string& str, char sepa,
+  void split_string(const std::string& str,
+                    char sepa,
                     std::vector<std::string>* sub_strs) {
     size_t b = 0;
     size_t e = str.find_first_of(sepa, b);
@@ -120,4 +122,3 @@ class LoadtimeMeasurement {
 };
 
 #endif  // NET_TOOLS_FLIP_SERVER_LOADTIME_MEASUREMENT_H__
-
diff --git a/net/tools/flip_server/mem_cache.cc b/net/tools/flip_server/mem_cache.cc
index 42d9343..521f56c 100644
--- a/net/tools/flip_server/mem_cache.cc
+++ b/net/tools/flip_server/mem_cache.cc
@@ -29,7 +29,7 @@ const char FLAGS_cache_base_dir[] = ".";
 
 namespace net {
 
-void StoreBodyAndHeadersVisitor::ProcessBodyData(const char *input,
+void StoreBodyAndHeadersVisitor::ProcessBodyData(const char* input,
                                                  size_t size) {
   body.append(input, size);
 }
@@ -53,8 +53,7 @@ void StoreBodyAndHeadersVisitor::HandleBodyError(BalsaFrame* framer) {
 FileData::FileData(const BalsaHeaders* headers,
                    const std::string& filename,
                    const std::string& body)
-    : filename_(filename)
-    , body_(body) {
+    : filename_(filename), body_(body) {
   if (headers) {
     headers_.reset(new BalsaHeaders);
     headers_->CopyFrom(*headers);
@@ -67,9 +66,7 @@ FileData::~FileData() {}
 
 MemoryCache::MemoryCache() : cwd_(FLAGS_cache_base_dir) {}
 
-MemoryCache::~MemoryCache() {
-  ClearFiles();
-}
+MemoryCache::~MemoryCache() { ClearFiles(); }
 
 void MemoryCache::CloneFrom(const MemoryCache& mc) {
   DCHECK_NE(this, &mc);
@@ -97,11 +94,10 @@ void MemoryCache::AddFiles() {
 
       if (current_dir) {
         VLOG(1) << "Succeeded opening";
-        for (struct dirent* dir_data = readdir(current_dir);
-             dir_data != NULL;
+        for (struct dirent* dir_data = readdir(current_dir); dir_data != NULL;
              dir_data = readdir(current_dir)) {
           std::string current_entry_name =
-            current_dir_name + "/" + dir_data->d_name;
+              current_dir_name + "/" + dir_data->d_name;
           if (dir_data->d_type == DT_REG) {
             VLOG(1) << "Found file: " << current_entry_name;
             ReadAndStoreFileContents(current_entry_name.c_str());
@@ -158,7 +154,7 @@ void MemoryCache::ReadAndStoreFileContents(const char* filename) {
                                filename_contents.size() - pos);
     if (framer.Error() || pos == old_pos) {
       LOG(ERROR) << "Unable to make forward progress, or error"
-        " framing file: " << filename;
+                    " framing file: " << filename;
       if (framer.Error()) {
         LOG(INFO) << "********************************************ERROR!";
         return;
@@ -180,9 +176,9 @@ void MemoryCache::ReadAndStoreFileContents(const char* filename) {
   visitor.headers.AppendHeader("transfer-encoding", "chunked");
   visitor.headers.AppendHeader("connection", "keep-alive");
 
-  // Experiment with changing headers for forcing use of cached
-  // versions of content.
-  // TODO(mbelshe) REMOVE ME
+// Experiment with changing headers for forcing use of cached
+// versions of content.
+// TODO(mbelshe) REMOVE ME
 #if 0
   // TODO(mbelshe) append current date.
   visitor.headers.RemoveAllOfHeader("date");
@@ -196,15 +192,14 @@ void MemoryCache::ReadAndStoreFileContents(const char* filename) {
   DCHECK_EQ(std::string(filename).substr(0, cwd_.size()), cwd_);
   DCHECK_EQ(filename[cwd_.size()], '/');
   std::string filename_stripped = std::string(filename).substr(cwd_.size() + 1);
-  LOG(INFO) << "Adding file (" << visitor.body.length() << " bytes): "
-            << filename_stripped;
+  LOG(INFO) << "Adding file (" << visitor.body.length()
+            << " bytes): " << filename_stripped;
   size_t slash_pos = filename_stripped.find('/');
   if (slash_pos == std::string::npos) {
     slash_pos = filename_stripped.size();
   }
-  InsertFile(&visitor.headers,
-             filename_stripped.substr(0, slash_pos),
-             visitor.body);
+  InsertFile(
+      &visitor.headers, filename_stripped.substr(0, slash_pos), visitor.body);
 }
 
 FileData* MemoryCache::GetFileData(const std::string& filename) {
diff --git a/net/tools/flip_server/mem_cache.h b/net/tools/flip_server/mem_cache.h
index b059f02..76ffc95 100644
--- a/net/tools/flip_server/mem_cache.h
+++ b/net/tools/flip_server/mem_cache.h
@@ -16,15 +16,15 @@
 
 namespace net {
 
-class StoreBodyAndHeadersVisitor: public BalsaVisitorInterface {
+class StoreBodyAndHeadersVisitor : public BalsaVisitorInterface {
  public:
   void HandleError() { error_ = true; }
 
   // BalsaVisitorInterface:
-  virtual void ProcessBodyInput(const char *input, size_t size) OVERRIDE {}
-  virtual void ProcessBodyData(const char *input, size_t size) OVERRIDE;
-  virtual void ProcessHeaderInput(const char *input, size_t size) OVERRIDE {}
-  virtual void ProcessTrailerInput(const char *input, size_t size) OVERRIDE {}
+  virtual void ProcessBodyInput(const char* input, size_t size) OVERRIDE {}
+  virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE;
+  virtual void ProcessHeaderInput(const char* input, size_t size) OVERRIDE {}
+  virtual void ProcessTrailerInput(const char* input, size_t size) OVERRIDE {}
   virtual void ProcessHeaders(const BalsaHeaders& headers) OVERRIDE {
     // nothing to do here-- we're assuming that the BalsaFrame has
     // been handed our headers.
@@ -37,17 +37,17 @@ class StoreBodyAndHeadersVisitor: public BalsaVisitorInterface {
                                        size_t request_uri_length,
                                        const char* version_input,
                                        size_t version_length) OVERRIDE {}
-  virtual void ProcessResponseFirstLine(const char *line_input,
+  virtual void ProcessResponseFirstLine(const char* line_input,
                                         size_t line_length,
-                                        const char *version_input,
+                                        const char* version_input,
                                         size_t version_length,
-                                        const char *status_input,
+                                        const char* status_input,
                                         size_t status_length,
-                                        const char *reason_input,
+                                        const char* reason_input,
                                         size_t reason_length) OVERRIDE {}
   virtual void ProcessChunkLength(size_t chunk_length) OVERRIDE {}
-  virtual void ProcessChunkExtensions(const char *input,
-                                      size_t size) OVERRIDE {}
+  virtual void ProcessChunkExtensions(const char* input, size_t size) OVERRIDE {
+  }
   virtual void HeaderDone() OVERRIDE {}
   virtual void MessageDone() OVERRIDE {}
   virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE;
@@ -60,7 +60,6 @@ class StoreBodyAndHeadersVisitor: public BalsaVisitorInterface {
   bool error_;
 };
 
-////////////////////////////////////////////////////////////////////////////////
 class FileData {
  public:
   FileData();
@@ -83,26 +82,24 @@ class FileData {
   DISALLOW_COPY_AND_ASSIGN(FileData);
 };
 
-////////////////////////////////////////////////////////////////////////////////
-
 class MemCacheIter {
  public:
-  MemCacheIter() :
-      file_data(NULL),
-      priority(0),
-      transformed_header(false),
-      body_bytes_consumed(0),
-      stream_id(0),
-      max_segment_size(kInitialDataSendersThreshold),
-      bytes_sent(0) {}
-  explicit MemCacheIter(FileData* fd) :
-      file_data(fd),
-      priority(0),
-      transformed_header(false),
-      body_bytes_consumed(0),
-      stream_id(0),
-      max_segment_size(kInitialDataSendersThreshold),
-      bytes_sent(0) {}
+  MemCacheIter()
+      : file_data(NULL),
+        priority(0),
+        transformed_header(false),
+        body_bytes_consumed(0),
+        stream_id(0),
+        max_segment_size(kInitialDataSendersThreshold),
+        bytes_sent(0) {}
+  explicit MemCacheIter(FileData* fd)
+      : file_data(fd),
+        priority(0),
+        transformed_header(false),
+        body_bytes_consumed(0),
+        stream_id(0),
+        max_segment_size(kInitialDataSendersThreshold),
+        bytes_sent(0) {}
   FileData* file_data;
   int priority;
   bool transformed_header;
@@ -112,8 +109,6 @@ class MemCacheIter {
   size_t bytes_sent;
 };
 
-////////////////////////////////////////////////////////////////////////////////
-
 class MemoryCache {
  public:
   typedef std::map<std::string, FileData*> Files;
diff --git a/net/tools/flip_server/mem_cache_test.cc b/net/tools/flip_server/mem_cache_test.cc
index 59bc485..5e45bb5 100644
--- a/net/tools/flip_server/mem_cache_test.cc
+++ b/net/tools/flip_server/mem_cache_test.cc
@@ -15,8 +15,8 @@ class MemoryCacheWithFakeReadToString : public MemoryCache {
  public:
   virtual ~MemoryCacheWithFakeReadToString() {}
 
-  virtual void ReadToString(const char* filename, std::string* output)
-      OVERRIDE {
+  virtual void ReadToString(const char* filename,
+                            std::string* output) OVERRIDE {
     *output = data_map_[filename];
   }
 
@@ -25,7 +25,7 @@ class MemoryCacheWithFakeReadToString : public MemoryCache {
 
 class FlipMemoryCacheTest : public ::testing::Test {
  public:
-  FlipMemoryCacheTest(): mem_cache_(new MemoryCacheWithFakeReadToString) {}
+  FlipMemoryCacheTest() : mem_cache_(new MemoryCacheWithFakeReadToString) {}
 
  protected:
   scoped_ptr<MemoryCacheWithFakeReadToString> mem_cache_;
@@ -44,7 +44,8 @@ TEST_F(FlipMemoryCacheTest, ReadAndStoreFileContents) {
   FileData* hello;
 
   mem_cache_->data_map_["./foo"] = "bar";
-  mem_cache_->data_map_["./hello"] = "HTTP/1.0 200 OK\r\n"
+  mem_cache_->data_map_["./hello"] =
+      "HTTP/1.0 200 OK\r\n"
       "key1: value1\r\n"
       "key2: value2\r\n\r\n"
       "body: body\r\n";
@@ -63,8 +64,9 @@ TEST_F(FlipMemoryCacheTest, ReadAndStoreFileContents) {
   ASSERT_EQ("HTTP/1.1", hello->headers()->response_version());
   ASSERT_EQ("200", hello->headers()->response_code());
   ASSERT_EQ("OK", hello->headers()->response_reason_phrase());
-  ASSERT_EQ(4, std::distance(hello->headers()->header_lines_begin(),
-                             hello->headers()->header_lines_end()));
+  ASSERT_EQ(4,
+            std::distance(hello->headers()->header_lines_begin(),
+                          hello->headers()->header_lines_end()));
   ASSERT_TRUE(hello->headers()->HasHeader("key1"));
   ASSERT_TRUE(hello->headers()->HasHeader("key2"));
   ASSERT_TRUE(hello->headers()->HasHeader("transfer-encoding"));
@@ -82,7 +84,8 @@ TEST_F(FlipMemoryCacheTest, ReadAndStoreFileContents) {
 TEST_F(FlipMemoryCacheTest, GetFileDataForHtmlFile) {
   FileData* hello_html;
 
-  mem_cache_->data_map_["./hello.http"] = "HTTP/1.0 200 OK\r\n"
+  mem_cache_->data_map_["./hello.http"] =
+      "HTTP/1.0 200 OK\r\n"
       "key1: value1\r\n"
       "key2: value2\r\n\r\n"
       "body: body\r\n";
diff --git a/net/tools/flip_server/output_ordering.cc b/net/tools/flip_server/output_ordering.cc
index 6a42869..4f8870d 100644
--- a/net/tools/flip_server/output_ordering.cc
+++ b/net/tools/flip_server/output_ordering.cc
@@ -9,13 +9,10 @@
 #include "net/tools/flip_server/flip_config.h"
 #include "net/tools/flip_server/sm_connection.h"
 
-
 namespace net {
 
 OutputOrdering::PriorityMapPointer::PriorityMapPointer()
-    : ring(NULL),
-      alarm_enabled(false) {
-}
+    : ring(NULL), alarm_enabled(false) {}
 
 // static
 double OutputOrdering::server_think_time_in_s_ = 0.0;
@@ -27,9 +24,7 @@ OutputOrdering::OutputOrdering(SMConnectionInterface* connection)
     epoll_server_ = connection->epoll_server();
 }
 
-OutputOrdering::~OutputOrdering() {
-  Reset();
-}
+OutputOrdering::~OutputOrdering() { Reset(); }
 
 void OutputOrdering::Reset() {
   while (!stream_ids_.empty()) {
@@ -53,11 +48,7 @@ OutputOrdering::BeginOutputtingAlarm::BeginOutputtingAlarm(
     OutputOrdering* oo,
     OutputOrdering::PriorityMapPointer* pmp,
     const MemCacheIter& mci)
-    : output_ordering_(oo),
-      pmp_(pmp),
-      mci_(mci),
-      epoll_server_(NULL) {
-}
+    : output_ordering_(oo), pmp_(pmp), mci_(mci), epoll_server_(NULL) {}
 
 OutputOrdering::BeginOutputtingAlarm::~BeginOutputtingAlarm() {
   if (epoll_server_ && pmp_->alarm_enabled)
@@ -110,35 +101,31 @@ void OutputOrdering::AddToOutputOrder(const MemCacheIter& mci) {
     double tmp_think_time_in_s = strtod(x_server_latency.c_str(), &endp);
     if (endp != x_server_latency.c_str() + x_server_latency.size()) {
       LOG(ERROR) << "Unable to understand X-Server-Latency of: "
-                 << x_server_latency << " for resource: "
-                 <<  mci.file_data->filename().c_str();
+                 << x_server_latency
+                 << " for resource: " << mci.file_data->filename().c_str();
     } else {
       think_time_in_s = tmp_think_time_in_s;
     }
   }
   StreamIdToPriorityMap::iterator sitpmi;
-  sitpmi = stream_ids_.insert(
-      std::pair<uint32, PriorityMapPointer>(mci.stream_id,
-                                            PriorityMapPointer())).first;
+  sitpmi = stream_ids_.insert(std::pair<uint32, PriorityMapPointer>(
+                                  mci.stream_id, PriorityMapPointer())).first;
   PriorityMapPointer& pmp = sitpmi->second;
 
   BeginOutputtingAlarm* boa = new BeginOutputtingAlarm(this, &pmp, mci);
   VLOG(1) << "Server think time: " << think_time_in_s;
-  epoll_server_->RegisterAlarmApproximateDelta(
-      think_time_in_s * 1000000, boa);
+  epoll_server_->RegisterAlarmApproximateDelta(think_time_in_s * 1000000, boa);
 }
 
 void OutputOrdering::SpliceToPriorityRing(PriorityRing::iterator pri) {
   MemCacheIter& mci = *pri;
   PriorityMap::iterator pmi = priority_map_.find(mci.priority);
   if (pmi == priority_map_.end()) {
-    pmi = priority_map_.insert(
-        std::pair<uint32, PriorityRing>(mci.priority, PriorityRing())).first;
+    pmi = priority_map_.insert(std::pair<uint32, PriorityRing>(
+                                   mci.priority, PriorityRing())).first;
   }
 
-  pmi->second.splice(pmi->second.end(),
-                     first_data_senders_,
-                     pri);
+  pmi->second.splice(pmi->second.end(), first_data_senders_, pri);
   StreamIdToPriorityMap::iterator sitpmi = stream_ids_.find(mci.stream_id);
   sitpmi->second.ring = &(pmi->second);
 }
@@ -150,8 +137,8 @@ MemCacheIter* OutputOrdering::GetIter() {
       SpliceToPriorityRing(first_data_senders_.begin());
     } else {
       first_data_senders_.splice(first_data_senders_.end(),
-                                first_data_senders_,
-                                first_data_senders_.begin());
+                                 first_data_senders_,
+                                 first_data_senders_.begin());
       mci.max_segment_size = kInitialDataSendersThreshold;
       return &mci;
     }
@@ -163,9 +150,7 @@ MemCacheIter* OutputOrdering::GetIter() {
       continue;
     }
     MemCacheIter& mci = first_ring.front();
-    first_ring.splice(first_ring.end(),
-                      first_ring,
-                      first_ring.begin());
+    first_ring.splice(first_ring.end(), first_ring, first_ring.begin());
     mci.max_segment_size = kSpdySegmentSize;
     return &mci;
   }
diff --git a/net/tools/flip_server/ring_buffer.cc b/net/tools/flip_server/ring_buffer.cc
index 81e9e9e..16c278b 100644
--- a/net/tools/flip_server/ring_buffer.cc
+++ b/net/tools/flip_server/ring_buffer.cc
@@ -12,42 +12,19 @@ RingBuffer::RingBuffer(int buffer_size)
       buffer_size_(buffer_size),
       bytes_used_(0),
       read_idx_(0),
-      write_idx_(0) {
-}
+      write_idx_(0) {}
 
 RingBuffer::~RingBuffer() {}
 
-////////////////////////////////////////////////////////////////////////////////
-
-int RingBuffer::ReadableBytes() const {
-  return bytes_used_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-int RingBuffer::BufferSize() const {
-  return buffer_size_;
-}
+int RingBuffer::ReadableBytes() const { return bytes_used_; }
 
-////////////////////////////////////////////////////////////////////////////////
-
-int RingBuffer::BytesFree() const {
-  return BufferSize() - ReadableBytes();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-bool RingBuffer::Empty() const {
-  return ReadableBytes() == 0;
-}
+int RingBuffer::BufferSize() const { return buffer_size_; }
 
-////////////////////////////////////////////////////////////////////////////////
+int RingBuffer::BytesFree() const { return BufferSize() - ReadableBytes(); }
 
-bool RingBuffer::Full() const {
-  return ReadableBytes() == BufferSize();
-}
+bool RingBuffer::Empty() const { return ReadableBytes() == 0; }
 
-////////////////////////////////////////////////////////////////////////////////
+bool RingBuffer::Full() const { return ReadableBytes() == BufferSize(); }
 
 // Returns the number of characters written.
 // Appends up-to-'size' bytes to the ringbuffer.
@@ -94,8 +71,6 @@ int RingBuffer::Write(const char* bytes, int size) {
 #endif
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 // Sets *ptr to the beginning of writable memory, and sets *size to the size
 // available for writing using this pointer.
 void RingBuffer::GetWritablePtr(char** ptr, int* size) const {
@@ -110,8 +85,6 @@ void RingBuffer::GetWritablePtr(char** ptr, int* size) const {
   }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 // Sets *ptr to the beginning of readable memory, and sets *size to the size
 // available for reading using this pointer.
 void RingBuffer::GetReadablePtr(char** ptr, int* size) const {
@@ -126,8 +99,6 @@ void RingBuffer::GetReadablePtr(char** ptr, int* size) const {
   }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 // returns the number of bytes read into
 int RingBuffer::Read(char* bytes, int size) {
   CHECK_GE(size, 0);
@@ -171,18 +142,14 @@ int RingBuffer::Read(char* bytes, int size) {
 #endif
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 void RingBuffer::Clear() {
   bytes_used_ = 0;
   write_idx_ = 0;
   read_idx_ = 0;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 bool RingBuffer::Reserve(int size) {
-  DCHECK(size > 0);
+  DCHECK_GT(size, 0);
   char* write_ptr = NULL;
   int write_size = 0;
   GetWritablePtr(&write_ptr, &write_size);
@@ -197,8 +164,8 @@ bool RingBuffer::Reserve(int size) {
       // possible if the read_idx < write_idx. If write_idx < read_idx, then
       // the writeable region must be contiguous: [write_idx, read_idx). There
       // is no work to be done for the latter.
-      DCHECK(read_idx_ <= write_idx_);
-      DCHECK(read_size == ReadableBytes());
+      DCHECK_LE(read_idx_, write_idx_);
+      DCHECK_EQ(read_size, ReadableBytes());
       if (read_idx_ < write_idx_) {
         // Writeable area fragmented, consolidate it.
         memmove(buffer_.get(), read_ptr, read_size);
@@ -206,7 +173,7 @@ bool RingBuffer::Reserve(int size) {
         write_idx_ = read_size;
       } else if (read_idx_ == write_idx_) {
         // No unconsumed data in the buffer, simply reset the indexes.
-        DCHECK(ReadableBytes() == 0);
+        DCHECK_EQ(ReadableBytes(), 0);
         read_idx_ = 0;
         write_idx_ = 0;
       }
@@ -218,8 +185,6 @@ bool RingBuffer::Reserve(int size) {
   return true;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 void RingBuffer::AdvanceReadablePtr(int amount_to_consume) {
   CHECK_GE(amount_to_consume, 0);
   if (amount_to_consume >= bytes_used_) {
@@ -231,8 +196,6 @@ void RingBuffer::AdvanceReadablePtr(int amount_to_consume) {
   bytes_used_ -= amount_to_consume;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 void RingBuffer::AdvanceWritablePtr(int amount_to_produce) {
   CHECK_GE(amount_to_produce, 0);
   CHECK_LE(amount_to_produce, BytesFree());
@@ -241,11 +204,10 @@ void RingBuffer::AdvanceWritablePtr(int amount_to_produce) {
   bytes_used_ += amount_to_produce;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 void RingBuffer::Resize(int buffer_size) {
   CHECK_GE(buffer_size, 0);
-  if (buffer_size == buffer_size_) return;
+  if (buffer_size == buffer_size_)
+    return;
 
   char* new_buffer = new char[buffer_size];
   if (buffer_size < bytes_used_) {
@@ -259,7 +221,8 @@ void RingBuffer::Resize(int buffer_size) {
     int size;
     char* ptr;
     GetReadablePtr(&ptr, &size);
-    if (size == 0) break;
+    if (size == 0)
+      break;
     if (size > buffer_size) {
       size = buffer_size;
     }
@@ -276,4 +239,3 @@ void RingBuffer::Resize(int buffer_size) {
 }
 
 }  // namespace net
-
diff --git a/net/tools/flip_server/ring_buffer.h b/net/tools/flip_server/ring_buffer.h
index ef660c3..b129ee8 100644
--- a/net/tools/flip_server/ring_buffer.h
+++ b/net/tools/flip_server/ring_buffer.h
@@ -47,7 +47,7 @@ class RingBuffer : public BufferInterface {
 
   // returns the number of characters written.
   // appends up-to-'size' bytes to the ringbuffer.
-  virtual int Write(const char * bytes, int size) OVERRIDE;
+  virtual int Write(const char* bytes, int size) OVERRIDE;
 
   // Stores a pointer into the ring buffer in *ptr,  and stores the number of
   // characters which are allowed to be written in *size.
@@ -110,4 +110,3 @@ class RingBuffer : public BufferInterface {
 }  // namespace net
 
 #endif  // NET_TOOLS_FLIP_SERVER_RING_BUFFER_H__
-
diff --git a/net/tools/flip_server/run_all_tests.cc b/net/tools/flip_server/run_all_tests.cc
index 07ac2f7..6acc286b 100644
--- a/net/tools/flip_server/run_all_tests.cc
+++ b/net/tools/flip_server/run_all_tests.cc
@@ -5,6 +5,4 @@
 #include "base/test/test_suite.h"
 #include "build/build_config.h"
 
-int main(int argc, char** argv) {
-  return base::TestSuite(argc, argv).Run();
-}
+int main(int argc, char** argv) { return base::TestSuite(argc, argv).Run(); }
diff --git a/net/tools/flip_server/sm_connection.cc b/net/tools/flip_server/sm_connection.cc
index 062e44e..158cd30f 100644
--- a/net/tools/flip_server/sm_connection.cc
+++ b/net/tools/flip_server/sm_connection.cc
@@ -54,17 +54,14 @@ SMConnection::SMConnection(EpollServer* epoll_server,
       sm_interface_(NULL),
       log_prefix_(log_prefix),
       max_bytes_sent_per_dowrite_(4096),
-      ssl_(NULL) {
-}
+      ssl_(NULL) {}
 
 SMConnection::~SMConnection() {
   if (initialized())
     Reset();
 }
 
-EpollServer* SMConnection::epoll_server() {
-  return epoll_server_;
-}
+EpollServer* SMConnection::epoll_server() { return epoll_server_; }
 
 void SMConnection::ReadyToSend() {
   VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
@@ -104,11 +101,8 @@ void SMConnection::InitSMConnection(SMConnectionPoolInterface* connection_pool,
     // TODO(kelindsay): is_numeric_host_address value needs to be detected
     server_ip_ = server_ip;
     server_port_ = server_port;
-    int ret = CreateConnectedSocket(&fd_,
-                                    server_ip,
-                                    server_port,
-                                    true,
-                                    acceptor_->disable_nagle_);
+    int ret = CreateConnectedSocket(
+        &fd_, server_ip, server_port, true, acceptor_->disable_nagle_);
 
     if (ret < 0) {
       LOG(ERROR) << "-1 Could not create connected socket";
@@ -117,12 +111,12 @@ void SMConnection::InitSMConnection(SMConnectionPoolInterface* connection_pool,
       DCHECK_NE(-1, fd_);
       connection_complete_ = true;
       VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
-              << "Connection complete to: " << server_ip_ << ":"
-              << server_port_ << " ";
+              << "Connection complete to: " << server_ip_ << ":" << server_port_
+              << " ";
     }
     VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
-            << "Connecting to server: " << server_ip_ << ":"
-              << server_port_ << " ";
+            << "Connecting to server: " << server_ip_ << ":" << server_port_
+            << " ";
   } else {
     // If fd != -1 then we are initializing a connection that has just been
     // accepted from the listen socket.
@@ -132,7 +126,7 @@ void SMConnection::InitSMConnection(SMConnectionPoolInterface* connection_pool,
     }
     if (fd_ != -1) {
       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
-               << "Closing pre-existing fd";
+              << "Closing pre-existing fd";
       close(fd_);
       fd_ = -1;
     }
@@ -261,8 +255,8 @@ void SMConnection::Cleanup(const char* cleanup) {
 }
 
 void SMConnection::HandleEvents() {
-  VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "Received: "
-          << EpollServer::EventMaskToString(events_).c_str();
+  VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
+          << "Received: " << EpollServer::EventMaskToString(events_).c_str();
 
   if (events_ & EPOLLIN) {
     if (!DoRead())
@@ -274,8 +268,8 @@ void SMConnection::HandleEvents() {
     if (connection_complete_ == false) {
       int sock_error;
       socklen_t sock_error_len = sizeof(sock_error);
-      int ret = getsockopt(fd_, SOL_SOCKET, SO_ERROR, &sock_error,
-                            &sock_error_len);
+      int ret =
+          getsockopt(fd_, SOL_SOCKET, SO_ERROR, &sock_error, &sock_error_len);
       if (ret != 0) {
         VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
                 << "getsockopt error: " << errno << ": " << strerror(errno);
@@ -285,7 +279,7 @@ void SMConnection::HandleEvents() {
         connection_complete_ = true;
         VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
                 << "Connection complete to " << server_ip_ << ":"
-              << server_port_ << " ";
+                << server_port_ << " ";
       } else if (sock_error == EINPROGRESS) {
         return;
       } else {
@@ -304,7 +298,7 @@ void SMConnection::HandleEvents() {
   }
   return;
 
-  handle_close_or_error:
+ handle_close_or_error:
   Cleanup("HandleEvents");
 }
 
@@ -316,25 +310,28 @@ bool SMConnection::WasSpdyNegotiated(SpdyMajorVersion* version_negotiated) {
 
   // If this is an SSL connection, check if NPN specifies SPDY.
   if (ssl_) {
-    const unsigned char *npn_proto;
+    const unsigned char* npn_proto;
     unsigned int npn_proto_len;
     SSL_get0_next_proto_negotiated(ssl_, &npn_proto, &npn_proto_len);
     if (npn_proto_len > 0) {
-      std::string npn_proto_str((const char *)npn_proto, npn_proto_len);
+      std::string npn_proto_str((const char*)npn_proto, npn_proto_len);
       VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
               << "NPN protocol detected: " << npn_proto_str;
       if (!strncmp(reinterpret_cast<const char*>(npn_proto),
-                   "spdy/2", npn_proto_len)) {
+                   "spdy/2",
+                   npn_proto_len)) {
         *version_negotiated = SPDY2;
         return true;
       }
       if (!strncmp(reinterpret_cast<const char*>(npn_proto),
-                   "spdy/3", npn_proto_len)) {
+                   "spdy/3",
+                   npn_proto_len)) {
         *version_negotiated = SPDY3;
         return true;
       }
       if (!strncmp(reinterpret_cast<const char*>(npn_proto),
-                   "spdy/4a2", npn_proto_len)) {
+                   "spdy/4a2",
+                   npn_proto_len)) {
         *version_negotiated = SPDY4;
         return true;
       }
@@ -363,55 +360,43 @@ bool SMConnection::SetupProtocolInterfaces() {
   }
 
   switch (acceptor_->flip_handler_type_) {
-    case FLIP_HANDLER_HTTP_SERVER:
-      {
-        DCHECK(!spdy_negotiated);
-        VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
-                << (sm_http_interface_ ? "Creating" : "Reusing")
-                << " HTTP interface.";
-        if (!sm_http_interface_)
-          sm_http_interface_ = new HttpSM(this,
-                                          NULL,
-                                          memory_cache_,
-                                          acceptor_);
-        sm_interface_ = sm_http_interface_;
-      }
+    case FLIP_HANDLER_HTTP_SERVER: {
+      DCHECK(!spdy_negotiated);
+      VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
+              << (sm_http_interface_ ? "Creating" : "Reusing")
+              << " HTTP interface.";
+      if (!sm_http_interface_)
+        sm_http_interface_ = new HttpSM(this, NULL, memory_cache_, acceptor_);
+      sm_interface_ = sm_http_interface_;
       break;
-    case FLIP_HANDLER_PROXY:
-      {
-        VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
-                << (sm_streamer_interface_ ? "Creating" : "Reusing")
-                << " PROXY Streamer interface.";
-        if (!sm_streamer_interface_) {
-          sm_streamer_interface_ = new StreamerSM(this,
-                                                  NULL,
-                                                  epoll_server_,
-                                                  acceptor_);
-          sm_streamer_interface_->set_is_request();
-        }
-        sm_interface_ = sm_streamer_interface_;
-        // If spdy is not negotiated, the streamer interface will proxy all
-        // data to the origin server.
-        if (!spdy_negotiated)
-          break;
-      }
-      // Otherwise fall through into the case below.
-    case FLIP_HANDLER_SPDY_SERVER:
-      {
-        DCHECK(spdy_negotiated);
-        VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
-                << (sm_spdy_interface_ ? "Creating" : "Reusing")
-                << " SPDY interface.";
-        if (!sm_spdy_interface_)
-          sm_spdy_interface_ = new SpdySM(this,
-                                          NULL,
-                                          epoll_server_,
-                                          memory_cache_,
-                                          acceptor_,
-                                          version);
-        sm_interface_ = sm_spdy_interface_;
+    }
+    case FLIP_HANDLER_PROXY: {
+      VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
+              << (sm_streamer_interface_ ? "Creating" : "Reusing")
+              << " PROXY Streamer interface.";
+      if (!sm_streamer_interface_) {
+        sm_streamer_interface_ =
+            new StreamerSM(this, NULL, epoll_server_, acceptor_);
+        sm_streamer_interface_->set_is_request();
       }
+      sm_interface_ = sm_streamer_interface_;
+      // If spdy is not negotiated, the streamer interface will proxy all
+      // data to the origin server.
+      if (!spdy_negotiated)
+        break;
+    }
+    // Otherwise fall through into the case below.
+    case FLIP_HANDLER_SPDY_SERVER: {
+      DCHECK(spdy_negotiated);
+      VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
+              << (sm_spdy_interface_ ? "Creating" : "Reusing")
+              << " SPDY interface.";
+      if (!sm_spdy_interface_)
+        sm_spdy_interface_ = new SpdySM(
+            this, NULL, epoll_server_, memory_cache_, acceptor_, version);
+      sm_interface_ = sm_spdy_interface_;
       break;
+    }
   }
 
   CorkSocket();
@@ -469,12 +454,12 @@ bool SMConnection::DoRead() {
         default:
           VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
                   << "While calling recv, got error: "
-                  << (ssl_?"(ssl error)":strerror(stored_errno));
+                  << (ssl_ ? "(ssl error)" : strerror(stored_errno));
           goto error_or_close;
       }
     } else if (bytes_read > 0) {
       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "read " << bytes_read
-               << " bytes";
+              << " bytes";
       last_read_time_ = time(NULL);
       // If the protocol hasn't been detected yet, set up the handlers
       // we'll need.
@@ -498,7 +483,7 @@ bool SMConnection::DoRead() {
   VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "DoRead done!";
   return true;
 
-  error_or_close:
+ error_or_close:
   VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
           << "DoRead(): error_or_close. "
           << "Cleaning up, then returning false";
@@ -536,9 +521,7 @@ bool SMConnection::DoConsumeReadData() {
   return true;
 }
 
-void SMConnection::HandleResponseFullyRead() {
-  sm_interface_->Cleanup();
-}
+void SMConnection::HandleResponseFullyRead() { sm_interface_->Cleanup(); }
 
 bool SMConnection::DoWrite() {
   size_t bytes_sent = 0;
@@ -558,8 +541,8 @@ bool SMConnection::DoWrite() {
     }
   }
   while (!output_list_.empty()) {
-    VLOG(2) << log_prefix_ << "DoWrite: Items in output list: "
-            << output_list_.size();
+    VLOG(2) << log_prefix_
+            << "DoWrite: Items in output list: " << output_list_.size();
     if (bytes_sent >= max_bytes_sent_per_dowrite_) {
       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
               << " byte sent >= max bytes sent per write: Setting EPOLLOUT: "
@@ -571,7 +554,7 @@ bool SMConnection::DoWrite() {
       sm_interface_->GetOutput();
     }
     DataFrame* data_frame = output_list_.front();
-    const char*  bytes = data_frame->data;
+    const char* bytes = data_frame->data;
     int size = data_frame->size;
     bytes += data_frame->index;
     size -= data_frame->index;
@@ -606,13 +589,13 @@ bool SMConnection::DoWrite() {
           continue;
         default:
           VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
-                  << "While calling send, got error: " << stored_errno
-                  << ": " << (ssl_?"":strerror(stored_errno));
+                  << "While calling send, got error: " << stored_errno << ": "
+                  << (ssl_ ? "" : strerror(stored_errno));
           goto error_or_close;
       }
     } else if (bytes_written > 0) {
-      VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "Wrote: "
-              << bytes_written << " bytes";
+      VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
+              << "Wrote: " << bytes_written << " bytes";
       data_frame->index += bytes_written;
       bytes_sent += bytes_written;
       continue;
@@ -660,8 +643,7 @@ void SMConnection::Reset() {
   initialized_ = false;
   protocol_detected_ = false;
   events_ = 0;
-  for (std::list<DataFrame*>::iterator i =
-       output_list_.begin();
+  for (std::list<DataFrame*>::iterator i = output_list_.begin();
        i != output_list_.end();
        ++i) {
     delete *i;
@@ -671,12 +653,12 @@ void SMConnection::Reset() {
 
 // static
 SMConnection* SMConnection::NewSMConnection(EpollServer* epoll_server,
-                                            SSLState *ssl_state,
+                                            SSLState* ssl_state,
                                             MemoryCache* memory_cache,
-                                            FlipAcceptor *acceptor,
+                                            FlipAcceptor* acceptor,
                                             std::string log_prefix) {
-  return new SMConnection(epoll_server, ssl_state, memory_cache,
-                          acceptor, log_prefix);
+  return new SMConnection(
+      epoll_server, ssl_state, memory_cache, acceptor, log_prefix);
 }
 
 }  // namespace net
diff --git a/net/tools/flip_server/sm_connection.h b/net/tools/flip_server/sm_connection.h
index 20961cd..93ad42e 100644
--- a/net/tools/flip_server/sm_connection.h
+++ b/net/tools/flip_server/sm_connection.h
@@ -46,9 +46,9 @@ class SMConnection : public SMConnectionInterface,
   virtual ~SMConnection();
 
   static SMConnection* NewSMConnection(EpollServer* epoll_server,
-                                       SSLState *ssl_state,
+                                       SSLState* ssl_state,
                                        MemoryCache* memory_cache,
-                                       FlipAcceptor *acceptor,
+                                       FlipAcceptor* acceptor,
                                        std::string log_prefix);
 
   // TODO(mbelshe): Make these private.
@@ -125,6 +125,7 @@ class SMConnection : public SMConnectionInterface,
                MemoryCache* memory_cache,
                FlipAcceptor* acceptor,
                std::string log_prefix);
+
  private:
   int fd_;
   int events_;
@@ -136,10 +137,10 @@ class SMConnection : public SMConnectionInterface,
 
   SMConnectionPoolInterface* connection_pool_;
 
-  EpollServer *epoll_server_;
-  SSLState *ssl_state_;
+  EpollServer* epoll_server_;
+  SSLState* ssl_state_;
   MemoryCache* memory_cache_;
-  FlipAcceptor *acceptor_;
+  FlipAcceptor* acceptor_;
   std::string client_ip_;
 
   RingBuffer read_buffer_;
diff --git a/net/tools/flip_server/sm_interface.h b/net/tools/flip_server/sm_interface.h
index 28e5bc6..389c683 100644
--- a/net/tools/flip_server/sm_interface.h
+++ b/net/tools/flip_server/sm_interface.h
@@ -28,7 +28,7 @@ class SMInterface {
                                 std::string server_ip,
                                 std::string server_port,
                                 std::string remote_ip,
-                                bool use_ssl)  = 0;
+                                bool use_ssl) = 0;
   virtual size_t ProcessReadInput(const char* data, size_t len) = 0;
   virtual size_t ProcessWriteInput(const char* data, size_t len) = 0;
   virtual void SetStreamID(uint32 stream_id) = 0;
@@ -46,16 +46,20 @@ class SMInterface {
 
   virtual int PostAcceptHook() = 0;
 
-  virtual void NewStream(uint32 stream_id, uint32 priority,
+  virtual void NewStream(uint32 stream_id,
+                         uint32 priority,
                          const std::string& filename) = 0;
   virtual void SendEOF(uint32 stream_id) = 0;
   virtual void SendErrorNotFound(uint32 stream_id) = 0;
   virtual size_t SendSynStream(uint32 stream_id,
-                              const BalsaHeaders& headers) = 0;
+                               const BalsaHeaders& headers) = 0;
   virtual size_t SendSynReply(uint32 stream_id,
                               const BalsaHeaders& headers) = 0;
-  virtual void SendDataFrame(uint32 stream_id, const char* data, int64 len,
-                             uint32 flags, bool compress) = 0;
+  virtual void SendDataFrame(uint32 stream_id,
+                             const char* data,
+                             int64 len,
+                             uint32 flags,
+                             bool compress) = 0;
   virtual void GetOutput() = 0;
   virtual void set_is_request() = 0;
 
@@ -64,9 +68,9 @@ class SMInterface {
 
 class SMConnectionInterface {
  public:
-   virtual ~SMConnectionInterface() {}
-   virtual void ReadyToSend() = 0;
-   virtual EpollServer* epoll_server() = 0;
+  virtual ~SMConnectionInterface() {}
+  virtual void ReadyToSend() = 0;
+  virtual EpollServer* epoll_server() = 0;
 };
 
 class SMConnectionPoolInterface {
@@ -78,4 +82,3 @@ class SMConnectionPoolInterface {
 }  // namespace net
 
 #endif  // NET_TOOLS_FLIP_SERVER_SM_INTERFACE_H_
-
diff --git a/net/tools/flip_server/spdy_interface.cc b/net/tools/flip_server/spdy_interface.cc
index 23646bd..41ad430 100644
--- a/net/tools/flip_server/spdy_interface.cc
+++ b/net/tools/flip_server/spdy_interface.cc
@@ -22,15 +22,12 @@ std::string SpdySM::forward_ip_header_;
 
 class SpdyFrameDataFrame : public DataFrame {
  public:
-  explicit SpdyFrameDataFrame(SpdyFrame* spdy_frame)
-      : frame(spdy_frame) {
+  explicit SpdyFrameDataFrame(SpdyFrame* spdy_frame) : frame(spdy_frame) {
     data = spdy_frame->data();
     size = spdy_frame->size();
   }
 
-  virtual ~SpdyFrameDataFrame() {
-    delete frame;
-  }
+  virtual ~SpdyFrameDataFrame() { delete frame; }
 
   const SpdyFrame* frame;
 };
@@ -54,9 +51,7 @@ SpdySM::SpdySM(SMConnection* connection,
   buffered_spdy_framer_->set_visitor(this);
 }
 
-SpdySM::~SpdySM() {
-  delete buffered_spdy_framer_;
-}
+SpdySM::~SpdySM() { delete buffered_spdy_framer_; }
 
 void SpdySM::InitSMConnection(SMConnectionPoolInterface* connection_pool,
                               SMInterface* sm_interface,
@@ -66,11 +61,15 @@ void SpdySM::InitSMConnection(SMConnectionPoolInterface* connection_pool,
                               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);
+  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() {
@@ -85,25 +84,22 @@ SMInterface* SpdySM::NewConnectionInterface() {
     return NULL;
   }
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Creating new HTTP interface";
-  SMInterface *sm_http_interface = new HttpSM(server_connection,
-                                              this,
-                                              memory_cache_,
-                                              acceptor_);
+  SMInterface* sm_http_interface =
+      new HttpSM(server_connection, this, memory_cache_, acceptor_);
   return sm_http_interface;
 }
 
 SMInterface* SpdySM::FindOrMakeNewSMConnectionInterface(
     const std::string& server_ip,
     const std::string& server_port) {
-  SMInterface *sm_http_interface;
+  SMInterface* sm_http_interface;
   int32 server_idx;
   if (unused_server_interface_list.empty()) {
     sm_http_interface = NewConnectionInterface();
     server_idx = server_interface_list.size();
     server_interface_list.push_back(sm_http_interface);
     VLOG(2) << ACCEPTOR_CLIENT_IDENT
-            << "SpdySM: Making new server connection on index: "
-            << server_idx;
+            << "SpdySM: Making new server connection on index: " << server_idx;
   } else {
     server_idx = unused_server_interface_list.back();
     unused_server_interface_list.pop_back();
@@ -125,17 +121,14 @@ SMInterface* SpdySM::FindOrMakeNewSMConnectionInterface(
   return sm_http_interface;
 }
 
-int SpdySM::SpdyHandleNewStream(
-    SpdyStreamId stream_id,
-    SpdyPriority priority,
-    const SpdyHeaderBlock& headers,
-    std::string &http_data,
-    bool* is_https_scheme) {
+int SpdySM::SpdyHandleNewStream(SpdyStreamId stream_id,
+                                SpdyPriority priority,
+                                const SpdyHeaderBlock& headers,
+                                std::string& http_data,
+                                bool* is_https_scheme) {
   *is_https_scheme = false;
-  VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnSyn("
-          << stream_id << ")";
-  VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: # headers: "
-          << headers.size();
+  VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnSyn(" << stream_id << ")";
+  VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: # headers: " << headers.size();
 
   SpdyHeaderBlock supplement;
   SpdyHeaderBlock::const_iterator method = headers.end();
@@ -254,8 +247,8 @@ void SpdySM::OnSynStream(SpdyStreamId stream_id,
                          const SpdyHeaderBlock& headers) {
   std::string http_data;
   bool is_https_scheme;
-  int ret = SpdyHandleNewStream(stream_id, priority, headers, http_data,
-                                &is_https_scheme);
+  int ret = SpdyHandleNewStream(
+      stream_id, priority, headers, http_data, &is_https_scheme);
   if (!ret) {
     LOG(ERROR) << "SpdySM: Could not convert spdy into http.";
     return;
@@ -278,8 +271,7 @@ void SpdySM::OnSynStream(SpdyStreamId stream_id,
         FindOrMakeNewSMConnectionInterface(server_ip, server_port);
     stream_to_smif_[stream_id] = sm_http_interface;
     sm_http_interface->SetStreamID(stream_id);
-    sm_http_interface->ProcessWriteInput(http_data.c_str(),
-                                         http_data.size());
+    sm_http_interface->ProcessWriteInput(http_data.c_str(), http_data.size());
   }
 }
 
@@ -288,21 +280,18 @@ void SpdySM::OnSynReply(SpdyStreamId stream_id,
                         const SpdyHeaderBlock& headers) {
   // TODO(willchan): if there is an error parsing headers, we
   // should send a RST_STREAM.
-  VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnSynReply("
-          << stream_id << ")";
+  VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnSynReply(" << stream_id << ")";
 }
 
 void SpdySM::OnHeaders(SpdyStreamId stream_id,
                        bool fin,
                        const SpdyHeaderBlock& headers) {
-  VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnHeaders("
-          << stream_id << ")";
+  VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnHeaders(" << stream_id << ")";
 }
 
-void SpdySM::OnRstStream(SpdyStreamId stream_id,
-                         SpdyRstStreamStatus status) {
-  VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnRstStream("
-          << stream_id << ")";
+void SpdySM::OnRstStream(SpdyStreamId stream_id, SpdyRstStreamStatus status) {
+  VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnRstStream(" << stream_id
+          << ")";
   client_output_ordering_.RemoveStreamId(stream_id);
 }
 
@@ -310,9 +299,7 @@ size_t SpdySM::ProcessReadInput(const char* data, size_t len) {
   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 {
   return buffered_spdy_framer_->MessageFullyRead();
@@ -348,8 +335,7 @@ int SpdySM::PostAcceptHook() {
   SettingsMap settings;
   settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, 100);
-  SpdyFrame* settings_frame =
-      buffered_spdy_framer_->CreateSettings(settings);
+  SpdyFrame* settings_frame = buffered_spdy_framer_->CreateSettings(settings);
 
   VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Sending Settings Frame";
   EnqueueDataFrame(new SpdyFrameDataFrame(settings_frame));
@@ -382,9 +368,7 @@ 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);
@@ -398,8 +382,11 @@ size_t SpdySM::SendSynReply(uint32 stream_id, const BalsaHeaders& headers) {
   return SendSynReplyImpl(stream_id, headers);
 }
 
-void SpdySM::SendDataFrame(uint32 stream_id, const char* data, int64 len,
-                           uint32 flags, bool compress) {
+void SpdySM::SendDataFrame(uint32 stream_id,
+                           const char* data,
+                           int64 len,
+                           uint32 flags,
+                           bool compress) {
   SpdyDataFlags spdy_flags = static_cast<SpdyDataFlags>(flags);
   SendDataFrameImpl(stream_id, data, len, spdy_flags, compress);
 }
@@ -440,15 +427,14 @@ void SpdySM::CopyHeaders(SpdyHeaderBlock& dest, const BalsaHeaders& headers) {
     if (fhi == dest.end()) {
       dest[key] = hi->second.as_string();
     } else {
-      dest[key] = (
-          std::string(fhi->second.data(), fhi->second.size()) + "\0" +
-          std::string(hi->second.data(), hi->second.size()));
+      dest[key] = (std::string(fhi->second.data(), fhi->second.size()) + "\0" +
+                   std::string(hi->second.data(), hi->second.size()));
     }
   }
 
   // These headers have no value
   dest.erase("X-Associated-Content");  // TODO(mbelshe): case-sensitive
-  dest.erase("X-Original-Url");  // TODO(mbelshe): case-sensitive
+  dest.erase("X-Original-Url");        // TODO(mbelshe): case-sensitive
 }
 
 size_t SpdySM::SendSynStreamImpl(uint32 stream_id,
@@ -516,14 +502,17 @@ size_t SpdySM::SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers) {
   return df_size;
 }
 
-void SpdySM::SendDataFrameImpl(uint32 stream_id, const char* data, int64 len,
-                               SpdyDataFlags flags, bool compress) {
+void SpdySM::SendDataFrameImpl(uint32 stream_id,
+                               const char* data,
+                               int64 len,
+                               SpdyDataFlags flags,
+                               bool compress) {
   // TODO(mbelshe):  We can't compress here - before going into the
   //                 priority queue.  Compression needs to be done
   //                 with late binding.
   if (len == 0) {
-    SpdyFrame* fdf = buffered_spdy_framer_->CreateDataFrame(
-        stream_id, data, len, flags);
+    SpdyFrame* fdf =
+        buffered_spdy_framer_->CreateDataFrame(stream_id, data, len, flags);
     EnqueueDataFrame(new SpdyFrameDataFrame(fdf));
     return;
   }
@@ -575,9 +564,8 @@ void SpdySM::GetOutput() {
         headers.CopyFrom(*(mci->file_data->headers()));
         headers.ReplaceOrAppendHeader("status", "200");
         headers.ReplaceOrAppendHeader("version", "http/1.1");
-        headers.SetRequestFirstlineFromStringPieces("PUSH",
-                                                    mci->file_data->filename(),
-                                                    "");
+        headers.SetRequestFirstlineFromStringPieces(
+            "PUSH", mci->file_data->filename(), "");
         mci->bytes_sent = SendSynStream(mci->stream_id, headers);
       } else {
         BalsaHeaders headers;
@@ -609,7 +597,9 @@ void SpdySM::GetOutput() {
 
     SendDataFrame(mci->stream_id,
                   mci->file_data->body().data() + mci->body_bytes_consumed,
-                  num_to_write, 0, should_compress);
+                  num_to_write,
+                  0,
+                  should_compress);
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: GetOutput SendDataFrame["
             << mci->stream_id << "]: " << num_to_write;
     mci->body_bytes_consumed += num_to_write;
diff --git a/net/tools/flip_server/spdy_interface.h b/net/tools/flip_server/spdy_interface.h
index 05e1d85..6e5ad0b 100644
--- a/net/tools/flip_server/spdy_interface.h
+++ b/net/tools/flip_server/spdy_interface.h
@@ -23,8 +23,7 @@ namespace net {
 class FlipAcceptor;
 class MemoryCache;
 
-class SpdySM : public BufferedSpdyFramerVisitorInterface,
-               public SMInterface {
+class SpdySM : public BufferedSpdyFramerVisitorInterface, public SMInterface {
  public:
   SpdySM(SMConnection* connection,
          SMInterface* sm_http_interface,
@@ -155,8 +154,11 @@ class SpdySM : public BufferedSpdyFramerVisitorInterface,
                                const BalsaHeaders& headers) OVERRIDE;
   virtual size_t SendSynReply(uint32 stream_id,
                               const BalsaHeaders& headers) OVERRIDE;
-  virtual void SendDataFrame(uint32 stream_id, const char* data, int64 len,
-                             uint32 flags, bool compress) OVERRIDE;
+  virtual void SendDataFrame(uint32 stream_id,
+                             const char* data,
+                             int64 len,
+                             uint32 flags,
+                             bool compress) OVERRIDE;
   BufferedSpdyFramer* spdy_framer() { return buffered_spdy_framer_; }
 
   const OutputOrdering& output_ordering() const {
@@ -178,8 +180,11 @@ class SpdySM : public BufferedSpdyFramerVisitorInterface,
   void CopyHeaders(SpdyHeaderBlock& dest, const BalsaHeaders& headers);
   size_t SendSynStreamImpl(uint32 stream_id, const BalsaHeaders& headers);
   size_t SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers);
-  void SendDataFrameImpl(uint32 stream_id, const char* data, int64 len,
-                         SpdyDataFlags flags, bool compress);
+  void SendDataFrameImpl(uint32 stream_id,
+                         const char* data,
+                         int64 len,
+                         SpdyDataFlags flags,
+                         bool compress);
   void EnqueueDataFrame(DataFrame* df);
   virtual void GetOutput() OVERRIDE;
 
diff --git a/net/tools/flip_server/spdy_interface_test.cc b/net/tools/flip_server/spdy_interface_test.cc
index 25d9505..3b98852 100644
--- a/net/tools/flip_server/spdy_interface_test.cc
+++ b/net/tools/flip_server/spdy_interface_test.cc
@@ -32,9 +32,7 @@ namespace {
 struct StringSaver {
  public:
   StringSaver() : data(NULL), size(0) {}
-  void Save() {
-    string = std::string(data, size);
-  }
+  void Save() { string = std::string(data, size); }
 
   const char* data;
   size_t size;
@@ -46,13 +44,14 @@ class SpdyFramerVisitor : public BufferedSpdyFramerVisitorInterface {
   virtual ~SpdyFramerVisitor() {}
   MOCK_METHOD1(OnError, void(SpdyFramer::SpdyError));
   MOCK_METHOD2(OnStreamError, void(SpdyStreamId, const std::string&));
-  MOCK_METHOD7(OnSynStream, void(SpdyStreamId,
-                                 SpdyStreamId,
-                                 SpdyPriority,
-                                 uint8,
-                                 bool,
-                                 bool,
-                                 const SpdyHeaderBlock&));
+  MOCK_METHOD7(OnSynStream,
+               void(SpdyStreamId,
+                    SpdyStreamId,
+                    SpdyPriority,
+                    uint8,
+                    bool,
+                    bool,
+                    const SpdyHeaderBlock&));
   MOCK_METHOD3(OnSynStream, void(SpdyStreamId, bool, const SpdyHeaderBlock&));
   MOCK_METHOD3(OnSynReply, void(SpdyStreamId, bool, const SpdyHeaderBlock&));
   MOCK_METHOD3(OnHeaders, void(SpdyStreamId, bool, const SpdyHeaderBlock&));
@@ -84,14 +83,15 @@ class FakeSMConnection : public SMConnection {
                      log_prefix) {}
 
   MOCK_METHOD0(Cleanup, void());
-  MOCK_METHOD8(InitSMConnection, void(SMConnectionPoolInterface*,
-                                      SMInterface*,
-                                      EpollServer*,
-                                      int,
-                                      std::string,
-                                      std::string,
-                                      std::string,
-                                      bool));
+  MOCK_METHOD8(InitSMConnection,
+               void(SMConnectionPoolInterface*,
+                    SMInterface*,
+                    EpollServer*,
+                    int,
+                    std::string,
+                    std::string,
+                    std::string,
+                    bool));
 };
 
 // This class is almost SpdySM, except one function.
@@ -100,11 +100,11 @@ class TestSpdySM : public SpdySM {
  public:
   virtual ~TestSpdySM() {}
   TestSpdySM(SMConnection* connection,
-                                   SMInterface* sm_http_interface,
-                                   EpollServer* epoll_server,
-                                   MemoryCache* memory_cache,
-                                   FlipAcceptor* acceptor,
-                                   SpdyMajorVersion version)
+             SMInterface* sm_http_interface,
+             EpollServer* epoll_server,
+             MemoryCache* memory_cache,
+             FlipAcceptor* acceptor,
+             SpdyMajorVersion version)
       : SpdySM(connection,
                sm_http_interface,
                epoll_server,
@@ -195,30 +195,22 @@ class SpdySMProxyTest : public SpdySMTestBase {
 
 class SpdySMServerTest : public SpdySMTestBase {
  public:
-  SpdySMServerTest(): SpdySMTestBase(FLIP_HANDLER_SPDY_SERVER) {}
+  SpdySMServerTest() : SpdySMTestBase(FLIP_HANDLER_SPDY_SERVER) {}
   virtual ~SpdySMServerTest() {}
 };
 
 INSTANTIATE_TEST_CASE_P(SpdySMProxyTest,
                         SpdySMProxyTest,
                         Values(SPDY2, SPDY3, SPDY4));
-INSTANTIATE_TEST_CASE_P(SpdySMServerTest,
-                        SpdySMServerTest,
-                        Values(SPDY2));
+INSTANTIATE_TEST_CASE_P(SpdySMServerTest, SpdySMServerTest, Values(SPDY2));
 
 TEST_P(SpdySMProxyTest, InitSMConnection) {
   {
     InSequence s;
     EXPECT_CALL(*connection_, InitSMConnection(_, _, _, _, _, _, _, _));
   }
-  interface_->InitSMConnection(NULL,
-                               NULL,
-                               epoll_server_.get(),
-                               -1,
-                               "",
-                               "",
-                               "",
-                               false);
+  interface_->InitSMConnection(
+      NULL, NULL, epoll_server_.get(), -1, "", "", "", false);
 }
 
 TEST_P(SpdySMProxyTest, OnSynStream_SPDY2) {
@@ -242,8 +234,7 @@ TEST_P(SpdySMProxyTest, OnSynStream_SPDY2) {
   StringSaver saver;
   {
     InSequence s;
-    EXPECT_CALL(*interface_,
-                FindOrMakeNewSMConnectionInterface(_, _))
+    EXPECT_CALL(*interface_, FindOrMakeNewSMConnectionInterface(_, _))
         .WillOnce(Return(mock_interface.get()));
     EXPECT_CALL(*mock_interface, SetStreamID(stream_id));
     EXPECT_CALL(*mock_interface, ProcessWriteInput(_, _))
@@ -310,8 +301,7 @@ TEST_P(SpdySMProxyTest, OnStreamFrameData_SPDY2) {
   block["version"] = "HTTP/1.0";
   {
     InSequence s;
-    EXPECT_CALL(*interface_,
-                FindOrMakeNewSMConnectionInterface(_, _))
+    EXPECT_CALL(*interface_, FindOrMakeNewSMConnectionInterface(_, _))
         .WillOnce(Return(mock_interface.get()));
     EXPECT_CALL(*mock_interface, SetStreamID(stream_id));
     EXPECT_CALL(*mock_interface, ProcessWriteInput(_, _)).Times(1);
@@ -420,8 +410,8 @@ TEST_P(SpdySMProxyTest, PostAcceptHook) {
   {
     InSequence s;
     EXPECT_CALL(*spdy_framer_visitor_, OnSettings(false));
-    EXPECT_CALL(*spdy_framer_visitor_, OnSetting(
-        SETTINGS_MAX_CONCURRENT_STREAMS, 0u, 100u));
+    EXPECT_CALL(*spdy_framer_visitor_,
+                OnSetting(SETTINGS_MAX_CONCURRENT_STREAMS, 0u, 100u));
   }
   spdy_framer_->ProcessInput(df->data, df->size);
 }
@@ -465,8 +455,7 @@ TEST_P(SpdySMProxyTest, SendErrorNotFound_SPDY2) {
 
   {
     InSequence s;
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnSynReply(stream_id, false, _))
+    EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
         .WillOnce(SaveArg<2>(&actual_header_block));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(*spdy_framer_visitor_,
@@ -686,8 +675,7 @@ TEST_P(SpdySMProxyTest, SendDataFrame) {
                 OnDataFrameHeader(stream_id, _, false));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, _, _, false))
-        .WillOnce(DoAll(SaveArg<1>(&actual_data),
-                        SaveArg<2>(&actual_size)));
+        .WillOnce(DoAll(SaveArg<1>(&actual_data), SaveArg<2>(&actual_size)));
   }
 
   spdy_framer_->ProcessInput(df->data, df->size);
@@ -701,10 +689,8 @@ TEST_P(SpdySMProxyTest, SendLongDataFrame) {
   const char* actual_data;
   size_t actual_size;
 
-  std::string data =
-      std::string(kSpdySegmentSize, 'a') +
-      std::string(kSpdySegmentSize, 'b') +
-      "c";
+  std::string data = std::string(kSpdySegmentSize, 'a') +
+                     std::string(kSpdySegmentSize, 'b') + "c";
   interface_->SendDataFrame(stream_id, data.data(), data.size(), flags, true);
 
   {
@@ -831,8 +817,7 @@ TEST_P(SpdySMServerTest, NewStreamError) {
 
   {
     InSequence s;
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnSynReply(stream_id, false, _))
+    EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
         .WillOnce(SaveArg<2>(&actual_header_block));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(*spdy_framer_visitor_,
diff --git a/net/tools/flip_server/spdy_ssl.cc b/net/tools/flip_server/spdy_ssl.cc
index dac3d02..1f18a0b 100644
--- a/net/tools/flip_server/spdy_ssl.cc
+++ b/net/tools/flip_server/spdy_ssl.cc
@@ -19,12 +19,12 @@ namespace net {
   "\x08http/1.0"
 #define SSL_CIPHER_LIST "!aNULL:!ADH:!eNull:!LOW:!EXP:RC4+RSA:MEDIUM:HIGH"
 
-int ssl_set_npn_callback(SSL *s,
-                         const unsigned char **data,
-                         unsigned int *len,
-                         void *arg) {
-  VLOG(1) <<  "SSL NPN callback: advertising protocols.";
-  *data = (const unsigned char *) NEXT_PROTO_STRING;
+int ssl_set_npn_callback(SSL* s,
+                         const unsigned char** data,
+                         unsigned int* len,
+                         void* arg) {
+  VLOG(1) << "SSL NPN callback: advertising protocols.";
+  *data = (const unsigned char*)NEXT_PROTO_STRING;
   *len = strlen(NEXT_PROTO_STRING);
   return SSL_TLSEXT_ERR_OK;
 }
@@ -57,9 +57,8 @@ void InitSSL(SSLState* state,
     PrintSslError();
     LOG(FATAL) << "Unable to use cert.pem as SSL cert.";
   }
-  if (SSL_CTX_use_PrivateKey_file(state->ssl_ctx,
-                                  ssl_key_name.c_str(),
-                                  SSL_FILETYPE_PEM) <= 0) {
+  if (SSL_CTX_use_PrivateKey_file(
+          state->ssl_ctx, ssl_key_name.c_str(), SSL_FILETYPE_PEM) <= 0) {
     PrintSslError();
     LOG(FATAL) << "Unable to use key.pem as SSL key.";
   }
@@ -68,8 +67,8 @@ void InitSSL(SSLState* state,
     LOG(FATAL) << "The cert.pem and key.pem files don't match";
   }
   if (use_npn) {
-    SSL_CTX_set_next_protos_advertised_cb(state->ssl_ctx,
-                                          ssl_set_npn_callback, NULL);
+    SSL_CTX_set_next_protos_advertised_cb(
+        state->ssl_ctx, ssl_set_npn_callback, NULL);
   }
   VLOG(1) << "SSL CTX default cipher list: " << SSL_CIPHER_LIST;
   SSL_CTX_set_cipher_list(state->ssl_ctx, SSL_CIPHER_LIST);
@@ -86,7 +85,7 @@ void InitSSL(SSLState* state,
   // Proper methods to disable compression don't exist until 0.9.9+. For now
   // we must manipulate the stack of compression methods directly.
   if (disable_ssl_compression) {
-    STACK_OF(SSL_COMP) *ssl_comp_methods = SSL_COMP_get_compression_methods();
+    STACK_OF(SSL_COMP)* ssl_comp_methods = SSL_COMP_get_compression_methods();
     int num_methods = sk_SSL_COMP_num(ssl_comp_methods);
     int i;
     for (i = 0; i < num_methods; i++) {
diff --git a/net/tools/flip_server/spdy_ssl.h b/net/tools/flip_server/spdy_ssl.h
index 8db0d8c..8b55733 100644
--- a/net/tools/flip_server/spdy_ssl.h
+++ b/net/tools/flip_server/spdy_ssl.h
@@ -28,4 +28,3 @@ void PrintSslError();
 }  // namespace net
 
 #endif  // NET_TOOLS_FLIP_SERVER_SPDY_SSL_H_
-
diff --git a/net/tools/flip_server/spdy_util.cc b/net/tools/flip_server/spdy_util.cc
index d4a789a..311bdb9 100644
--- a/net/tools/flip_server/spdy_util.cc
+++ b/net/tools/flip_server/spdy_util.cc
@@ -31,4 +31,3 @@ std::string EncodeURL(std::string uri, std::string host, std::string method) {
 }
 
 }  // namespace net
-
diff --git a/net/tools/flip_server/spdy_util.h b/net/tools/flip_server/spdy_util.h
index 537053d..6f00200 100644
--- a/net/tools/flip_server/spdy_util.h
+++ b/net/tools/flip_server/spdy_util.h
@@ -18,4 +18,3 @@ std::string EncodeURL(std::string uri, std::string host, std::string method);
 }  // namespace net
 
 #endif  // NET_TOOLS_FLIP_SERVER_SPDY_UTIL_H_
-
diff --git a/net/tools/flip_server/streamer_interface.cc b/net/tools/flip_server/streamer_interface.cc
index 8c2e0e7..25a4964 100644
--- a/net/tools/flip_server/streamer_interface.cc
+++ b/net/tools/flip_server/streamer_interface.cc
@@ -57,9 +57,14 @@ void StreamerSM::InitSMConnection(SMConnectionPoolInterface* connection_pool,
                                   bool use_ssl) {
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "StreamerSM: Initializing server "
           << "connection.";
-  connection_->InitSMConnection(connection_pool, sm_interface,
-                                epoll_server, fd, server_ip,
-                                server_port, remote_ip, use_ssl);
+  connection_->InitSMConnection(connection_pool,
+                                sm_interface,
+                                epoll_server,
+                                fd,
+                                server_ip,
+                                server_port,
+                                remote_ip,
+                                use_ssl);
 }
 
 size_t StreamerSM::ProcessReadInput(const char* data, size_t len) {
@@ -72,23 +77,19 @@ size_t StreamerSM::ProcessReadInput(const char* data, size_t len) {
 }
 
 size_t StreamerSM::ProcessWriteInput(const char* data, size_t len) {
-  char * dataPtr = new char[len];
+  char* dataPtr = new char[len];
   memcpy(dataPtr, data, len);
   DataFrame* df = new DataFrame;
-  df->data = (const char *)dataPtr;
+  df->data = (const char*)dataPtr;
   df->size = len;
   df->delete_when_done = true;
   connection_->EnqueueDataFrame(df);
   return len;
 }
 
-bool StreamerSM::Error() const {
-  return false;
-}
+bool StreamerSM::Error() const { return false; }
 
-const char* StreamerSM::ErrorAsString() const {
-  return "(none)";
-}
+const char* StreamerSM::ErrorAsString() const { return "(none)"; }
 
 bool StreamerSM::MessageFullyRead() const {
   if (is_request_) {
@@ -116,17 +117,16 @@ void StreamerSM::Cleanup() {
 
 int StreamerSM::PostAcceptHook() {
   if (!sm_other_interface_) {
-    SMConnection *server_connection =
-      SMConnection::NewSMConnection(epoll_server_, NULL, NULL,
-                                    acceptor_, "server_conn: ");
+    SMConnection* server_connection = SMConnection::NewSMConnection(
+        epoll_server_, NULL, NULL, acceptor_, "server_conn: ");
     if (server_connection == NULL) {
       LOG(ERROR) << "StreamerSM: Could not create server conenction.";
       return 0;
     }
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "StreamerSM: Creating new server "
             << "connection.";
-    sm_other_interface_ = new StreamerSM(server_connection, this,
-                                         epoll_server_, acceptor_);
+    sm_other_interface_ =
+        new StreamerSM(server_connection, this, epoll_server_, acceptor_);
     sm_other_interface_->InitSMInterface(this, 0);
   }
   // The Streamer interface is used to stream HTTPS connections, so we
@@ -152,7 +152,7 @@ size_t StreamerSM::SendSynReply(uint32 stream_id, const BalsaHeaders& headers) {
   return 0;
 }
 
-void StreamerSM::ProcessBodyInput(const char *input, size_t size) {
+void StreamerSM::ProcessBodyInput(const char* input, size_t size) {
   VLOG(2) << ACCEPTOR_CLIENT_IDENT
           << "StreamerHttpSM: Process Body Input Data: "
           << "size " << size;
@@ -187,21 +187,14 @@ void StreamerSM::ProcessHeaders(const BalsaHeaders& headers) {
   sm_other_interface_->ProcessWriteInput(buffer, size);
 }
 
-void StreamerSM::HandleHeaderError(BalsaFrame* framer) {
-  HandleError();
-}
+void StreamerSM::HandleHeaderError(BalsaFrame* framer) { HandleError(); }
 
-void StreamerSM::HandleChunkingError(BalsaFrame* framer) {
-  HandleError();
-}
+void StreamerSM::HandleChunkingError(BalsaFrame* framer) { HandleError(); }
 
-void StreamerSM::HandleBodyError(BalsaFrame* framer) {
-  HandleError();
-}
+void StreamerSM::HandleBodyError(BalsaFrame* framer) { HandleError(); }
 
 void StreamerSM::HandleError() {
   VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Error detected";
 }
 
 }  // namespace net
-
diff --git a/net/tools/flip_server/streamer_interface.h b/net/tools/flip_server/streamer_interface.h
index efaee6b..0114491 100644
--- a/net/tools/flip_server/streamer_interface.h
+++ b/net/tools/flip_server/streamer_interface.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef NET_TOOLS_FLIP_SERVER_STREAMER_INTERFACE_
-#define NET_TOOLS_FLIP_SERVER_STREAMER_INTERFACE_
+#ifndef NET_TOOLS_FLIP_SERVER_STREAMER_INTERFACE_H_
+#define NET_TOOLS_FLIP_SERVER_STREAMER_INTERFACE_H_
 
 #include <string>
 
@@ -20,8 +20,7 @@ class MemCacheIter;
 class SMConnection;
 class EpollServer;
 
-class StreamerSM : public BalsaVisitorInterface,
-                   public SMInterface  {
+class StreamerSM : public BalsaVisitorInterface, public SMInterface {
  public:
   StreamerSM(SMConnection* connection,
              SMInterface* sm_other_interface,
@@ -53,7 +52,8 @@ class StreamerSM : public BalsaVisitorInterface,
   virtual void ResetForNewConnection() OVERRIDE;
   virtual void Cleanup() OVERRIDE;
   virtual int PostAcceptHook() OVERRIDE;
-  virtual void NewStream(uint32 stream_id, uint32 priority,
+  virtual void NewStream(uint32 stream_id,
+                         uint32 priority,
                          const std::string& filename) OVERRIDE {}
   virtual void SendEOF(uint32 stream_id) OVERRIDE {}
   virtual void SendErrorNotFound(uint32 stream_id) OVERRIDE {}
@@ -62,8 +62,11 @@ class StreamerSM : public BalsaVisitorInterface,
                                const BalsaHeaders& headers) OVERRIDE;
   virtual size_t SendSynReply(uint32 stream_id,
                               const BalsaHeaders& headers) OVERRIDE;
-  virtual void SendDataFrame(uint32 stream_id, const char* data, int64 len,
-                             uint32 flags, bool compress) OVERRIDE {}
+  virtual void SendDataFrame(uint32 stream_id,
+                             const char* data,
+                             int64 len,
+                             uint32 flags,
+                             bool compress) OVERRIDE {}
   virtual void set_is_request() OVERRIDE;
   static std::string forward_ip_header() { return forward_ip_header_; }
   static void set_forward_ip_header(std::string value) {
@@ -80,16 +83,19 @@ class StreamerSM : public BalsaVisitorInterface,
   size_t SendSynStreamImpl(uint32 stream_id, const BalsaHeaders& headers) {
     return 0;
   }
-  void SendDataFrameImpl(uint32 stream_id, const char* data, int64 len,
-                         uint32 flags, bool compress) {}
+  void SendDataFrameImpl(uint32 stream_id,
+                         const char* data,
+                         int64 len,
+                         uint32 flags,
+                         bool compress) {}
   virtual void GetOutput() OVERRIDE {}
 
-  virtual void ProcessBodyInput(const char *input, size_t size) OVERRIDE;
+  virtual void ProcessBodyInput(const char* input, size_t size) OVERRIDE;
   virtual void MessageDone() OVERRIDE;
   virtual void ProcessHeaders(const BalsaHeaders& headers) OVERRIDE;
-  virtual void ProcessBodyData(const char *input, size_t size) OVERRIDE {}
-  virtual void ProcessHeaderInput(const char *input, size_t size) OVERRIDE {}
-  virtual void ProcessTrailerInput(const char *input, size_t size) OVERRIDE {}
+  virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE {}
+  virtual void ProcessHeaderInput(const char* input, size_t size) OVERRIDE {}
+  virtual void ProcessTrailerInput(const char* input, size_t size) OVERRIDE {}
   virtual void ProcessRequestFirstLine(const char* line_input,
                                        size_t line_length,
                                        const char* method_input,
@@ -98,17 +104,17 @@ class StreamerSM : public BalsaVisitorInterface,
                                        size_t request_uri_length,
                                        const char* version_input,
                                        size_t version_length) OVERRIDE {}
-  virtual void ProcessResponseFirstLine(const char *line_input,
+  virtual void ProcessResponseFirstLine(const char* line_input,
                                         size_t line_length,
-                                        const char *version_input,
+                                        const char* version_input,
                                         size_t version_length,
-                                        const char *status_input,
+                                        const char* status_input,
                                         size_t status_length,
-                                        const char *reason_input,
+                                        const char* reason_input,
                                         size_t reason_length) OVERRIDE {}
   virtual void ProcessChunkLength(size_t chunk_length) OVERRIDE {}
-  virtual void ProcessChunkExtensions(const char *input,
-                                      size_t size) OVERRIDE {}
+  virtual void ProcessChunkExtensions(const char* input, size_t size) OVERRIDE {
+  }
   virtual void HeaderDone() OVERRIDE {}
   virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE;
   virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE {}
@@ -128,5 +134,4 @@ class StreamerSM : public BalsaVisitorInterface,
 
 }  // namespace net
 
-#endif  // NET_TOOLS_FLIP_SERVER_STREAMER_INTERFACE_
-
+#endif  // NET_TOOLS_FLIP_SERVER_STREAMER_INTERFACE_H_