Switch to standard integer types in gpu/.

gpu/command_buffer/client/query_tracker.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 "gpu/command_buffer/client/query_tracker.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "base/atomicops.h"
 #include "base/numerics/safe_conversions.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/mapped_memory.h"
 #include "gpu/command_buffer/common/time.h"
 
 namespace gpu {
 namespace gles2 {
 
 QuerySyncManager::Bucket::Bucket(QuerySync* sync_mem,
-                                 int32 shm_id,
+                                 int32_t shm_id,
                                  unsigned int shm_offset)
-    : syncs(sync_mem),
-      shm_id(shm_id),
-      base_shm_offset(shm_offset) {
-}
+    : syncs(sync_mem), shm_id(shm_id), base_shm_offset(shm_offset) {}
 
 QuerySyncManager::Bucket::~Bucket() = default;
 
 QuerySyncManager::QuerySyncManager(MappedMemoryManager* manager)
     : mapped_memory_(manager) {
   DCHECK(manager);
 }
 
 QuerySyncManager::~QuerySyncManager() {
   while (!buckets_.empty()) {
     mapped_memory_->Free(buckets_.front()->syncs);
     delete buckets_.front();
     buckets_.pop_front();
   }
 }
 
 bool QuerySyncManager::Alloc(QuerySyncManager::QueryInfo* info) {
   DCHECK(info);
   Bucket* bucket = nullptr;
   for (Bucket* bucket_candidate : buckets_) {
     // In C++11 STL this could be replaced with
     // if (!bucket_candidate->in_use_queries.all()) { ... }
     if (bucket_candidate->in_use_queries.count() != kSyncsPerBucket) {
       bucket = bucket_candidate;
       break;
     }
   }
   if (!bucket) {
-    int32 shm_id;
+    int32_t shm_id;
     unsigned int shm_offset;
     void* mem = mapped_memory_->Alloc(
         kSyncsPerBucket * sizeof(QuerySync), &shm_id, &shm_offset);
     if (!mem) {
       return false;
     }
     QuerySync* syncs = static_cast<QuerySync*>(mem);
     bucket = new Bucket(syncs, shm_id, shm_offset);
     buckets_.push_back(bucket);
   }
 
   size_t index_in_bucket = 0;
   for (size_t i = 0; i < kSyncsPerBucket; i++) {
     if (!bucket->in_use_queries[i]) {
       index_in_bucket = i;
       break;
     }
   }
 
-  uint32 shm_offset =
+  uint32_t shm_offset =
       bucket->base_shm_offset + index_in_bucket * sizeof(QuerySync);
   QuerySync* sync = bucket->syncs + index_in_bucket;
   *info = QueryInfo(bucket, bucket->shm_id, shm_offset, sync);
   info->sync->Reset();
   bucket->in_use_queries[index_in_bucket] = true;
   return true;
 }
 
 void QuerySyncManager::Free(const QuerySyncManager::QueryInfo& info) {
   DCHECK_NE(info.bucket->in_use_queries.count(), 0u);
@@ skipping 110 matching lines @@
         helper->Flush();
       } else {
         // Insert no-ops so that eventually the GPU process will see more work.
         helper->Noop(1);
       }
     }
   }
   return state_ == kComplete;
 }
 
-uint64 QueryTracker::Query::GetResult() const {
+uint64_t QueryTracker::Query::GetResult() const {
   DCHECK(state_ == kComplete || state_ == kUninitialized);
   return result_;
 }
 
 QueryTracker::QueryTracker(MappedMemoryManager* manager)
     : query_sync_manager_(manager),
       mapped_memory_(manager),
       disjoint_count_sync_shm_id_(-1),
       disjoint_count_sync_shm_offset_(0),
       disjoint_count_sync_(nullptr),
@@ skipping 166 matching lines @@
     if (local_disjoint_count_ != disjoint_count) {
       local_disjoint_count_ = disjoint_count;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace gles2
 }  // namespace gpu