Switch to standard integer types in gpu/.

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 2013 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/in_process_command_buffer.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <queue>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 213 matching lines @@
 void InProcessCommandBuffer::PumpCommands() {
   CheckSequencedThread();
   command_buffer_lock_.AssertAcquired();
 
   if (!MakeCurrent())
     return;
 
   gpu_scheduler_->PutChanged();
 }
 
-bool InProcessCommandBuffer::GetBufferChanged(int32 transfer_buffer_id) {
+bool InProcessCommandBuffer::GetBufferChanged(int32_t transfer_buffer_id) {
   CheckSequencedThread();
   command_buffer_lock_.AssertAcquired();
   command_buffer_->SetGetBuffer(transfer_buffer_id);
   return true;
 }
 
 bool InProcessCommandBuffer::Initialize(
     scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
-    const std::vector<int32>& attribs,
+    const std::vector<int32_t>& attribs,
     gfx::GpuPreference gpu_preference,
     const base::Closure& context_lost_callback,
     InProcessCommandBuffer* share_group,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
     ImageFactory* image_factory) {
   DCHECK(!share_group || service_.get() == share_group->service_.get());
   context_lost_callback_ = WrapCallback(context_lost_callback);
 
   if (surface.get()) {
     // GPU thread must be the same as client thread due to GLSurface not being
@@ skipping 232 matching lines @@
   if (state_after_last_flush_.generation - last_state_.generation < 0x80000000U)
     last_state_ = state_after_last_flush_;
   return last_state_;
 }
 
 CommandBuffer::State InProcessCommandBuffer::GetLastState() {
   CheckSequencedThread();
   return last_state_;
 }
 
-int32 InProcessCommandBuffer::GetLastToken() {
+int32_t InProcessCommandBuffer::GetLastToken() {
   CheckSequencedThread();
   GetStateFast();
   return last_state_.token;
 }
 
-void InProcessCommandBuffer::FlushOnGpuThread(int32 put_offset,
+void InProcessCommandBuffer::FlushOnGpuThread(int32_t put_offset,
                                               uint32_t order_num) {
   CheckSequencedThread();
   ScopedEvent handle_flush(&flush_event_);
   base::AutoLock lock(command_buffer_lock_);
 
   {
     ScopedOrderNumberProcessor scoped_order_num(sync_point_order_data_.get(),
                                                 order_num);
     command_buffer_->Flush(put_offset);
     {
@@ skipping 36 matching lines @@
 
 void InProcessCommandBuffer::ScheduleDelayedWorkOnGpuThread() {
   CheckSequencedThread();
   if (delayed_work_pending_)
     return;
   delayed_work_pending_ = true;
   service_->ScheduleDelayedWork(base::Bind(
       &InProcessCommandBuffer::PerformDelayedWork, gpu_thread_weak_ptr_));
 }
 
-void InProcessCommandBuffer::Flush(int32 put_offset) {
+void InProcessCommandBuffer::Flush(int32_t put_offset) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   if (last_put_offset_ == put_offset)
     return;
 
   SyncPointManager* sync_manager = service_->sync_point_manager();
   const uint32_t order_num =
       sync_point_order_data_->GenerateUnprocessedOrderNumber(sync_manager);
   last_put_offset_ = put_offset;
   base::Closure task = base::Bind(&InProcessCommandBuffer::FlushOnGpuThread,
                                   gpu_thread_weak_ptr_,
                                   put_offset,
                                   order_num);
   QueueTask(task);
 
   flushed_fence_sync_release_ = next_fence_sync_release_ - 1;
 }
 
-void InProcessCommandBuffer::OrderingBarrier(int32 put_offset) {
+void InProcessCommandBuffer::OrderingBarrier(int32_t put_offset) {
   Flush(put_offset);
 }
 
-void InProcessCommandBuffer::WaitForTokenInRange(int32 start, int32 end) {
+void InProcessCommandBuffer::WaitForTokenInRange(int32_t start, int32_t end) {
   CheckSequencedThread();
   while (!InRange(start, end, GetLastToken()) &&
          last_state_.error == gpu::error::kNoError)
     flush_event_.Wait();
 }
 
-void InProcessCommandBuffer::WaitForGetOffsetInRange(int32 start, int32 end) {
+void InProcessCommandBuffer::WaitForGetOffsetInRange(int32_t start,
+                                                     int32_t end) {
   CheckSequencedThread();
 
   GetStateFast();
   while (!InRange(start, end, last_state_.get_offset) &&
          last_state_.error == gpu::error::kNoError) {
     flush_event_.Wait();
     GetStateFast();
   }
 }
 
-void InProcessCommandBuffer::SetGetBuffer(int32 shm_id) {
+void InProcessCommandBuffer::SetGetBuffer(int32_t shm_id) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   base::WaitableEvent completion(true, false);
   base::Closure task =
       base::Bind(&InProcessCommandBuffer::SetGetBufferOnGpuThread,
                  base::Unretained(this), shm_id, &completion);
   QueueTask(task);
   completion.Wait();
 
   {
     base::AutoLock lock(state_after_last_flush_lock_);
     state_after_last_flush_ = command_buffer_->GetLastState();
   }
 }
 
 void InProcessCommandBuffer::SetGetBufferOnGpuThread(
-    int32 shm_id,
+    int32_t shm_id,
     base::WaitableEvent* completion) {
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->SetGetBuffer(shm_id);
   last_put_offset_ = 0;
   completion->Signal();
 }
 
-scoped_refptr<Buffer> InProcessCommandBuffer::CreateTransferBuffer(size_t size,
-                                                                   int32* id) {
+scoped_refptr<Buffer> InProcessCommandBuffer::CreateTransferBuffer(
+    size_t size,
+    int32_t* id) {
   CheckSequencedThread();
   base::AutoLock lock(command_buffer_lock_);
   return command_buffer_->CreateTransferBuffer(size, id);
 }
 
-void InProcessCommandBuffer::DestroyTransferBuffer(int32 id) {
+void InProcessCommandBuffer::DestroyTransferBuffer(int32_t id) {
   CheckSequencedThread();
   base::Closure task =
       base::Bind(&InProcessCommandBuffer::DestroyTransferBufferOnGpuThread,
                  base::Unretained(this),
                  id);
 
   QueueTask(task);
 }
 
-void InProcessCommandBuffer::DestroyTransferBufferOnGpuThread(int32 id) {
+void InProcessCommandBuffer::DestroyTransferBufferOnGpuThread(int32_t id) {
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->DestroyTransferBuffer(id);
 }
 
 gpu::Capabilities InProcessCommandBuffer::GetCapabilities() {
   return capabilities_;
 }
 
-int32 InProcessCommandBuffer::CreateImage(ClientBuffer buffer,
-                                          size_t width,
-                                          size_t height,
-                                          unsigned internalformat) {
+int32_t InProcessCommandBuffer::CreateImage(ClientBuffer buffer,
+                                            size_t width,
+                                            size_t height,
+                                            unsigned internalformat) {
   CheckSequencedThread();
 
   DCHECK(gpu_memory_buffer_manager_);
   gfx::GpuMemoryBuffer* gpu_memory_buffer =
       gpu_memory_buffer_manager_->GpuMemoryBufferFromClientBuffer(buffer);
   DCHECK(gpu_memory_buffer);
 
-  int32 new_id = next_image_id_.GetNext();
+  int32_t new_id = next_image_id_.GetNext();
 
   DCHECK(gpu::ImageFactory::IsGpuMemoryBufferFormatSupported(
       gpu_memory_buffer->GetFormat(), capabilities_));
   DCHECK(gpu::ImageFactory::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
       internalformat, gpu_memory_buffer->GetFormat()));
 
   // This handle is owned by the GPU thread and must be passed to it or it
   // will leak. In otherwords, do not early out on error between here and the
   // queuing of the CreateImage task below.
   bool requires_sync_point = false;
@@ skipping 24 matching lines @@
                          GetCommandBufferID(), fence_sync);
     sync_token.SetVerifyFlush();
     gpu_memory_buffer_manager_->SetDestructionSyncToken(gpu_memory_buffer,
                                                         sync_token);
   }
 
   return new_id;
 }
 
 void InProcessCommandBuffer::CreateImageOnGpuThread(
-    int32 id,
+    int32_t id,
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     gfx::BufferFormat format,
-    uint32 internalformat,
+    uint32_t internalformat,
     uint32_t order_num,
     uint64_t fence_sync) {
   ScopedOrderNumberProcessor scoped_order_num(sync_point_order_data_.get(),
                                               order_num);
   if (!decoder_)
     return;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (image_manager->LookupImage(id)) {
@@ skipping 38 matching lines @@
       image_manager->AddImage(image.get(), id);
       break;
     }
   }
 
   if (fence_sync) {
     sync_point_client_->ReleaseFenceSync(fence_sync);
   }
 }
 
-void InProcessCommandBuffer::DestroyImage(int32 id) {
+void InProcessCommandBuffer::DestroyImage(int32_t id) {
   CheckSequencedThread();
 
   QueueTask(base::Bind(&InProcessCommandBuffer::DestroyImageOnGpuThread,
                        base::Unretained(this),
                        id));
 }
 
-void InProcessCommandBuffer::DestroyImageOnGpuThread(int32 id) {
+void InProcessCommandBuffer::DestroyImageOnGpuThread(int32_t id) {
   if (!decoder_)
     return;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (!image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image with ID doesn't exist.";
     return;
   }
 
   image_manager->RemoveImage(id);
 }
 
-int32 InProcessCommandBuffer::CreateGpuMemoryBufferImage(
+int32_t InProcessCommandBuffer::CreateGpuMemoryBufferImage(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage) {
   CheckSequencedThread();
 
   DCHECK(gpu_memory_buffer_manager_);
   scoped_ptr<gfx::GpuMemoryBuffer> buffer(
       gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
           gfx::Size(width, height),
           gpu::ImageFactory::DefaultBufferFormatForImageFormat(internalformat),
           gfx::BufferUsage::SCANOUT));
   if (!buffer)
     return -1;
 
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
-uint32 InProcessCommandBuffer::InsertSyncPoint() {
-  uint32 sync_point = service_->sync_point_manager()->GenerateSyncPoint();
+uint32_t InProcessCommandBuffer::InsertSyncPoint() {
+  uint32_t sync_point = service_->sync_point_manager()->GenerateSyncPoint();
   QueueTask(base::Bind(&InProcessCommandBuffer::RetireSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point));
   return sync_point;
 }
 
-uint32 InProcessCommandBuffer::InsertFutureSyncPoint() {
+uint32_t InProcessCommandBuffer::InsertFutureSyncPoint() {
   return service_->sync_point_manager()->GenerateSyncPoint();
 }
 
-void InProcessCommandBuffer::RetireSyncPoint(uint32 sync_point) {
+void InProcessCommandBuffer::RetireSyncPoint(uint32_t sync_point) {
   QueueTask(base::Bind(&InProcessCommandBuffer::RetireSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point));
 }
 
-void InProcessCommandBuffer::RetireSyncPointOnGpuThread(uint32 sync_point) {
+void InProcessCommandBuffer::RetireSyncPointOnGpuThread(uint32_t sync_point) {
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   if (mailbox_manager->UsesSync()) {
     bool make_current_success = false;
     {
       base::AutoLock lock(command_buffer_lock_);
       make_current_success = MakeCurrent();
     }
     if (make_current_success) {
       // Old sync points are global and do not have a command buffer ID,
@@ skipping 161 matching lines @@
                        base::Unretained(this),
                        sync_token,
                        WrapCallback(callback)));
 }
 
 bool InProcessCommandBuffer::CanWaitUnverifiedSyncToken(
     const SyncToken* sync_token) {
   return false;
 }
 
-uint32 InProcessCommandBuffer::CreateStreamTextureOnGpuThread(
-    uint32 client_texture_id) {
+uint32_t InProcessCommandBuffer::CreateStreamTextureOnGpuThread(
+    uint32_t client_texture_id) {
 #if defined(OS_ANDROID)
   return stream_texture_manager_->CreateStreamTexture(
       client_texture_id, decoder_->GetContextGroup()->texture_manager());
 #else
   return 0;
 #endif
 }
 
 gpu::error::Error InProcessCommandBuffer::GetLastError() {
   CheckSequencedThread();
@@ skipping 35 matching lines @@
       base::Bind(&RunOnTargetThread, base::Passed(&scoped_callback));
   base::Closure wrapped_callback =
       base::Bind(&PostCallback, base::ThreadTaskRunnerHandle::IsSet()
                                     ? base::ThreadTaskRunnerHandle::Get()
                                     : nullptr,
                  callback_on_client_thread);
   return wrapped_callback;
 }
 
 #if defined(OS_ANDROID)
-scoped_refptr<gfx::SurfaceTexture>
-InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
+scoped_refptr<gfx::SurfaceTexture> InProcessCommandBuffer::GetSurfaceTexture(
+    uint32_t stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 
-uint32 InProcessCommandBuffer::CreateStreamTexture(uint32 texture_id) {
+uint32_t InProcessCommandBuffer::CreateStreamTexture(uint32_t texture_id) {
   base::WaitableEvent completion(true, false);
-  uint32 stream_id = 0;
-  base::Callback<uint32(void)> task =
+  uint32_t stream_id = 0;
+  base::Callback<uint32_t(void)> task =
       base::Bind(&InProcessCommandBuffer::CreateStreamTextureOnGpuThread,
                  base::Unretained(this), texture_id);
   QueueTask(
-      base::Bind(&RunTaskWithResult<uint32>, task, &stream_id, &completion));
+      base::Bind(&RunTaskWithResult<uint32_t>, task, &stream_id, &completion));
   completion.Wait();
   return stream_id;
 }
 #endif
 
 GpuInProcessThread::GpuInProcessThread(SyncPointManager* sync_point_manager)
     : base::Thread("GpuThread"), sync_point_manager_(sync_point_manager) {
   Start();
 }
 
@@ skipping 35 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu