Switch to standard integer types in gpu/.

gpu/command_buffer/service/buffer_manager.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/buffer_manager.h"
+
+#include <stdint.h>
+
 #include <limits>
+
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
@@ skipping 119 matching lines @@
 void Buffer::SetInfo(
     GLsizeiptr size, GLenum usage, bool shadow, const GLvoid* data,
     bool is_client_side_array) {
   usage_ = usage;
   is_client_side_array_ = is_client_side_array;
   ClearCache();
   if (size != size_ || shadow != shadowed_) {
     shadowed_ = shadow;
     size_ = size;
     if (shadowed_) {
-      shadow_.reset(new int8[size]);
+      shadow_.reset(new int8_t[size]);
     } else {
       shadow_.reset();
     }
   }
   if (shadowed_) {
     if (data) {
       memcpy(shadow_.get(), data, size);
     } else {
       memset(shadow_.get(), 0, size);
     }
   }
   mapped_range_.reset(nullptr);
 }
 
 bool Buffer::CheckRange(
     GLintptr offset, GLsizeiptr size) const {
-  int32 end = 0;
+  int32_t end = 0;
   return offset >= 0 && size >= 0 &&
-         offset <= std::numeric_limits<int32>::max() &&
-         size <= std::numeric_limits<int32>::max() &&
+         offset <= std::numeric_limits<int32_t>::max() &&
+         size <= std::numeric_limits<int32_t>::max() &&
          SafeAddInt32(offset, size, &end) && end <= size_;
 }
 
 bool Buffer::SetRange(
     GLintptr offset, GLsizeiptr size, const GLvoid * data) {
   if (!CheckRange(offset, size)) {
     return false;
   }
   if (shadowed_) {
     memcpy(shadow_.get() + offset, data, size);
@@ skipping 13 matching lines @@
   return shadow_.get() + offset;
 }
 
 void Buffer::ClearCache() {
   range_set_.clear();
 }
 
 template <typename T>
 GLuint GetMaxValue(const void* data, GLuint offset, GLsizei count) {
   GLuint max_value = 0;
-  const T* element = reinterpret_cast<const T*>(
-      static_cast<const int8*>(data) + offset);
+  const T* element =
+      reinterpret_cast<const T*>(static_cast<const int8_t*>(data) + offset);
   const T* end = element + count;
   for (; element < end; ++element) {
     if (*element > max_value) {
       max_value = *element;
     }
   }
   return max_value;
 }
 
 bool Buffer::GetMaxValueForRange(
     GLuint offset, GLsizei count, GLenum type, GLuint* max_value) {
   Range range(offset, count, type);
   RangeToMaxValueMap::iterator it = range_set_.find(range);
   if (it != range_set_.end()) {
     *max_value = it->second;
     return true;
   }
 
-  uint32 size;
+  uint32_t size;
   if (!SafeMultiplyUint32(
       count, GLES2Util::GetGLTypeSizeForTexturesAndBuffers(type), &size)) {
     return false;
   }
 
   if (!SafeAddUint32(offset, size, &size)) {
     return false;
   }
 
-  if (size > static_cast<uint32>(size_)) {
+  if (size > static_cast<uint32_t>(size_)) {
     return false;
   }
 
   if (!shadowed_) {
     return false;
   }
 
   // Scan the range for the max value and store
   GLuint max_v = 0;
   switch (type) {
     case GL_UNSIGNED_BYTE:
-      max_v = GetMaxValue<uint8>(shadow_.get(), offset, count);
+      max_v = GetMaxValue<uint8_t>(shadow_.get(), offset, count);
       break;
     case GL_UNSIGNED_SHORT:
       // Check we are not accessing an odd byte for a 2 byte value.
       if ((offset & 1) != 0) {
         return false;
       }
-      max_v = GetMaxValue<uint16>(shadow_.get(), offset, count);
+      max_v = GetMaxValue<uint16_t>(shadow_.get(), offset, count);
       break;
     case GL_UNSIGNED_INT:
       // Check we are not accessing a non aligned address for a 4 byte value.
       if ((offset & 3) != 0) {
         return false;
       }
-      max_v = GetMaxValue<uint32>(shadow_.get(), offset, count);
+      max_v = GetMaxValue<uint32_t>(shadow_.get(), offset, count);
       break;
     default:
       NOTREACHED();  // should never get here by validation.
       break;
   }
   range_set_.insert(std::make_pair(range, max_v));
   *max_value = max_v;
   return true;
 }
 
@@ skipping 73 matching lines @@
 
 
 void BufferManager::DoBufferData(
     ErrorState* error_state,
     Buffer* buffer,
     GLenum target,
     GLsizeiptr size,
     GLenum usage,
     const GLvoid* data) {
   // Clear the buffer to 0 if no initial data was passed in.
-  scoped_ptr<int8[]> zero;
+  scoped_ptr<int8_t[]> zero;
   if (!data) {
-    zero.reset(new int8[size]);
+    zero.reset(new int8_t[size]);
     memset(zero.get(), 0, size);
     data = zero.get();
   }
 
   ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(error_state, "glBufferData");
   if (IsUsageClientSideArray(usage)) {
     GLsizei empty_size = UseNonZeroSizeForClientSideArrayBuffer() ? 1 : 0;
     glBufferData(target, empty_size, NULL, usage);
   } else {
     glBufferData(target, size, data, usage);
@@ skipping 187 matching lines @@
     auto guid = gfx::GetGLBufferGUIDForTracing(
         memory_tracker_->ShareGroupTracingGUID(), client_buffer_id);
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid);
   }
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu