Clang format slam.

net/tools/epoll_server/epoll_server.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/tools/epoll_server/epoll_server.h"
 
 #include <unistd.h>  // For read, pipe, close and write.
 #include <stdlib.h>  // for abort
-#include <errno.h>    // for errno and strerror_r
+#include <errno.h>   // for errno and strerror_r
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/timer/timer.h"
 
 // Design notes: An efficient implementation of ready list has the following
 // desirable properties:
 //
@@ skipping 42 matching lines @@
  public:
   virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE {
     DCHECK(event->in_events == EPOLLIN);
     int data;
     int data_read = 1;
     // Read until the pipe is empty.
     while (data_read > 0) {
       data_read = read(fd, &data, sizeof(data));
     }
   }
-  virtual void OnShutdown(EpollServer *eps, int fd) OVERRIDE {}
+  virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE {}
   virtual void OnRegistration(EpollServer*, int, int) OVERRIDE {}
-  virtual void OnModification(int, int) OVERRIDE {}       // COV_NF_LINE
-  virtual void OnUnregistration(int, bool) OVERRIDE {}    // COV_NF_LINE
+  virtual void OnModification(int, int) OVERRIDE {}     // COV_NF_LINE
+  virtual void OnUnregistration(int, bool) OVERRIDE {}  // COV_NF_LINE
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
 EpollServer::EpollServer()
-  : epoll_fd_(epoll_create(1024)),
-    timeout_in_us_(0),
-    recorded_now_in_us_(0),
-    ready_list_size_(0),
-    wake_cb_(new ReadPipeCallback),
-    read_fd_(-1),
-    write_fd_(-1),
-    in_wait_for_events_and_execute_callbacks_(false),
-    in_shutdown_(false) {
+    : epoll_fd_(epoll_create(1024)),
+      timeout_in_us_(0),
+      recorded_now_in_us_(0),
+      ready_list_size_(0),
+      wake_cb_(new ReadPipeCallback),
+      read_fd_(-1),
+      write_fd_(-1),
+      in_wait_for_events_and_execute_callbacks_(false),
+      in_shutdown_(false) {
   // ensure that the epoll_fd_ is valid.
   CHECK_NE(epoll_fd_, -1);
   LIST_INIT(&ready_list_);
   LIST_INIT(&tmp_list_);
 
   int pipe_fds[2];
   if (pipe(pipe_fds) < 0) {
     // Unfortunately, it is impossible to test any such initialization in
     // a constructor (as virtual methods do not yet work).
     // This -could- be solved by moving initialization to an outside
@@ skipping 23 matching lines @@
     cb_iter = cb_map_.begin();
   }
 }
 
 void EpollServer::CleanupTimeToAlarmCBMap() {
   TimeToAlarmCBMap::iterator erase_it;
 
   // Call OnShutdown() on alarms. Note that the structure of the loop
   // is similar to the structure of loop in the function HandleAlarms()
   for (TimeToAlarmCBMap::iterator i = alarm_map_.begin();
-       i != alarm_map_.end();
-      ) {
+       i != alarm_map_.end();) {
     // Note that OnShutdown() can call UnregisterAlarm() on
     // other iterators. OnShutdown() should not call UnregisterAlarm()
     // on self because by definition the iterator is not valid any more.
     i->second->OnShutdown(this);
     erase_it = i;
     ++i;
     alarm_map_.erase(erase_it);
   }
 }
 
@@ skipping 61 matching lines @@
       AddFD(fd, event_mask);
     }
     fd_i->cb = cb;
     fd_i->event_mask = event_mask;
     fd_i->events_to_fake = 0;
   } else {
     AddFD(fd, event_mask);
     cb_map_.insert(CBAndEventMask(cb, event_mask, fd));
   }
 
-
   // set the FD to be non-blocking.
   SetNonblocking(fd);
 
   cb->OnRegistration(this, fd, event_mask);
 }
 
 int EpollServer::GetFlags(int fd) {
   return fcntl(fd, F_GETFL, 0);
 }
 
 void EpollServer::SetNonblocking(int fd) {
   int flags = GetFlags(fd);
   if (flags == -1) {
     int saved_errno = errno;
     char buf[kErrorBufferSize];
-    LOG(FATAL) << "Error " << saved_errno
-               << " doing fcntl(" << fd << ", F_GETFL, 0): "
+    LOG(FATAL) << "Error " << saved_errno << " doing fcntl(" << fd
+               << ", F_GETFL, 0): "
                << strerror_r(saved_errno, buf, sizeof(buf));
   }
   if (!(flags & O_NONBLOCK)) {
     int saved_flags = flags;
     flags = SetFlags(fd, flags | O_NONBLOCK);
     if (flags == -1) {
       // bad.
       int saved_errno = errno;
       char buf[kErrorBufferSize];
-      LOG(FATAL) << "Error " << saved_errno
-        << " doing fcntl(" << fd << ", F_SETFL, " << saved_flags << "): "
-        << strerror_r(saved_errno, buf, sizeof(buf));
+      LOG(FATAL) << "Error " << saved_errno << " doing fcntl(" << fd
+                 << ", F_SETFL, " << saved_flags
+                 << "): " << strerror_r(saved_errno, buf, sizeof(buf));
     }
   }
 }
 
 int EpollServer::epoll_wait_impl(int epfd,
                                  struct epoll_event* events,
                                  int max_events,
                                  int timeout_in_ms) {
   return epoll_wait(epfd, events, max_events, timeout_in_ms);
 }
