Switch to standard integer types in gpu/.

gpu/command_buffer/client/program_info_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 <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/client/program_info_manager.h"
 
 namespace {
 
-template<typename T> static T LocalGetAs(
-    const std::vector<int8>& data, uint32 offset, size_t size) {
-  const int8* p = &data[0] + offset;
+template <typename T>
+static T LocalGetAs(const std::vector<int8_t>& data,
+                    uint32_t offset,
+                    size_t size) {
+  const int8_t* p = &data[0] + offset;
   if (offset + size > data.size()) {
     NOTREACHED();
     return NULL;
   }
   return static_cast<T>(static_cast<const void*>(p));
 }
 
 }  // namespace anonymous
 
 namespace gpu {
@@ skipping 300 matching lines @@
         params[ii] = uniforms_es3_[indices[ii]].is_row_major;
       }
       return true;
     default:
       NOTREACHED();
       break;
   }
   return false;
 }
 
-void ProgramInfoManager::Program::UpdateES2(const std::vector<int8>& result) {
+void ProgramInfoManager::Program::UpdateES2(const std::vector<int8_t>& result) {
   if (cached_es2_) {
     return;
   }
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
   DCHECK_GE(result.size(), sizeof(ProgramInfoHeader));
   const ProgramInfoHeader* header = LocalGetAs<const ProgramInfoHeader*>(
       result, 0, sizeof(header));
   link_status_ = header->link_status != 0;
   if (!link_status_) {
     return;
   }
   DCHECK_EQ(0u, attrib_infos_.size());
   DCHECK_EQ(0u, uniform_infos_.size());
   DCHECK_EQ(0, max_attrib_name_length_);
   DCHECK_EQ(0, max_uniform_name_length_);
   const ProgramInput* inputs = LocalGetAs<const ProgramInput*>(
       result, sizeof(*header),
       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
   const ProgramInput* input = inputs;
-  for (uint32 ii = 0; ii < header->num_attribs; ++ii) {
-    const int32* location = LocalGetAs<const int32*>(
-        result, input->location_offset, sizeof(int32));
+  for (uint32_t ii = 0; ii < header->num_attribs; ++ii) {
+    const int32_t* location = LocalGetAs<const int32_t*>(
+        result, input->location_offset, sizeof(int32_t));
     const char* name_buf = LocalGetAs<const char*>(
         result, input->name_offset, input->name_length);
     std::string name(name_buf, input->name_length);
     attrib_infos_.push_back(
         VertexAttrib(input->size, input->type, name, *location));
     max_attrib_name_length_ = std::max(
         static_cast<GLsizei>(name.size() + 1), max_attrib_name_length_);
     ++input;
   }
-  for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
-    const int32* locations = LocalGetAs<const int32*>(
-        result, input->location_offset, sizeof(int32) * input->size);
+  for (uint32_t ii = 0; ii < header->num_uniforms; ++ii) {
+    const int32_t* locations = LocalGetAs<const int32_t*>(
+        result, input->location_offset, sizeof(int32_t) * input->size);
     const char* name_buf = LocalGetAs<const char*>(
         result, input->name_offset, input->name_length);
     std::string name(name_buf, input->name_length);
     UniformInfo info(input->size, input->type, name);
     max_uniform_name_length_ = std::max(
         static_cast<GLsizei>(name.size() + 1), max_uniform_name_length_);
-    for (int32 jj = 0; jj < input->size; ++jj) {
+    for (int32_t jj = 0; jj < input->size; ++jj) {
       info.element_locations.push_back(locations[jj]);
     }
     uniform_infos_.push_back(info);
     ++input;
   }
   DCHECK_EQ(header->num_attribs + header->num_uniforms,
-            static_cast<uint32>(input - inputs));
+            static_cast<uint32_t>(input - inputs));
   cached_es2_ = true;
 }
 
 void ProgramInfoManager::Program::UpdateES3UniformBlocks(
-    const std::vector<int8>& result) {
+    const std::vector<int8_t>& result) {
   if (cached_es3_uniform_blocks_) {
     return;
   }
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
   DCHECK_EQ(0u, uniform_blocks_.size());
   DCHECK_EQ(0u, active_uniform_block_max_name_length_);
 
@@ skipping 50 matching lines @@
           static_cast<GLuint>(indices[uu]);
     }
     indices += entries[ii].active_uniforms;
     data = reinterpret_cast<const char*>(indices);
   }
   DCHECK_EQ(data_size, size);
   cached_es3_uniform_blocks_ = true;
 }
 
 void ProgramInfoManager::Program::UpdateES3Uniformsiv(
-    const std::vector<int8>& result) {
+    const std::vector<int8_t>& result) {
   if (cached_es3_uniformsiv_) {
     return;
   }
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
   DCHECK_EQ(0u, uniforms_es3_.size());
 
   // |result| comes from GPU process. We consider it trusted data. Therefore,
@@ skipping 21 matching lines @@
     uniforms_es3_[ii].block_index = entries[ii].block_index;
     uniforms_es3_[ii].offset = entries[ii].offset;
     uniforms_es3_[ii].array_stride = entries[ii].array_stride;
     uniforms_es3_[ii].matrix_stride = entries[ii].matrix_stride;
     uniforms_es3_[ii].is_row_major = entries[ii].is_row_major;
   }
   cached_es3_uniformsiv_ = true;
 }
 
 void ProgramInfoManager::Program::UpdateES3TransformFeedbackVaryings(
-    const std::vector<int8>& result) {
+    const std::vector<int8_t>& result) {
   if (cached_es3_transform_feedback_varyings_) {
     return;
   }
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
   DCHECK_EQ(0u, transform_feedback_buffer_mode_);
   DCHECK_EQ(0u, transform_feedback_varyings_.size());
   DCHECK_EQ(0u, transform_feedback_varying_max_length_);
@@ skipping 77 matching lines @@
     GLES2Implementation* gl, GLuint program, ProgramInfoType type) {
   lock_.AssertAcquired();
   ProgramInfoMap::iterator it = program_infos_.find(program);
   if (it == program_infos_.end()) {
     return NULL;
   }
   Program* info = &it->second;
   if (info->IsCached(type))
     return info;
 
-  std::vector<int8> result;
+  std::vector<int8_t> result;
   switch (type) {
     case kES2:
       {
         base::AutoUnlock unlock(lock_);
         // lock_ can't be held across IPC call or else it may deadlock in
         // pepper. http://crbug.com/418651
         gl->GetProgramInfoCHROMIUMHelper(program, &result);
       }
       info->UpdateES2(result);
       break;
@@ skipping 424 matching lines @@
       }
       return true;
     }
   }
   return gl->GetUniformIndicesHelper(program, count, names, indices);
 }
 
 }  // namespace gles2
 }  // namespace gpu