Switch to standard integer types in base/.

base/task/cancelable_task_tracker.cc

 // Copyright 2014 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 "base/task/cancelable_task_tracker.h"
 
+#include <stddef.h>
+
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/task_runner.h"
@@ skipping 68 matching lines @@
     const Closure& reply) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // We need a MessageLoop to run reply.
   DCHECK(base::ThreadTaskRunnerHandle::IsSet());
 
   // Owned by reply callback below.
   CancellationFlag* flag = new CancellationFlag();
 
   TaskId id = next_id_;
-  next_id_++;  // int64 is big enough that we ignore the potential overflow.
+  next_id_++;  // int64_t is big enough that we ignore the potential overflow.
 
   const Closure& untrack_closure =
       Bind(&CancelableTaskTracker::Untrack, weak_factory_.GetWeakPtr(), id);
   bool success =
       task_runner->PostTaskAndReply(from_here,
                                     Bind(&RunIfNotCanceled, flag, task),
                                     Bind(&RunIfNotCanceledThenUntrack,
                                          base::Owned(flag),
                                          reply,
                                          untrack_closure));
 
   if (!success)
     return kBadTaskId;
 
   Track(id, flag);
   return id;
 }
 
 CancelableTaskTracker::TaskId CancelableTaskTracker::NewTrackedTaskId(
     IsCanceledCallback* is_canceled_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(base::ThreadTaskRunnerHandle::IsSet());
 
   TaskId id = next_id_;
-  next_id_++;  // int64 is big enough that we ignore the potential overflow.
+  next_id_++;  // int64_t is big enough that we ignore the potential overflow.
 
   // Will be deleted by |untrack_and_delete_flag| after Untrack().
   CancellationFlag* flag = new CancellationFlag();
 
   Closure untrack_and_delete_flag = Bind(
       &RunAndDeleteFlag,
       Bind(&CancelableTaskTracker::Untrack, weak_factory_.GetWeakPtr(), id),
       flag);
 
   // Will always run |untrack_and_delete_flag| on current MessageLoop.
@@ skipping 48 matching lines @@
   DCHECK(success);
 }
 
 void CancelableTaskTracker::Untrack(TaskId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   size_t num = task_flags_.erase(id);
   DCHECK_EQ(1u, num);
 }
 
 }  // namespace base