Switch to standard integer types in net/.

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 <algorithm>
@@ skipping 343 matching lines @@
                                      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_t 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_t 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;
+  int64_t wait_time_in_us;
+  int64_t 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));
+    wait_time_in_us = std::max(alarm_timeout_in_us, static_cast<int64_t>(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_,
@@ skipping 42 matching lines @@
   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) {
     ++count;
   }
   CHECK_EQ(ready_list_size_, count) << "Ready list size does not match count";
 }
 
-void EpollServer::RegisterAlarm(int64 timeout_time_in_us, AlarmCB* ac) {
+void EpollServer::RegisterAlarm(int64_t timeout_time_in_us, AlarmCB* ac) {
   CHECK(ac);
   if (ContainsKey(all_alarms_, ac)) {
     LOG(FATAL) << "Alarm already exists " << ac;
   }
   VLOG(4) << "RegisteringAlarm at : " << timeout_time_in_us;
 
   TimeToAlarmCBMap::iterator alarm_iter =
       alarm_map_.insert(std::make_pair(timeout_time_in_us, ac));
 
   all_alarms_.insert(ac);
@@ skipping 15 matching lines @@
   // Omit the internal FD (read_fd_)
   return cb_map_.size() - 1;
 }
 
 void EpollServer::Wake() {
   char data = 'd';  // 'd' is for data.  It's good enough for me.
   int rv = write(write_fd_, &data, 1);
   DCHECK_EQ(rv, 1);
 }
 
-int64 EpollServer::NowInUsec() const {
+int64_t EpollServer::NowInUsec() const {
   return (base::Time::Now() - base::Time::UnixEpoch()).InMicroseconds();
 }
 
-int64 EpollServer::ApproximateNowInUsec() const {
+int64_t 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 ";
@@ skipping 111 matching lines @@
     event_mask |= add_event;
 
     VLOG(3) << " event_mask after: " << EventMaskToString(event_mask);
 
     ModFD(fd, event_mask);
 
     fd_i->cb->OnModification(fd, event_mask);
   }
 }
 
-void EpollServer::WaitForEventsAndCallHandleEvents(int64 timeout_in_us,
+void EpollServer::WaitForEventsAndCallHandleEvents(int64_t timeout_in_us,
                                                    struct epoll_event events[],
                                                    int events_size) {
   if (timeout_in_us == 0 || ready_list_.lh_first != NULL) {
     // If ready list is not empty, then don't sleep at all.
     timeout_in_us = 0;
   } else if (timeout_in_us < 0) {
     LOG(INFO) << "Negative epoll timeout: " << timeout_in_us
               << "us; epoll will wait forever for events.";
     // If timeout_in_us is < 0 we are supposed to Wait forever.  This means we
     // should set timeout_in_us to -1000 so we will
@@ skipping 83 matching lines @@
       } else if (event.out_ready_mask != 0) {
         cb_and_mask->events_to_fake = event.out_ready_mask;
         AddToReadyList(cb_and_mask);
       }
     }
   }
   DCHECK(tmp_list_.lh_first == NULL);
 }
 
 void EpollServer::CallAndReregisterAlarmEvents() {
-  int64 now_in_us = recorded_now_in_us_;
+  int64_t 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();
       ) {
     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();
     if (added_in_this_round) {
       ++i;
       continue;
     }
     all_alarms_.erase(cb);
-    const int64 new_timeout_time_in_us = cb->OnAlarm();
+    const int64_t 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.
@@ skipping 10 matching lines @@
   alarms_reregistered_and_should_be_skipped_.clear();
 }
 
 EpollAlarm::EpollAlarm() : eps_(NULL), registered_(false) {
 }
 
 EpollAlarm::~EpollAlarm() {
   UnregisterIfRegistered();
 }
 
-int64 EpollAlarm::OnAlarm() {
+int64_t EpollAlarm::OnAlarm() {
   registered_ = false;
   return 0;
 }
 
 void EpollAlarm::OnRegistration(const EpollServer::AlarmRegToken& token,
                                 EpollServer* eps) {
   DCHECK_EQ(false, registered_);
 
   token_ = token;
   eps_ = eps;
@@ skipping 11 matching lines @@
 
 // If the alarm was registered, unregister it.
 void EpollAlarm::UnregisterIfRegistered() {
   if (!registered_) {
     return;
   }
   eps_->UnregisterAlarm(token_);
 }
 
 }  // namespace net