@@ skipping 81 matching lines @@
   AddToReadyList(cb_and_mask);
 }
 
 class TrueFalseGuard {
  public:
   explicit TrueFalseGuard(bool* guarded_bool) : guarded_bool_(guarded_bool) {
     DCHECK(guarded_bool_ != NULL);
     DCHECK(*guarded_bool_ == false);
     *guarded_bool_ = true;
   }
-  ~TrueFalseGuard() {
-    *guarded_bool_ = false;
-  }
+  ~TrueFalseGuard() { *guarded_bool_ = false; }
+
  private:
   bool* guarded_bool_;
 };
 
 void EpollServer::WaitForEventsAndExecuteCallbacks() {
   if (in_wait_for_events_and_execute_callbacks_) {
-    LOG(DFATAL) <<
-      "Attempting to call WaitForEventsAndExecuteCallbacks"
-      " when an ancestor to the current function is already"
-      " WaitForEventsAndExecuteCallbacks!";
+    LOG(DFATAL) << "Attempting to call WaitForEventsAndExecuteCallbacks"
+                   " when an ancestor to the current function is already"
+                   " WaitForEventsAndExecuteCallbacks!";
     // The line below is actually tested, but in coverage mode,
     // we never see it.
     return;  // COV_NF_LINE
   }
   TrueFalseGuard recursion_guard(&in_wait_for_events_and_execute_callbacks_);
   if (alarm_map_.empty()) {
     // no alarms, this is business as usual.
-    WaitForEventsAndCallHandleEvents(timeout_in_us_,
-                                     events_,
-                                     events_size_);
+    WaitForEventsAndCallHandleEvents(timeout_in_us_, events_, events_size_);
     recorded_now_in_us_ = 0;
     return;
   }
 
   // store the 'now'. If we recomputed 'now' every iteration
   // down below, then we might never exit that loop-- any
   // long-running alarms might install other long-running
   // alarms, etc. By storing it here now, we ensure that
   // a more reasonable amount of work is done here.
-  int64 now_in_us  = NowInUsec();
+  int64 now_in_us = NowInUsec();
 
   // Get the first timeout from the alarm_map where it is
   // stored in absolute time.
-  int64 next_alarm_time_in_us =  alarm_map_.begin()->first;
+  int64 next_alarm_time_in_us = alarm_map_.begin()->first;
   VLOG(4) << "next_alarm_time = " << next_alarm_time_in_us
           << " now             = " << now_in_us
           << " timeout_in_us = " << timeout_in_us_;
 
   int64 wait_time_in_us;
   int64 alarm_timeout_in_us = next_alarm_time_in_us - now_in_us;
 
   // If the next alarm is sooner than the default timeout, or if there is no
   // timeout (timeout_in_us_ == -1), wake up when the alarm should fire.
   // Otherwise use the default timeout.
   if (alarm_timeout_in_us < timeout_in_us_ || timeout_in_us_ < 0) {
     wait_time_in_us = std::max(alarm_timeout_in_us, static_cast<int64>(0));
   } else {
     wait_time_in_us = timeout_in_us_;
   }
 
   VLOG(4) << "wait_time_in_us = " << wait_time_in_us;
 
   // wait for events.
 
-  WaitForEventsAndCallHandleEvents(wait_time_in_us,
-                                   events_,
-                                   events_size_);
+  WaitForEventsAndCallHandleEvents(wait_time_in_us, events_, events_size_);
   CallAndReregisterAlarmEvents();
   recorded_now_in_us_ = 0;
 }
 
 void EpollServer::SetFDReady(int fd, int events_to_fake) {
   FDToCBMap::iterator fd_i = cb_map_.find(CBAndEventMask(NULL, 0, fd));
   if (cb_map_.end() != fd_i && fd_i->cb != NULL) {
     // This const_cast is necessary for LIST_HEAD_INSERT to work. Declaring
     // entry mutable is insufficient because LIST_HEAD_INSERT assigns the
     // forward pointer of the list head to the current cb_and_mask, and the
@@ skipping 14 matching lines @@
 
 void EpollServer::SetFDNotReady(int fd) {
   FDToCBMap::iterator fd_i = cb_map_.find(CBAndEventMask(NULL, 0, fd));
   if (cb_map_.end() != fd_i) {
     RemoveFromReadyList(*fd_i);
   }
 }
 
 bool EpollServer::IsFDReady(int fd) const {
   FDToCBMap::const_iterator fd_i = cb_map_.find(CBAndEventMask(NULL, 0, fd));
-  return (cb_map_.end() != fd_i &&
-          fd_i->cb != NULL &&
+  return (cb_map_.end() != fd_i && fd_i->cb != NULL &&
           fd_i->entry.le_prev != NULL);
 }
 
 void EpollServer::VerifyReadyList() const {
   int count = 0;
   CBAndEventMask* cur = ready_list_.lh_first;
   for (; cur; cur = cur->entry.le_next) {
     ++count;
   }
   for (cur = tmp_list_.lh_first; cur; cur = cur->entry.le_next) {
@@ skipping 44 matching lines @@
 
 int64 EpollServer::ApproximateNowInUsec() const {
   if (recorded_now_in_us_ != 0) {
     return recorded_now_in_us_;
   }
   return this->NowInUsec();
 }
 
 std::string EpollServer::EventMaskToString(int event_mask) {
   std::string s;
-  if (event_mask & EPOLLIN) s += "EPOLLIN ";
-  if (event_mask & EPOLLPRI) s += "EPOLLPRI ";
-  if (event_mask & EPOLLOUT) s += "EPOLLOUT ";
-  if (event_mask & EPOLLRDNORM) s += "EPOLLRDNORM ";
-  if (event_mask & EPOLLRDBAND) s += "EPOLLRDBAND ";
-  if (event_mask & EPOLLWRNORM) s += "EPOLLWRNORM ";
-  if (event_mask & EPOLLWRBAND) s += "EPOLLWRBAND ";
-  if (event_mask & EPOLLMSG) s += "EPOLLMSG ";
-  if (event_mask & EPOLLERR) s += "EPOLLERR ";
-  if (event_mask & EPOLLHUP) s += "EPOLLHUP ";
-  if (event_mask & EPOLLONESHOT) s += "EPOLLONESHOT ";
-  if (event_mask & EPOLLET) s += "EPOLLET ";
+  if (event_mask & EPOLLIN)
+    s += "EPOLLIN ";
+  if (event_mask & EPOLLPRI)
+    s += "EPOLLPRI ";
+  if (event_mask & EPOLLOUT)
+    s += "EPOLLOUT ";
+  if (event_mask & EPOLLRDNORM)
+    s += "EPOLLRDNORM ";
+  if (event_mask & EPOLLRDBAND)
+    s += "EPOLLRDBAND ";
+  if (event_mask & EPOLLWRNORM)
+    s += "EPOLLWRNORM ";
+  if (event_mask & EPOLLWRBAND)
+    s += "EPOLLWRBAND ";
+  if (event_mask & EPOLLMSG)
+    s += "EPOLLMSG ";
+  if (event_mask & EPOLLERR)
+    s += "EPOLLERR ";
+  if (event_mask & EPOLLHUP)
+    s += "EPOLLHUP ";
+  if (event_mask & EPOLLONESHOT)
+    s += "EPOLLONESHOT ";
+  if (event_mask & EPOLLET)
+    s += "EPOLLET ";
   return s;
 }
 
 void EpollServer::LogStateOnCrash() {
   LOG(ERROR) << "----------------------Epoll Server---------------------------";
   LOG(ERROR) << "Epoll server " << this << " polling on fd " << epoll_fd_;
   LOG(ERROR) << "timeout_in_us_: " << timeout_in_us_;
 
   // Log sessions with alarms.
   LOG(ERROR) << alarm_map_.size() << " alarms registered.";
   for (TimeToAlarmCBMap::iterator it = alarm_map_.begin();
        it != alarm_map_.end();
        ++it) {
     const bool skipped =
-        alarms_reregistered_and_should_be_skipped_.find(it->second)
-        != alarms_reregistered_and_should_be_skipped_.end();
+        alarms_reregistered_and_should_be_skipped_.find(it->second) !=
+        alarms_reregistered_and_should_be_skipped_.end();
     LOG(ERROR) << "Alarm " << it->second << " registered at time " << it->first
                << " and should be skipped = " << skipped;
   }
 
   LOG(ERROR) << cb_map_.size() << " fd callbacks registered.";
-  for (FDToCBMap::iterator it = cb_map_.begin();
-       it != cb_map_.end();
-       ++it) {
+  for (FDToCBMap::iterator it = cb_map_.begin(); it != cb_map_.end(); ++it) {
     LOG(ERROR) << "fd: " << it->fd << " with mask " << it->event_mask
                << " registered with cb: " << it->cb;
   }
   LOG(ERROR) << "----------------------/Epoll Server--------------------------";
 }
 
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
 void EpollServer::DelFD(int fd) const {
   struct epoll_event ee;
   memset(&ee, 0, sizeof(ee));
 #ifdef EPOLL_SERVER_EVENT_TRACING
   event_recorder_.RecordFDMaskEvent(fd, 0, "DelFD");
 #endif
   if (epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, &ee)) {
@@ skipping 25 matching lines @@
 ////////////////////////////////////////
 
 void EpollServer::ModFD(int fd, int event_mask) const {
   struct epoll_event ee;
   memset(&ee, 0, sizeof(ee));
   ee.events = event_mask | EPOLLERR | EPOLLHUP;
   ee.data.fd = fd;
 #ifdef EPOLL_SERVER_EVENT_TRACING
   event_recorder_.RecordFDMaskEvent(fd, ee.events, "ModFD");
 #endif
-  VLOG(3) <<  "modifying fd= " << fd << " "
-          << EventMaskToString(ee.events);
+  VLOG(3) << "modifying fd= " << fd << " " << EventMaskToString(ee.events);
   if (epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, fd, &ee)) {
     int saved_errno = errno;
     char buf[kErrorBufferSize];
     LOG(FATAL) << "Epoll set modification error for fd " << fd << ": "
                << strerror_r(saved_errno, buf, sizeof(buf));
   }
 }
 
 ////////////////////////////////////////
 
 void EpollServer::ModifyFD(int fd, int remove_event, int add_event) {
   FDToCBMap::iterator fd_i = cb_map_.find(CBAndEventMask(NULL, 0, fd));
   if (cb_map_.end() == fd_i) {
     VLOG(2) << "Didn't find the fd " << fd << "in internal structures";
     return;
   }
 
   if (fd_i->cb != NULL) {
-    int & event_mask = fd_i->event_mask;
+    int& event_mask = fd_i->event_mask;
     VLOG(3) << "fd= " << fd
             << " event_mask before: " << EventMaskToString(event_mask);
     event_mask &= ~remove_event;
     event_mask |= add_event;
 
     VLOG(3) << " event_mask after: " << EventMaskToString(event_mask);
 
     ModFD(fd, event_mask);
 
     fd_i->cb->OnModification(fd, event_mask);
@@ skipping 13 matching lines @@
     // should set timeout_in_us to -1000 so we will
     // Wait(-1000/1000) == Wait(-1) == Wait forever.
     timeout_in_us = -1000;
   } else {
     // If timeout is specified, and the ready list is empty.
     if (timeout_in_us < 1000) {
       timeout_in_us = 1000;
     }
   }
   const int timeout_in_ms = timeout_in_us / 1000;
-  int nfds = epoll_wait_impl(epoll_fd_,
-                             events,
-                             events_size,
-                             timeout_in_ms);
+  int nfds = epoll_wait_impl(epoll_fd_, events, events_size, timeout_in_ms);
   VLOG(3) << "nfds=" << nfds;
 
 #ifdef EPOLL_SERVER_EVENT_TRACING
   event_recorder_.RecordEpollWaitEvent(timeout_in_ms, nfds);
 #endif
 
   // If you're wondering why the NowInUsec() is recorded here, the answer is
   // simple: If we did it before the epoll_wait_impl, then the max error for
   // the ApproximateNowInUs() call would be as large as the maximum length of
   // epoll_wait, which can be arbitrarily long. Since this would make
@@ skipping 32 matching lines @@
   if (tmp_list_.lh_first) {
     tmp_list_.lh_first->entry.le_prev = &tmp_list_.lh_first;
     EpollEvent event(0, false);
     while (tmp_list_.lh_first != NULL) {
       DCHECK_GT(ready_list_size_, 0);
       CBAndEventMask* cb_and_mask = tmp_list_.lh_first;
       RemoveFromReadyList(*cb_and_mask);
 
       event.out_ready_mask = 0;
       event.in_events =
-        cb_and_mask->events_asserted | cb_and_mask->events_to_fake;
+          cb_and_mask->events_asserted | cb_and_mask->events_to_fake;
       // TODO(fenix): get rid of the two separate fields in cb_and_mask.
       cb_and_mask->events_asserted = 0;
       cb_and_mask->events_to_fake = 0;
       {
         // OnEvent() may call UnRegister, so we set in_use, here. Any
         // UnRegister call will now simply set the cb to NULL instead of
         // invalidating the cb_and_mask object (by deleting the object in the
         // map to which cb_and_mask refers)
         TrueFalseGuard in_use_guard(&(cb_and_mask->in_use));
         cb_and_mask->cb->OnEvent(cb_and_mask->fd, &event);
@@ skipping 14 matching lines @@
 }
 
 void EpollServer::CallAndReregisterAlarmEvents() {
   int64 now_in_us = recorded_now_in_us_;
   DCHECK_NE(0, recorded_now_in_us_);
 
   TimeToAlarmCBMap::iterator erase_it;
 
   // execute alarms.
   for (TimeToAlarmCBMap::iterator i = alarm_map_.begin();
-       i != alarm_map_.end();
-      ) {
+       i != alarm_map_.end();) {
     if (i->first > now_in_us) {
       break;
     }
     AlarmCB* cb = i->second;
     // Execute the OnAlarm() only if we did not register
     // it in this loop itself.
     const bool added_in_this_round =
-        alarms_reregistered_and_should_be_skipped_.find(cb)
-        != alarms_reregistered_and_should_be_skipped_.end();
+        alarms_reregistered_and_should_be_skipped_.find(cb) !=
+        alarms_reregistered_and_should_be_skipped_.end();
     if (added_in_this_round) {
       ++i;
       continue;
     }
     all_alarms_.erase(cb);
     const int64 new_timeout_time_in_us = cb->OnAlarm();
 
     erase_it = i;
     ++i;
     alarm_map_.erase(erase_it);
 
     if (new_timeout_time_in_us > 0) {
       // We add to hash_set only if the new timeout is <= now_in_us.
       // if timeout is > now_in_us then we have no fear that this alarm
       // can be reexecuted in this loop, and hence we do not need to
       // worry about a recursive loop.
       DVLOG(3) << "Reregistering alarm "
-               << " " << cb
-               << " " << new_timeout_time_in_us
-               << " " << now_in_us;
+               << " " << cb << " " << new_timeout_time_in_us << " "
+               << now_in_us;
       if (new_timeout_time_in_us <= now_in_us) {
         alarms_reregistered_and_should_be_skipped_.insert(cb);
       }
       RegisterAlarm(new_timeout_time_in_us, cb);
     }
   }
   alarms_reregistered_and_should_be_skipped_.clear();
 }
 
 EpollAlarm::EpollAlarm() : eps_(NULL), registered_(false) {
@@ skipping 28 matching lines @@
 
 // If the alarm was registered, unregister it.
 void EpollAlarm::UnregisterIfRegistered() {
   if (!registered_) {
     return;
   }
   eps_->UnregisterAlarm(token_);
 }
 
 }  // namespace net