Switch to standard integer types in content/browser/.

content/browser/gpu/shader_disk_cache.cc

 // Copyright (c) 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 "content/browser/gpu/shader_disk_cache.h"
 
+#include "base/macros.h"
 #include "base/threading/thread_checker.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/public/browser/browser_thread.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "net/base/cache_type.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 namespace content {
 
@@ skipping 402 matching lines @@
   return base::Singleton<ShaderCacheFactory,
                          base::LeakySingletonTraits<ShaderCacheFactory>>::get();
 }
 
 ShaderCacheFactory::ShaderCacheFactory() {
 }
 
 ShaderCacheFactory::~ShaderCacheFactory() {
 }
 
-void ShaderCacheFactory::SetCacheInfo(int32 client_id,
+void ShaderCacheFactory::SetCacheInfo(int32_t client_id,
                                       const base::FilePath& path) {
   client_id_to_path_map_[client_id] = path;
 }
 
-void ShaderCacheFactory::RemoveCacheInfo(int32 client_id) {
+void ShaderCacheFactory::RemoveCacheInfo(int32_t client_id) {
   client_id_to_path_map_.erase(client_id);
 }
 
-scoped_refptr<ShaderDiskCache> ShaderCacheFactory::Get(int32 client_id) {
+scoped_refptr<ShaderDiskCache> ShaderCacheFactory::Get(int32_t client_id) {
   ClientIdToPathMap::iterator iter =
       client_id_to_path_map_.find(client_id);
   if (iter == client_id_to_path_map_.end())
     return NULL;
   return ShaderCacheFactory::GetByPath(iter->second);
 }
 
 scoped_refptr<ShaderDiskCache> ShaderCacheFactory::GetByPath(
     const base::FilePath& path) {
   ShaderCacheMap::iterator iter = shader_cache_map_.find(path);
@@ skipping 113 matching lines @@
   int rv;
   if (begin_time.is_null()) {
     rv = backend_->DoomAllEntries(completion_callback);
   } else {
     rv = backend_->DoomEntriesBetween(begin_time, end_time,
                                       completion_callback);
   }
   return rv;
 }
 
-int32 ShaderDiskCache::Size() {
+int32_t ShaderDiskCache::Size() {
   if (!cache_available_)
     return -1;
   return backend_->GetEntryCount();
 }
 
 int ShaderDiskCache::SetAvailableCallback(
     const net::CompletionCallback& callback) {
   if (cache_available_)
     return net::OK;
   available_callback_ = callback;
@@ skipping 33 matching lines @@
     const net::CompletionCallback& callback) {
   if (entry_map_.empty()) {
     return net::OK;
   }
   cache_complete_callback_ = callback;
   return net::ERR_IO_PENDING;
 }
 
 }  // namespace content