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

webrtc/base/task.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.
  */
 
 #include "webrtc/base/task.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/taskrunner.h"
 
 namespace rtc {
 
-int32 Task::unique_id_seed_ = 0;
+int32_t Task::unique_id_seed_ = 0;
 
 Task::Task(TaskParent *parent)
     : TaskParent(this, parent),
       state_(STATE_INIT),
       blocked_(false),
       done_(false),
       aborted_(false),
       busy_(false),
       error_(false),
       start_time_(0),
@@ skipping 13 matching lines @@
   ASSERT(state_ == STATE_INIT || blocked_);
 
   // If the task is being deleted without being done, it
   // means that it hasn't been removed from its parent.
   // This happens if a task is deleted outside of TaskRunner.
   if (!done_) {
     Stop();
   }
 }
 
-int64 Task::CurrentTime() {
+int64_t Task::CurrentTime() {
   return GetRunner()->CurrentTime();
 }
 
-int64 Task::ElapsedTime() {
+int64_t Task::ElapsedTime() {
   return CurrentTime() - start_time_;
 }
 
 void Task::Start() {
   if (state_ != STATE_INIT)
     return;
   // Set the start time before starting the task.  Otherwise if the task
   // finishes quickly and deletes the Task object, setting start_time_
   // will crash.
   start_time_ = CurrentTime();
@@ skipping 167 matching lines @@
   ResetTimeout();
 }
 
 bool Task::TimedOut() {
   return timeout_seconds_ &&
     timeout_time_ &&
     CurrentTime() >= timeout_time_;
 }
 
 void Task::ResetTimeout() {
-  int64 previous_timeout_time = timeout_time_;
+  int64_t previous_timeout_time = timeout_time_;
   bool timeout_allowed = (state_ != STATE_INIT)
                       && (state_ != STATE_DONE)
                       && (state_ != STATE_ERROR);
   if (timeout_seconds_ && timeout_allowed && !timeout_suspended_)
     timeout_time_ = CurrentTime() +
                     (timeout_seconds_ * kSecToMsec * kMsecTo100ns);
   else
     timeout_time_ = 0;
 
   GetRunner()->UpdateTaskTimeout(this, previous_timeout_time);
 }
 
 void Task::ClearTimeout() {
-  int64 previous_timeout_time = timeout_time_;
+  int64_t previous_timeout_time = timeout_time_;
   timeout_time_ = 0;
   GetRunner()->UpdateTaskTimeout(this, previous_timeout_time);
 }
 
 void Task::SuspendTimeout() {
   if (!timeout_suspended_) {
     timeout_suspended_ = true;
     ResetTimeout();
   }
 }
 
 void Task::ResumeTimeout() {
   if (timeout_suspended_) {
     timeout_suspended_ = false;
     ResetTimeout();
   }
 }
 
 int Task::OnTimeout() {
   // by default, we are finished after timing out
   return STATE_DONE;
 }
 
 } // namespace rtc