Switch to standard integer types in base/threading/.

base/threading/sequenced_worker_pool.cc

 // Copyright (c) 2012 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/threading/sequenced_worker_pool.h"
 
+#include <stdint.h>
+
 #include <list>
 #include <map>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/atomic_sequence_num.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/critical_closure.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/tracked_objects.h"
+#include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #elif defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #endif
 
 #if !defined(OS_NACL)
 #include "base/metrics/histogram.h"
 #endif
@@ skipping 13 matching lines @@
       : base::TrackingInfo(from_here, TimeTicks()),
         sequence_token_id(0),
         trace_id(0),
         sequence_task_number(0),
         shutdown_behavior(SequencedWorkerPool::BLOCK_SHUTDOWN) {}
 
   ~SequencedTask() {}
 
   int sequence_token_id;
   int trace_id;
-  int64 sequence_task_number;
+  int64_t sequence_task_number;
   SequencedWorkerPool::WorkerShutdown shutdown_behavior;
   tracked_objects::Location posted_from;
   Closure task;
 
   // Non-delayed tasks and delayed tasks are managed together by time-to-run
   // order. We calculate the time by adding the posted time and the given delay.
   TimeTicks time_to_run;
 };
 
 struct SequencedTaskLessThan {
@@ skipping 130 matching lines @@
     const Closure& task,
     TimeDelta delay) {
   // There's no way to run nested tasks, so simply forward to
   // PostDelayedTask.
   return PostDelayedTask(from_here, task, delay);
 }
 
 // Create a process-wide unique ID to represent this task in trace events. This
 // will be mangled with a Process ID hash to reduce the likelyhood of colliding
 // with MessageLoop pointers on other processes.
-uint64 GetTaskTraceID(const SequencedTask& task,
-                      void* pool) {
-  return (static_cast<uint64>(task.trace_id) << 32) |
-         static_cast<uint64>(reinterpret_cast<intptr_t>(pool));
+uint64_t GetTaskTraceID(const SequencedTask& task, void* pool) {
+  return (static_cast<uint64_t>(task.trace_id) << 32) |
+         static_cast<uint64_t>(reinterpret_cast<intptr_t>(pool));
 }
 
 }  // namespace
 
 // Worker ---------------------------------------------------------------------
 
 class SequencedWorkerPool::Worker : public SimpleThread {
  public:
   // Hold a (cyclic) ref to |worker_pool|, since we want to keep it
   // around as long as we are running.
@@ skipping 110 matching lines @@
     CLEANUP_RUNNING,
     CLEANUP_FINISHING,
     CLEANUP_DONE,
   };
 
   // Called from within the lock, this converts the given token name into a
   // token ID, creating a new one if necessary.
   int LockedGetNamedTokenID(const std::string& name);
 
   // Called from within the lock, this returns the next sequence task number.
-  int64 LockedGetNextSequenceTaskNumber();
+  int64_t LockedGetNextSequenceTaskNumber();
 
   // Gets new task. There are 3 cases depending on the return value:
   //
   // 1) If the return value is |GET_WORK_FOUND|, |task| is filled in and should
   //    be run immediately.
   // 2) If the return value is |GET_WORK_NOT_FOUND|, there are no tasks to run,
   //    and |task| is not filled in. In this case, the caller should wait until
   //    a task is posted.
   // 3) If the return value is |GET_WORK_WAIT|, there are no tasks to run
   //    immediately, and |task| is not filled in. Likewise, |wait_time| is
@@ skipping 95 matching lines @@
 
   // A set of all pending tasks in time-to-run order. These are tasks that are
   // either waiting for a thread to run on, waiting for their time to run,
   // or blocked on a previous task in their sequence. We have to iterate over
   // the tasks by time-to-run order, so we use the set instead of the
   // traditional priority_queue.
   typedef std::set<SequencedTask, SequencedTaskLessThan> PendingTaskSet;
   PendingTaskSet pending_tasks_;
 
   // The next sequence number for a new sequenced task.
-  int64 next_sequence_task_number_;
+  int64_t next_sequence_task_number_;
 
   // Number of tasks in the pending_tasks_ list that are marked as blocking
   // shutdown.
   size_t blocking_shutdown_pending_task_count_;
 
   // Lists all sequence tokens currently executing.
   std::set<int> current_sequences_;
 
   // An ID for each posted task to distinguish the task from others in traces.
   int trace_id_;
@@ skipping 457 matching lines @@
       named_sequence_tokens_.find(name);
   if (found != named_sequence_tokens_.end())
     return found->second;  // Got an existing one.
 
   // Create a new one for this name.
   SequenceToken result = GetSequenceToken();
   named_sequence_tokens_.insert(std::make_pair(name, result.id_));
   return result.id_;
 }
 
-int64 SequencedWorkerPool::Inner::LockedGetNextSequenceTaskNumber() {
+int64_t SequencedWorkerPool::Inner::LockedGetNextSequenceTaskNumber() {
   lock_.AssertAcquired();
   // We assume that we never create enough tasks to wrap around.
   return next_sequence_task_number_++;
 }
 
 SequencedWorkerPool::Inner::GetWorkStatus SequencedWorkerPool::Inner::GetWork(
     SequencedTask* task,
     TimeDelta* wait_time,
     std::vector<Closure>* delete_these_outside_lock) {
   lock_.AssertAcquired();
@@ skipping 376 matching lines @@
 void SequencedWorkerPool::Shutdown(int max_new_blocking_tasks_after_shutdown) {
   DCHECK(constructor_task_runner_->BelongsToCurrentThread());
   inner_->Shutdown(max_new_blocking_tasks_after_shutdown);
 }
 
 bool SequencedWorkerPool::IsShutdownInProgress() {
   return inner_->IsShutdownInProgress();
 }
 
 }  // namespace base