Switch to standard integer types in gpu/.

gpu/command_buffer/service/memory_program_cache_unittest.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/memory_program_cache.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_mock.h"
@@ skipping 57 matching lines @@
         vertex_shader_(NULL),
         fragment_shader_(NULL),
         shader_cache_count_(0) { }
   ~MemoryProgramCacheTest() override { shader_manager_.Destroy(false); }
 
   void ShaderCacheCb(const std::string& key, const std::string& shader) {
     shader_cache_count_++;
     shader_cache_shader_ = shader;
   }
 
-  int32 shader_cache_count() { return shader_cache_count_; }
+  int32_t shader_cache_count() { return shader_cache_count_; }
   const std::string& shader_cache_shader() { return shader_cache_shader_; }
 
  protected:
   void SetUp() override {
     GpuServiceTest::SetUpWithGLVersion("3.0", "GL_ARB_get_program_binary");
 
     vertex_shader_ = shader_manager_.CreateShader(kVertexShaderClientId,
                                                   kVertexShaderServiceId,
                                                   GL_VERTEX_SHADER);
     fragment_shader_ = shader_manager_.CreateShader(
@@ skipping 79 matching lines @@
         .WillOnce(Invoke(emulator, &ProgramBinaryEmulator::ProgramBinary));
     EXPECT_CALL(*gl_.get(),
                 GetProgramiv(program_id, GL_LINK_STATUS, _))
                 .WillOnce(SetArgPointee<2>(GL_FALSE));
   }
 
   scoped_ptr<MemoryProgramCache> cache_;
   ShaderManager shader_manager_;
   Shader* vertex_shader_;
   Shader* fragment_shader_;
-  int32 shader_cache_count_;
+  int32_t shader_cache_count_;
   std::string shader_cache_shader_;
   std::vector<std::string> varyings_;
 };
 
 TEST_F(MemoryProgramCacheTest, CacheSave) {
   const GLenum kFormat = 1;
   const int kProgramId = 10;
   const int kBinaryLength = 20;
   char test_binary[kBinaryLength];
   for (int i = 0; i < kBinaryLength; ++i) {
@@ skipping 482 matching lines @@
       fragment_shader_,
       NULL,
       varyings_,
       GL_NONE,
       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                  base::Unretained(this))));
 }
 
 }  // namespace gles2
 }  // namespace gpu