Switch to standard integer types in gpu/.

gpu/command_buffer/service/program_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/program_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
@@ skipping 43 matching lines @@
   // Look for an array specification.
   size_t open_pos = name.find_last_of('[');
   if (open_pos == std::string::npos ||
       open_pos >= name.size() - 2) {
     return false;
   }
 
   base::CheckedNumeric<GLint> index = 0;
   size_t last = name.size() - 1;
   for (size_t pos = open_pos + 1; pos < last; ++pos) {
-    int8 digit = name[pos] - '0';
+    int8_t digit = name[pos] - '0';
     if (digit < 0 || digit > 9) {
       return false;
     }
     index = index * 10 + digit;
   }
   if (!index.IsValid()) {
     return false;
   }
 
   *element_index = index.ValueOrDie();
@@ skipping 16 matching lines @@
 }
 
 bool IsBuiltInInvariant(
     const VaryingMap& varyings, const std::string& name) {
   VaryingMap::const_iterator hit = varyings.find(name);
   if (hit == varyings.end())
     return false;
   return hit->second.isInvariant;
 }
 
-uint32 ComputeOffset(const void* start, const void* position) {
-  return static_cast<const uint8*>(position) -
-         static_cast<const uint8*>(start);
+uint32_t ComputeOffset(const void* start, const void* position) {
+  return static_cast<const uint8_t*>(position) -
+         static_cast<const uint8_t*>(start);
 }
 
 }  // anonymous namespace.
 
 Program::UniformInfo::UniformInfo()
     : size(0),
       type(GL_NONE),
       accepts_api_type(0),
       fake_location_base(0),
       is_array(false) {}
@@ skipping 190 matching lines @@
   }
   scoped_ptr<char[]> temp(new char[max_len]);
   GLint len = 0;
   glGetProgramInfoLog(service_id_, max_len, &len, temp.get());
   DCHECK(max_len == 0 || len < max_len);
   DCHECK(len == 0 || temp[len] == '\0');
   std::string log(temp.get(), len);
   set_log_info(ProcessLogInfo(log).c_str());
 }
 
-void Program::ClearUniforms(
-    std::vector<uint8>* zero_buffer) {
+void Program::ClearUniforms(std::vector<uint8_t>* zero_buffer) {
   DCHECK(zero_buffer);
   if (uniforms_cleared_) {
     return;
   }
   uniforms_cleared_ = true;
   for (const UniformInfo& uniform_info : uniform_infos_) {
     GLint location = uniform_info.element_locations[0];
     GLsizei size = uniform_info.size;
-    uint32 unit_size =
+    uint32_t unit_size =
         GLES2Util::GetElementCountForUniformType(uniform_info.type) *
         GLES2Util::GetElementSizeForUniformType(uniform_info.type);
     DCHECK_LT(0u, unit_size);
-    uint32 size_needed = size * unit_size;
+    uint32_t size_needed = size * unit_size;
     if (size_needed > zero_buffer->size()) {
       zero_buffer->resize(size_needed, 0u);
     }
     const void* zero = &(*zero_buffer)[0];
     switch (uniform_info.type) {
     case GL_FLOAT:
       glUniform1fv(location, size, reinterpret_cast<const GLfloat*>(zero));
       break;
     case GL_FLOAT_VEC2:
       glUniform2fv(location, size, reinterpret_cast<const GLfloat*>(zero));
@@ skipping 1475 matching lines @@
       variables.get(),
       combined_map.size());
 }
 
 void Program::GetProgramInfo(
     ProgramManager* manager, CommonDecoder::Bucket* bucket) const {
   // NOTE: It seems to me the math in here does not need check for overflow
   // because the data being calucated from has various small limits. The max
   // number of attribs + uniforms is somewhere well under 1024. The maximum size
   // of an identifier is 256 characters.
-  uint32 num_locations = 0;
-  uint32 total_string_size = 0;
+  uint32_t num_locations = 0;
+  uint32_t total_string_size = 0;
 
   for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
     const VertexAttrib& info = attrib_infos_[ii];
     num_locations += 1;
     total_string_size += info.name.size();
   }
 
   for (const UniformInfo& info : uniform_infos_) {
     num_locations += info.element_locations.size();
     total_string_size += info.name.size();
   }
 
-  uint32 num_inputs = attrib_infos_.size() + uniform_infos_.size();
-  uint32 input_size = num_inputs * sizeof(ProgramInput);
-  uint32 location_size = num_locations * sizeof(int32);
-  uint32 size = sizeof(ProgramInfoHeader) +
-      input_size + location_size + total_string_size;
+  uint32_t num_inputs = attrib_infos_.size() + uniform_infos_.size();
+  uint32_t input_size = num_inputs * sizeof(ProgramInput);
+  uint32_t location_size = num_locations * sizeof(int32_t);
+  uint32_t size = sizeof(ProgramInfoHeader) + input_size + location_size +
+                  total_string_size;
 
   bucket->SetSize(size);
   ProgramInfoHeader* header = bucket->GetDataAs<ProgramInfoHeader*>(0, size);
   ProgramInput* inputs = bucket->GetDataAs<ProgramInput*>(
       sizeof(ProgramInfoHeader), input_size);
-  int32* locations = bucket->GetDataAs<int32*>(
+  int32_t* locations = bucket->GetDataAs<int32_t*>(
       sizeof(ProgramInfoHeader) + input_size, location_size);
   char* strings = bucket->GetDataAs<char*>(
       sizeof(ProgramInfoHeader) + input_size + location_size,
       total_string_size);
   DCHECK(header);
   DCHECK(inputs);
   DCHECK(locations);
   DCHECK(strings);
 
   header->link_status = link_status_;
@@ skipping 389 matching lines @@
   if (manager_) {
     if (manager_->have_context_) {
       glDeleteProgram(service_id());
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 ProgramManager::ProgramManager(ProgramCache* program_cache,
-                               uint32 max_varying_vectors,
-                               uint32 max_dual_source_draw_buffers,
+                               uint32_t max_varying_vectors,
+                               uint32_t max_dual_source_draw_buffers,
                                FeatureInfo* feature_info)
     : program_count_(0),
       have_context_(true),
       program_cache_(program_cache),
       max_varying_vectors_(max_varying_vectors),
       max_dual_source_draw_buffers_(max_dual_source_draw_buffers),
       feature_info_(feature_info) {}
 
 ProgramManager::~ProgramManager() {
   DCHECK(programs_.empty());
@@ skipping 94 matching lines @@
   DCHECK(IsOwned(program));
   program->DecUseCount();
   RemoveProgramInfoIfUnused(shader_manager, program);
 }
 
 void ProgramManager::ClearUniforms(Program* program) {
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
-int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
+int32_t ProgramManager::MakeFakeLocation(int32_t index, int32_t element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu