Clang format slam.

net/tools/epoll_server/epoll_server.h

 // 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.
 
 #ifndef NET_TOOLS_EPOLL_SERVER_EPOLL_SERVER_H_
 #define NET_TOOLS_EPOLL_SERVER_EPOLL_SERVER_H_
 
 #include <fcntl.h>
 #include <sys/queue.h>
 #include <map>
@@ skipping 28 matching lines @@
 #include <sys/epoll.h>
 
 namespace net {
 
 class EpollServer;
 class EpollAlarmCallbackInterface;
 class ReadPipeCallback;
 
 struct EpollEvent {
   EpollEvent(int events, bool is_epoll_wait)
-      : in_events(events),
-        out_ready_mask(0) {
-  }
+      : in_events(events), out_ready_mask(0) {}
 
-  int in_events;            // incoming events
-  int out_ready_mask;       // the new event mask for ready list (0 means don't
-                            // get on the ready list). This field is always
-                            // initialized to 0 when the event is passed to
-                            // OnEvent.
+  int in_events;       // incoming events
+  int out_ready_mask;  // the new event mask for ready list (0 means don't
+                       // get on the ready list). This field is always
+                       // initialized to 0 when the event is passed to
+                       // OnEvent.
 };
 
 // Callbacks which go into EpollServers are expected to derive from this class.
 class EpollCallbackInterface {
  public:
   // Summary:
   //   Called when the callback is registered into a EpollServer.
   // Args:
   //   eps - the poll server into which this callback was registered
   //   fd - the file descriptor which was registered
@@ skipping 446 matching lines @@
         : cb(NULL),
           fd(-1),
           event_mask(0),
           events_asserted(0),
           events_to_fake(0),
           in_use(false) {
       entry.le_next = NULL;
       entry.le_prev = NULL;
     }
 
-    CBAndEventMask(EpollCallbackInterface* cb,
-                   int event_mask,
-                   int fd)
-        : cb(cb), fd(fd), event_mask(event_mask), events_asserted(0),
-          events_to_fake(0), in_use(false) {
+    CBAndEventMask(EpollCallbackInterface* cb, int event_mask, int fd)
+        : cb(cb),
+          fd(fd),
+          event_mask(event_mask),
+          events_asserted(0),
+          events_to_fake(0),
+          in_use(false) {
       entry.le_next = NULL;
       entry.le_prev = NULL;
     }
 
     // Required operator for hash_set. Normally operator== should be a free
     // standing function. However, since CBAndEventMask is a protected type and
     // it will never be a base class, it makes no difference.
     bool operator==(const CBAndEventMask& cb_and_mask) const {
       return fd == cb_and_mask.fd;
     }
@@ skipping 91 matching lines @@
   //   Waits for events, and calls HandleEvents() for each
   //   fd, event pair discovered to possibly have an event.
   //   Note that a callback (B) may get a spurious event if
   //   another callback (A) has closed a file-descriptor N, and
   //   the callback (B) has a newly opened file-descriptor, which
   //   also happens to be N.
   virtual void WaitForEventsAndCallHandleEvents(int64 timeout_in_us,
                                                 struct epoll_event events[],
                                                 int events_size);
 
-
-
   // Summary:
   //   An internal function for implementing the ready list. It adds a fd's
   //   CBAndEventMask to the ready list. If the fd is already on the ready
   //   list, it is a no-op.
   void AddToReadyList(CBAndEventMask* cb_and_mask);
 
   // Summary:
   //   An internal function for implementing the ready list. It remove a fd's
   //   CBAndEventMask from the ready list. If the fd is not on the ready list,
   //   it is a no-op.
   void RemoveFromReadyList(const CBAndEventMask& cb_and_mask);
 
   // Summary:
   // Calls any pending alarms that should go off and reregisters them if they
   // were recurring.
   virtual void CallAndReregisterAlarmEvents();
 
   // The file-descriptor created for epolling
   int epoll_fd_;
 
   // The mapping of file-descriptor to CBAndEventMasks
   FDToCBMap cb_map_;
 
   // Custom hash function to be used by hash_set.
   struct AlarmCBHash {
-    size_t operator()(AlarmCB*const& p) const {
+    size_t operator()(AlarmCB* const& p) const {
       return reinterpret_cast<size_t>(p);
     }
   };
 
-
   // TOOD(sushantj): Having this hash_set is avoidable. We currently have it
   // only so that we can enforce stringent checks that a caller can not register
   // the same alarm twice. One option is to have an implementation in which
   // this hash_set is used only in the debug mode.
   typedef base::hash_set<AlarmCB*, AlarmCBHash> AlarmCBMap;
   AlarmCBMap all_alarms_;
 
   TimeToAlarmCBMap alarm_map_;
 
   // The amount of time in microseconds that we'll wait before returning
@@ skipping 24 matching lines @@
   int ready_list_size_;
   // TODO(alyssar): make this into something that scales up.
   static const int events_size_ = 256;
   struct epoll_event events_[256];
 
 #ifdef EPOLL_SERVER_EVENT_TRACING
   struct EventRecorder {
    public:
     EventRecorder() : num_records_(0), record_threshold_(10000) {}
 
-    ~EventRecorder() {
-      Clear();
-    }
+    ~EventRecorder() { Clear(); }
 
     // When a number of events equals the record threshold,
     // the collected data summary for all FDs will be written
     // to LOG(INFO). Note that this does not include the
     // individual events (if you'reinterested in those, you'll
     // have to get at them programmatically).
     // After any such flushing to LOG(INFO) all events will
     // be cleared.
     // Note that the definition of an 'event' is a bit 'hazy',
     // as it includes the 'Unregistration' event, and perhaps
     // others.
     void set_record_threshold(int64 new_threshold) {
       record_threshold_ = new_threshold;
     }
 
     void Clear() {
       for (int i = 0; i < debug_events_.size(); ++i) {
         delete debug_events_[i];
       }
       debug_events_.clear();
       unregistered_fds_.clear();
       event_counts_.clear();
     }
 
     void MaybeRecordAndClear() {
       ++num_records_;
-      if ((num_records_ > record_threshold_) &&
-          (record_threshold_ > 0)) {
+      if ((num_records_ > record_threshold_) && (record_threshold_ > 0)) {
         LOG(INFO) << "\n" << *this;
         num_records_ = 0;
         Clear();
       }
     }
 
     void RecordFDMaskEvent(int fd, int mask, const char* function) {
       FDMaskOutput* fdmo = new FDMaskOutput(fd, mask, function);
       debug_events_.push_back(fdmo);
       MaybeRecordAndClear();
     }
 
-    void RecordEpollWaitEvent(int timeout_in_ms,
-                              int num_events_generated) {
-      EpollWaitOutput* ewo = new EpollWaitOutput(timeout_in_ms,
-                                                  num_events_generated);
+    void RecordEpollWaitEvent(int timeout_in_ms, int num_events_generated) {
+      EpollWaitOutput* ewo =
+          new EpollWaitOutput(timeout_in_ms, num_events_generated);
       debug_events_.push_back(ewo);
       MaybeRecordAndClear();
     }
 
     void RecordEpollEvent(int fd, int event_mask) {
       Events& events_for_fd = event_counts_[fd];
       events_for_fd.AssignFromMask(event_mask);
       MaybeRecordAndClear();
     }
 
@@ skipping 29 matching lines @@
       friend ostream& operator<<(ostream& os, const DebugOutput& debug_output) {
         debug_output.OutputToStream(os);
         return os;
       }
       virtual void OutputToStream(ostream* os) const = 0;
       virtual ~DebugOutput() {}
     };
 
     class FDMaskOutput : public DebugOutput {
      public:
-      FDMaskOutput(int fd, int mask, const char* function) :
-          fd_(fd), mask_(mask), function_(function) {}
+      FDMaskOutput(int fd, int mask, const char* function)
+          : fd_(fd), mask_(mask), function_(function) {}
       virtual void OutputToStream(ostream* os) const {
-        (*os) << "func: " << function_
-              << "\tfd: " << fd_;
+        (*os) << "func: " << function_ << "\tfd: " << fd_;
         if (mask_ != 0) {
-           (*os) << "\tmask: " << EventMaskToString(mask_);
+          (*os) << "\tmask: " << EventMaskToString(mask_);
         }
       }
       int fd_;
       int mask_;
       const char* function_;
     };
 
     class EpollWaitOutput : public DebugOutput {
      public:
-      EpollWaitOutput(int timeout_in_ms,
-                      int num_events_generated) :
-          timeout_in_ms_(timeout_in_ms),
-          num_events_generated_(num_events_generated) {}
+      EpollWaitOutput(int timeout_in_ms, int num_events_generated)
+          : timeout_in_ms_(timeout_in_ms),
+            num_events_generated_(num_events_generated) {}
       virtual void OutputToStream(ostream* os) const {
         (*os) << "timeout_in_ms: " << timeout_in_ms_
               << "\tnum_events_generated: " << num_events_generated_;
       }
+
      protected:
       int timeout_in_ms_;
       int num_events_generated_;
     };
 
     struct Events {
-      Events() :
-          epoll_in(0),
-          epoll_pri(0),
-          epoll_out(0),
-          epoll_rdnorm(0),
-          epoll_rdband(0),
-          epoll_wrnorm(0),
-          epoll_wrband(0),
-          epoll_msg(0),
-          epoll_err(0),
-          epoll_hup(0),
-          epoll_oneshot(0),
-          epoll_et(0) {}
+      Events()
+          : epoll_in(0),
+            epoll_pri(0),
+            epoll_out(0),
+            epoll_rdnorm(0),
+            epoll_rdband(0),
+            epoll_wrnorm(0),
+            epoll_wrband(0),
+            epoll_msg(0),
+            epoll_err(0),
+            epoll_hup(0),
+            epoll_oneshot(0),
+            epoll_et(0) {}
 
       void AssignFromMask(int event_mask) {
-        if (event_mask & EPOLLIN) ++epoll_in;
-        if (event_mask & EPOLLPRI) ++epoll_pri;
-        if (event_mask & EPOLLOUT) ++epoll_out;
-        if (event_mask & EPOLLRDNORM) ++epoll_rdnorm;
-        if (event_mask & EPOLLRDBAND) ++epoll_rdband;
-        if (event_mask & EPOLLWRNORM) ++epoll_wrnorm;
-        if (event_mask & EPOLLWRBAND) ++epoll_wrband;
-        if (event_mask & EPOLLMSG) ++epoll_msg;
-        if (event_mask & EPOLLERR) ++epoll_err;
-        if (event_mask & EPOLLHUP) ++epoll_hup;
-        if (event_mask & EPOLLONESHOT) ++epoll_oneshot;
-        if (event_mask & EPOLLET) ++epoll_et;
+        if (event_mask & EPOLLIN)
+          ++epoll_in;
+        if (event_mask & EPOLLPRI)
+          ++epoll_pri;
+        if (event_mask & EPOLLOUT)
+          ++epoll_out;
+        if (event_mask & EPOLLRDNORM)
+          ++epoll_rdnorm;
+        if (event_mask & EPOLLRDBAND)
+          ++epoll_rdband;
+        if (event_mask & EPOLLWRNORM)
+          ++epoll_wrnorm;
+        if (event_mask & EPOLLWRBAND)
+          ++epoll_wrband;
+        if (event_mask & EPOLLMSG)
+          ++epoll_msg;
+        if (event_mask & EPOLLERR)
+          ++epoll_err;
+        if (event_mask & EPOLLHUP)
+          ++epoll_hup;
+        if (event_mask & EPOLLONESHOT)
+          ++epoll_oneshot;
+        if (event_mask & EPOLLET)
+          ++epoll_et;
       };
 
       friend ostream& operator<<(ostream& os, const Events& ev) {
         if (ev.epoll_in) {
           os << "\t      EPOLLIN: " << ev.epoll_in << "\n";
         }
         if (ev.epoll_pri) {
           os << "\t     EPOLLPRI: " << ev.epoll_pri << "\n";
         }
         if (ev.epoll_out) {
@@ skipping 44 matching lines @@
     };
 
     std::vector<DebugOutput*> debug_events_;
     std::vector<Events> unregistered_fds_;
     typedef base::hash_map<int, Events> EventCountsMap;
     EventCountsMap event_counts_;
     int64 num_records_;
     int64 record_threshold_;
   };
 
-  void ClearEventRecords() {
-    event_recorder_.Clear();
-  }
-  void WriteEventRecords(ostream* os) const {
-    (*os) << event_recorder_;
-  }
+  void ClearEventRecords() { event_recorder_.Clear(); }
+  void WriteEventRecords(ostream* os) const { (*os) << event_recorder_; }
 
   mutable EventRecorder event_recorder_;
 
 #endif
 
  private:
   // Helper functions used in the destructor.
   void CleanupFDToCBMap();
   void CleanupTimeToAlarmCBMap();
 
@@ skipping 94 matching lines @@
 
  private:
   EpollServer::AlarmRegToken token_;
   EpollServer* eps_;
   bool registered_;
 };
 
 }  // namespace net
 
 #endif  // NET_TOOLS_EPOLL_SERVER_EPOLL_SERVER_H_