Switch to standard integer types in gpu/.

gpu/command_buffer/service/gpu_scheduler.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/service/gpu_scheduler.h"
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/service/logger.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_switches.h"
@@ skipping 43 matching lines @@
     error = parser_->ProcessCommands(CommandParser::kParseCommandsSlice);
 
     if (error == error::kDeferCommandUntilLater) {
       DCHECK(!scheduled());
       break;
     }
 
     // TODO(piman): various classes duplicate various pieces of state, leading
     // to needlessly complex update logic. It should be possible to simply
     // share the state across all of them.
-    command_buffer_->SetGetOffset(static_cast<int32>(parser_->get()));
+    command_buffer_->SetGetOffset(static_cast<int32_t>(parser_->get()));
 
     if (error::IsError(error)) {
       command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
       command_buffer_->SetParseError(error);
       break;
     }
 
     if (!command_processed_callback_.is_null())
       command_processed_callback_.Run();
 
@@ skipping 29 matching lines @@
   if (!decoder_)
     return;
   decoder_->ProcessPendingQueries(false);
 }
 
 void GpuScheduler::SetSchedulingChangedCallback(
     const SchedulingChangedCallback& callback) {
   scheduling_changed_callback_ = callback;
 }
 
-scoped_refptr<Buffer> GpuScheduler::GetSharedMemoryBuffer(int32 shm_id) {
+scoped_refptr<Buffer> GpuScheduler::GetSharedMemoryBuffer(int32_t shm_id) {
   return command_buffer_->GetTransferBuffer(shm_id);
 }
 
-void GpuScheduler::set_token(int32 token) {
+void GpuScheduler::set_token(int32_t token) {
   command_buffer_->SetToken(token);
 }
 
-bool GpuScheduler::SetGetBuffer(int32 transfer_buffer_id) {
+bool GpuScheduler::SetGetBuffer(int32_t transfer_buffer_id) {
   scoped_refptr<Buffer> ring_buffer =
       command_buffer_->GetTransferBuffer(transfer_buffer_id);
   if (!ring_buffer.get()) {
     return false;
   }
 
   if (!parser_.get()) {
     parser_.reset(new CommandParser(handler_));
   }
 
   parser_->SetBuffer(
       ring_buffer->memory(), ring_buffer->size(), 0, ring_buffer->size());
 
   SetGetOffset(0);
   return true;
 }
 
-bool GpuScheduler::SetGetOffset(int32 offset) {
+bool GpuScheduler::SetGetOffset(int32_t offset) {
   if (parser_->set_get(offset)) {
-    command_buffer_->SetGetOffset(static_cast<int32>(parser_->get()));
+    command_buffer_->SetGetOffset(static_cast<int32_t>(parser_->get()));
     return true;
   }
   return false;
 }
 
-int32 GpuScheduler::GetGetOffset() {
+int32_t GpuScheduler::GetGetOffset() {
   return parser_->get();
 }
 
 void GpuScheduler::SetCommandProcessedCallback(
     const base::Closure& callback) {
   command_processed_callback_ = callback;
 }
 
 bool GpuScheduler::IsPreempted() {
   if (!preemption_flag_.get())
@@ skipping 14 matching lines @@
   return (decoder_ && decoder_->HasMoreIdleWork());
 }
 
 void GpuScheduler::PerformIdleWork() {
   if (!decoder_)
     return;
   decoder_->PerformIdleWork();
 }
 
 }  // namespace gpu