Switch to standard integer types in net/.

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 <stddef.h>
+#include <stdint.h>
 #include <sys/queue.h>
+
 #include <map>
 #include <string>
 #include <vector>
 
 // #define EPOLL_SERVER_EVENT_TRACING 1
 //
 // Defining EPOLL_SERVER_EVENT_TRACING
 // causes code to exist which didn't before.
 // This code tracks each event generated by the epollserver,
 // as well as providing a per-fd-registered summary of
 // events. Note that enabling this code vastly slows
 // down operations, and uses substantially more
 // memory. For these reasons, it should only be enabled by developers doing
 // development at their workstations.
 //
 // A structure called 'EventRecorder' will exist when
 // the macro is defined. See the EventRecorder class interface
 // within the EpollServer class for more details.
 #ifdef EPOLL_SERVER_EVENT_TRACING
 #include <ostream>
 #include "base/logging.h"
 #endif
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include <sys/epoll.h>
 
 namespace net {
 
 class EpollServer;
 class EpollAlarmCallbackInterface;
 class ReadPipeCallback;
 
 struct EpollEvent {
@@ skipping 67 matching lines @@
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
 class EpollServer {
  public:
   typedef EpollAlarmCallbackInterface AlarmCB;
   typedef EpollCallbackInterface CB;
 
-  typedef std::multimap<int64, AlarmCB*> TimeToAlarmCBMap;
+  typedef std::multimap<int64_t, AlarmCB*> TimeToAlarmCBMap;
   typedef TimeToAlarmCBMap::iterator AlarmRegToken;
 
   // Summary:
   //   Constructor:
   //    By default, we don't wait any amount of time for events, and
   //    we suggest to the epoll-system that we're going to use on-the-order
   //    of 1024 FDs.
   EpollServer();
 
   ////////////////////////////////////////
@@ skipping 218 matching lines @@
   //   If the callback returns a positive number from its OnAlarm() function,
   //   then the callback will be re-registered at that time, else the alarm
   //   owner is responsible for freeing up memory.
   //
   //   Important: A give AlarmCB* can not be registered again if it is already
   //    registered. If a user wants to register a callback again it should first
   //    unregister the previous callback before calling RegisterAlarm again.
   // Args:
   //   timeout_time_in_us - the absolute time at which the alarm should go off
   //   ac - the alarm which will be called.
-  virtual void RegisterAlarm(int64 timeout_time_in_us, AlarmCB* ac);
+  virtual void RegisterAlarm(int64_t timeout_time_in_us, AlarmCB* ac);
 
   // Summary:
   //   Registers an alarm 'ac' to go off at time: (ApproximateNowInUs() +
   //   delta_in_us). While this is somewhat less accurate (see the description
   //   for ApproximateNowInUs() to see how 'approximate'), the error is never
   //   worse than the amount of time it takes to process all events in one
   //   WaitForEvents.  As with 'RegisterAlarm()', if the callback returns a
   //   positive number from its OnAlarm() function, then the callback will be
   //   re-registered at that time, else the alarm owner is responsible for
   //   freeing up memory.
   //   Note that this function is purely a convienence. The
   //   same thing may be accomplished by using RegisterAlarm with
   //   ApproximateNowInUs() directly.
   //
   //   Important: A give AlarmCB* can not be registered again if it is already
   //    registered. If a user wants to register a callback again it should first
   //    unregister the previous callback before calling RegisterAlarm again.
   // Args:
   //   delta_in_us - the delta in microseconds from the ApproximateTimeInUs() at
   //                 which point the alarm should go off.
   //   ac - the alarm which will be called.
-  void RegisterAlarmApproximateDelta(int64 delta_in_us, AlarmCB* ac) {
+  void RegisterAlarmApproximateDelta(int64_t delta_in_us, AlarmCB* ac) {
     RegisterAlarm(ApproximateNowInUsec() + delta_in_us, ac);
   }
 
   ////////////////////////////////////////
 
   // Summary:
   //   Unregister  the alarm referred to by iterator_token; Callers should
   //   be warned that a token may have become already invalid when OnAlarm()
   //   is called, was unregistered, or OnShutdown was called on that alarm.
   // Args:
@@ skipping 12 matching lines @@
   // Summary:
   //   Force the epoll server to wake up (by writing to an internal pipe).
   virtual void Wake();
 
   // Summary:
   //   Wrapper around WallTimer's NowInUsec.  We do this so that we can test
   //   EpollServer without using the system clock (and can avoid the flakiness
   //   that would ensue)
   // Returns:
   //   the current time as number of microseconds since the Unix epoch.
-  virtual int64 NowInUsec() const;
+  virtual int64_t NowInUsec() const;
 
   // Summary:
   //   Since calling NowInUsec() many thousands of times per
   //   WaitForEventsAndExecuteCallbacks function call is, to say the least,
   //   inefficient, we allow users to use an approximate time instead. The
   //   time returned from this function is as accurate as NowInUsec() when
   //   WaitForEventsAndExecuteCallbacks is not an ancestor of the caller's
   //   callstack.
   //   However, when WaitForEventsAndExecuteCallbacks -is- an ancestor, then
   //   this function returns the time at which the
   //   WaitForEventsAndExecuteCallbacks function started to process events or
   //   alarms.
   //
   //   Essentially, this function makes available a fast and mostly accurate
   //   mechanism for getting the time for any function handling an event or
   //   alarm. When functions which are not handling callbacks or alarms call
   //   this function, they get the slow and "absolutely" accurate time.
   //
   //   Users should be encouraged to use this function.
   // Returns:
   //   the "approximate" current time as number of microseconds since the Unix
   //   epoch.
-  virtual int64 ApproximateNowInUsec() const;
+  virtual int64_t ApproximateNowInUsec() const;
 
   static std::string EventMaskToString(int event_mask);
 
   // Summary:
   //   Logs the state of the epoll server with LOG(ERROR).
   void LogStateOnCrash();
 
   // Summary:
   //   Set the timeout to the value specified.
   //   If the timeout is set to a negative number,
   //      WaitForEventsAndExecuteCallbacks() will only return when an event has
   //      occured
   //   If the timeout is set to zero,
   //      WaitForEventsAndExecuteCallbacks() will return immediately
   //   If the timeout is set to a positive number,
   //      WaitForEventsAndExecuteCallbacks() will return when an event has
   //      occured, or when timeout_in_us microseconds has elapsed, whichever
   //      is first.
   //  Args:
   //    timeout_in_us - value specified depending on behaviour desired.
   //                    See above.
-  void set_timeout_in_us(int64 timeout_in_us) {
+  void set_timeout_in_us(int64_t timeout_in_us) {
     timeout_in_us_ = timeout_in_us;
   }
 
   ////////////////////////////////////////
 
   // Summary:
   //   Accessor for the current value of timeout_in_us.
   int timeout_in_us() const { return timeout_in_us_; }
 
   // Summary:
@@ skipping 142 matching lines @@
 
   ////////////////////////////////////////
 
   // Summary:
   //   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,
+  virtual void WaitForEventsAndCallHandleEvents(int64_t 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.
@@ skipping 25 matching lines @@
   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
   // from the WaitForEventsAndExecuteCallbacks() function.
   // If this is positive, wait that many microseconds.
   // If this is negative, wait forever, or for the first event that occurs
   // If this is zero, never wait for an event.
-  int64 timeout_in_us_;
+  int64_t timeout_in_us_;
 
   // This is nonzero only after the invocation of epoll_wait_impl within
   // WaitForEventsAndCallHandleEvents and before the function
   // WaitForEventsAndExecuteCallbacks returns.  At all other times, this is
   // zero. This enables us to have relatively accurate time returned from the
   // ApproximateNowInUs() function. See that function for more details.
-  int64 recorded_now_in_us_;
+  int64_t recorded_now_in_us_;
 
   // This is used to implement CallAndReregisterAlarmEvents. This stores
   // all alarms that were reregistered because OnAlarm() returned a
   // value > 0 and the time at which they should be executed is less that
   // the current time.  By storing such alarms in this map we ensure
   // that while calling CallAndReregisterAlarmEvents we do not call
   // OnAlarm on any alarm in this set. This ensures that we do not
   // go in an infinite loop.
   AlarmCBMap alarms_reregistered_and_should_be_skipped_;
 
@@ skipping 16 matching lines @@
     // 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) {
+    void set_record_threshold(int64_t 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();
@@ skipping 178 matching lines @@
       unsigned int epoll_err;
       unsigned int epoll_hup;
       unsigned int epoll_oneshot;
       unsigned int epoll_et;
     };
 
     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_;
+    int64_t num_records_;
+    int64_t record_threshold_;
   };
 
   void ClearEventRecords() {
     event_recorder_.Clear();
   }
   void WriteEventRecords(ostream* os) const {
     (*os) << event_recorder_;
   }
 
   mutable EventRecorder event_recorder_;
@@ skipping 30 matching lines @@
 
 class EpollAlarmCallbackInterface {
  public:
   // Summary:
   //   Called when an alarm times out. Invalidates an AlarmRegToken.
   //   WARNING: If a token was saved to refer to an alarm callback, OnAlarm must
   //   delete it, as the reference is no longer valid.
   // Returns:
   //   the unix time (in microseconds) at which this alarm should be signaled
   //   again, or 0 if the alarm should be removed.
-  virtual int64 OnAlarm() = 0;
+  virtual int64_t OnAlarm() = 0;
 
   // Summary:
   //   Called when the an alarm is registered. Invalidates an AlarmRegToken.
   // Args:
   //   token: the iterator to the the alarm registered in the alarm map.
   //   WARNING: this token becomes invalid when the alarm fires, is
   //   unregistered, or OnShutdown is called on that alarm.
   //   eps: the epoll server the alarm is registered with.
   virtual void OnRegistration(const EpollServer::AlarmRegToken& token,
                               EpollServer* eps) = 0;
@@ skipping 23 matching lines @@
 // of the parent class, or is must otherwise make sure that the 'registered_'
 // boolean and the token, 'token_', are updated appropriately.
 class EpollAlarm : public EpollAlarmCallbackInterface {
  public:
   EpollAlarm();
 
   ~EpollAlarm() override;
 
   // Marks the alarm as unregistered and returns 0.  The return value may be
   // safely ignored by subclasses.
-  int64 OnAlarm() override;
+  int64_t OnAlarm() override;
 
   // Marks the alarm as registered, and stores the token.
   void OnRegistration(const EpollServer::AlarmRegToken& token,
                       EpollServer* eps) override;
 
   // Marks the alarm as unregistered.
   void OnUnregistration() override;
 
   // Marks the alarm as unregistered.
   void OnShutdown(EpollServer* eps) override;
 
   // If the alarm was registered, unregister it.
   void UnregisterIfRegistered();
 
   bool registered() const { return registered_; }
 
   const EpollServer* eps() const { return eps_; }
 
  private:
   EpollServer::AlarmRegToken token_;
   EpollServer* eps_;
   bool registered_;
 };
 
 }  // namespace net
 
 #endif  // NET_TOOLS_EPOLL_SERVER_EPOLL_SERVER_H_