Switch to standard integer types in gpu/.

gpu/config/gpu_control_list.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 GPU_CONFIG_GPU_CONTROL_LIST_H_
 #define GPU_CONFIG_GPU_CONTROL_LIST_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <set>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "gpu/gpu_export.h"
 
 namespace gpu {
 struct GPUInfo;
 
@@ skipping 27 matching lines @@
   // list information to decide which entries are applied to the current
   // system and returns the union of features specified in each entry.
   // If os is kOsAny, use the current OS; if os_version is empty, use the
   // current OS version.
   std::set<int> MakeDecision(
       OsType os, std::string os_version, const GPUInfo& gpu_info);
 
   // Collects the active entries from the last MakeDecision() call.
   // If disabled set to true, return entries that are disabled; otherwise,
   // return enabled entries.
-  void GetDecisionEntries(std::vector<uint32>* entry_ids,
+  void GetDecisionEntries(std::vector<uint32_t>* entry_ids,
                           bool disabled) const;
 
   // Collects all disabled extensions.
   std::vector<std::string> GetDisabledExtensions();
 
   // Returns the description and bugs from active entries from the last
   // MakeDecision() call.
   //
   // Each problems has:
   // {
   //    "description": "Your GPU is too old",
   //    "crBugs": [1234],
   //    "webkitBugs": []
   // }
   void GetReasons(
       base::ListValue* problem_list, const std::string& tag) const;
 
   // Return the largest entry id.  This is used for histogramming.
-  uint32 max_entry_id() const;
+  uint32_t max_entry_id() const;
 
   // Returns the version of the control list.
   std::string version() const;
 
   // Check if we need more gpu info to make the decisions.
   // This is computed from the last MakeDecision() call.
   // If yes, we should create a gl context and do a full gpu info collection.
   bool needs_more_info() const { return needs_more_info_; }
 
   // Returns the number of entries.  This is only for tests.
@@ skipping 177 matching lines @@
                   const GPUInfo& gpu_info) const;
 
     // Determines whether we needs more gpu info to make the blacklisting
     // decision.  It should only be checked if Contains() returns true.
     bool NeedsMoreInfo(const GPUInfo& gpu_info, bool consider_exceptions) const;
 
     // Returns the OsType.
     OsType GetOsType() const;
 
     // Returns the entry's unique id.  0 is reserved.
-    uint32 id() const;
+    uint32_t id() const;
 
     // Returns whether the entry is disabled.
     bool disabled() const;
 
     // Returns the description of the entry
     const std::string& description() const { return description_; }
 
     // Returns a list of Chromium and Webkit bugs applicable to this entry
     const std::vector<int>& cr_bugs() const { return cr_bugs_; }
     const std::vector<int>& webkit_bugs() const { return webkit_bugs_; }
@@ skipping 35 matching lines @@
     enum GLType {
       kGLTypeGL,  // This is default on MacOSX, Linux, ChromeOS
       kGLTypeGLES,  // This is default on Android
       kGLTypeANGLE,  // This is default on Windows
       kGLTypeNone
     };
 
     GpuControlListEntry();
     ~GpuControlListEntry();
 
-    bool SetId(uint32 id);
+    bool SetId(uint32_t id);
 
     void SetDisabled(bool disabled);
 
     bool SetOsInfo(const std::string& os,
                    const std::string& version_op,
                    const std::string& version_string,
                    const std::string& version_string2);
 
     bool SetVendorId(const std::string& vendor_id_string);
 
@@ skipping 77 matching lines @@
     // map a feature_name to feature_id. If the string is not a registered
     // feature name, return false.
     static bool StringToFeature(const std::string& feature_name,
                                 int* feature_id,
                                 const FeatureMap& feature_map);
 
     // Return the default GL type, depending on the OS.
     // See GLType declaration.
     static GLType GetDefaultGLType();
 
-    uint32 id_;
+    uint32_t id_;
     bool disabled_;
     std::string description_;
     std::vector<int> cr_bugs_;
     std::vector<int> webkit_bugs_;
     std::vector<std::string> disabled_extensions_;
     scoped_ptr<OsInfo> os_info_;
-    uint32 vendor_id_;
-    std::vector<uint32> device_id_list_;
+    uint32_t vendor_id_;
+    std::vector<uint32_t> device_id_list_;
     MultiGpuStyle multi_gpu_style_;
     MultiGpuCategory multi_gpu_category_;
     GLType gl_type_;
     std::string driver_vendor_info_;
     scoped_ptr<VersionInfo> driver_version_info_;
     scoped_ptr<VersionInfo> driver_date_info_;
     scoped_ptr<VersionInfo> gl_version_info_;
     std::string gl_vendor_info_;
     std::string gl_renderer_info_;
     std::string gl_extensions_info_;
@@ skipping 21 matching lines @@
   static NumericOp StringToNumericOp(const std::string& op);
 
   std::string version_;
   std::vector<ScopedGpuControlListEntry> entries_;
 
   // This records all the blacklist entries that are appliable to the current
   // user machine.  It is updated everytime MakeDecision() is called and is
   // used later by GetDecisionEntries().
   std::vector<ScopedGpuControlListEntry> active_entries_;
 
-  uint32 max_entry_id_;
+  uint32_t max_entry_id_;
 
   bool needs_more_info_;
 
   // The features a GpuControlList recognizes and handles.
   FeatureMap feature_map_;
   bool supports_feature_type_all_;
 
   bool control_list_logging_enabled_;
   std::string control_list_logging_name_;
 };
 
 }  // namespace gpu
 
 #endif  // GPU_CONFIG_GPU_CONTROL_LIST_H_