Switch to standard integer types in content/browser/.

content/browser/gpu/shader_disk_cache.h

 // 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.
 
 #ifndef CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_
 #define CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_
 
+#include <stdint.h>
+
 #include <map>
 #include <queue>
 #include <string>
 
 #include "base/files/file_path.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
 #include "content/common/content_export.h"
 #include "net/disk_cache/disk_cache.h"
 
 namespace content {
 
 class ShaderDiskCacheEntry;
 class ShaderDiskReadHelper;
 class ShaderClearHelper;
@@ skipping 25 matching lines @@
       const base::Time end_time,
       const net::CompletionCallback& completion_callback);
 
   // Sets a callback for when the cache is available. If the cache is
   // already available the callback will not be called and net::OK is returned.
   // If the callback is set net::ERR_IO_PENDING is returned and the callback
   // will be executed when the cache is available.
   int SetAvailableCallback(const net::CompletionCallback& callback);
 
   // Returns the number of elements currently in the cache.
-  int32 Size();
+  int32_t Size();
 
   // Set a callback notification for when all current entries have been
   // written to the cache.
   // The return value is a net error code. If this method returns
   // ERR_IO_PENDING, the |callback| will be invoked when all entries have
   // been written to the cache.
   int SetCacheCompleteCallback(const net::CompletionCallback& callback);
 
  private:
   friend class base::RefCounted<ShaderDiskCache>;
@@ skipping 35 matching lines @@
   // Clear the shader disk cache for the given |path|. This supports unbounded
   // deletes in either direction by using null Time values for either
   // |begin_time| or |end_time|. The |callback| will be executed when the
   // clear is complete.
   void ClearByPath(const base::FilePath& path,
                    const base::Time& begin_time,
                    const base::Time& end_time,
                    const base::Closure& callback);
 
   // Retrieve the shader disk cache for the provided |client_id|.
-  scoped_refptr<ShaderDiskCache> Get(int32 client_id);
+  scoped_refptr<ShaderDiskCache> Get(int32_t client_id);
 
   // Set the |path| to be used for the disk cache for |client_id|.
-  void SetCacheInfo(int32 client_id, const base::FilePath& path);
+  void SetCacheInfo(int32_t client_id, const base::FilePath& path);
 
   // Remove the path mapping for |client_id|.
-  void RemoveCacheInfo(int32 client_id);
+  void RemoveCacheInfo(int32_t client_id);
 
   // Set the provided |cache| into the cache map for the given |path|.
   void AddToCache(const base::FilePath& path, ShaderDiskCache* cache);
 
   // Remove the provided |path| from our cache map.
   void RemoveFromCache(const base::FilePath& path);
 
  private:
   friend struct base::DefaultSingletonTraits<ShaderCacheFactory>;
   friend class ShaderClearHelper;
 
   ShaderCacheFactory();
   ~ShaderCacheFactory();
 
   scoped_refptr<ShaderDiskCache> GetByPath(const base::FilePath& path);
   void CacheCleared(const base::FilePath& path);
 
   typedef std::map<base::FilePath, ShaderDiskCache*> ShaderCacheMap;
   ShaderCacheMap shader_cache_map_;
 
-  typedef std::map<int32, base::FilePath> ClientIdToPathMap;
+  typedef std::map<int32_t, base::FilePath> ClientIdToPathMap;
   ClientIdToPathMap client_id_to_path_map_;
 
   typedef std::queue<scoped_refptr<ShaderClearHelper> > ShaderClearQueue;
   typedef std::map<base::FilePath, ShaderClearQueue> ShaderClearMap;
   ShaderClearMap shader_clear_map_;
 
   DISALLOW_COPY_AND_ASSIGN(ShaderCacheFactory);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_