Use suffixed {uint,int}{8,16,32,64}_t types.

webrtc/base/taskrunner.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 46 matching lines @@
   // "ChildSet copy" in TaskParent::AbortAllChildren.
   // Subsequent use of those task may cause data corruption or crashes.  
   ASSERT(!abort_count_);
   // Running continues until all tasks are Blocked (ok for a small # of tasks)
   if (tasks_running_) {
     return;  // don't reenter
   }
 
   tasks_running_ = true;
 
-  int64 previous_timeout_time = next_task_timeout();
+  int64_t previous_timeout_time = next_task_timeout();
 
   int did_run = true;
   while (did_run) {
     did_run = false;
     // use indexing instead of iterators because tasks_ may grow
     for (size_t i = 0; i < tasks_.size(); ++i) {
       while (!tasks_[i]->Blocked()) {
         tasks_[i]->Step();
         did_run = true;
       }
@@ skipping 50 matching lines @@
   Task* old_timeout_task = NULL;
   while (next_timeout_task_ &&
       old_timeout_task != next_timeout_task_ &&
       next_timeout_task_->TimedOut()) {
     old_timeout_task = next_timeout_task_;
     next_timeout_task_->Wake();
     WakeTasks();
   }
 }
 
-int64 TaskRunner::next_task_timeout() const {
+int64_t TaskRunner::next_task_timeout() const {
   if (next_timeout_task_) {
     return next_timeout_task_->timeout_time();
   }
   return 0;
 }
 
 // this function gets called frequently -- when each task changes
 // state to something other than DONE, ERROR or BLOCKED, it calls
 // ResetTimeout(), which will call this function to make sure that
 // the next timeout-able task hasn't changed.  The logic in this function
 // prevents RecalcNextTimeout() from getting called in most cases,
 // effectively making the task scheduler O-1 instead of O-N
 
 void TaskRunner::UpdateTaskTimeout(Task* task,
-                                   int64 previous_task_timeout_time) {
+                                   int64_t previous_task_timeout_time) {
   ASSERT(task != NULL);
-  int64 previous_timeout_time = next_task_timeout();
+  int64_t previous_timeout_time = next_task_timeout();
   bool task_is_timeout_task = next_timeout_task_ != NULL &&
       task->unique_id() == next_timeout_task_->unique_id();
   if (task_is_timeout_task) {
     previous_timeout_time = previous_task_timeout_time;
   }
 
   // if the relevant task has a timeout, then
   // check to see if it's closer than the current
   // "about to timeout" task
   if (task->timeout_time()) {
@@ skipping 17 matching lines @@
   }
 }
 
 void TaskRunner::RecalcNextTimeout(Task *exclude_task) {
   // walk through all the tasks looking for the one
   // which satisfies the following:
   //   it's not finished already
   //   we're not excluding it
   //   it has the closest timeout time
 
-  int64 next_timeout_time = 0;
+  int64_t next_timeout_time = 0;
   next_timeout_task_ = NULL;
 
   for (size_t i = 0; i < tasks_.size(); ++i) {
     Task *task = tasks_[i];
     // if the task isn't complete, and it actually has a timeout time
     if (!task->IsDone() && (task->timeout_time() > 0))
       // if it doesn't match our "exclude" task
       if (exclude_task == NULL ||
           exclude_task->unique_id() != task->unique_id())
         // if its timeout time is sooner than our current timeout time
         if (next_timeout_time == 0 ||
             task->timeout_time() <= next_timeout_time) {
           // set this task as our next-to-timeout
           next_timeout_time = task->timeout_time();
           next_timeout_task_ = task;
         }
   }
 }
 
-void TaskRunner::CheckForTimeoutChange(int64 previous_timeout_time) {
-  int64 next_timeout = next_task_timeout();
+void TaskRunner::CheckForTimeoutChange(int64_t previous_timeout_time) {
+  int64_t next_timeout = next_task_timeout();
   bool timeout_change = (previous_timeout_time == 0 && next_timeout != 0) ||
       next_timeout < previous_timeout_time ||
       (previous_timeout_time <= CurrentTime() &&
        previous_timeout_time != next_timeout);
   if (timeout_change) {
     OnTimeoutChange();
   }
 }
 
 } // namespace rtc