Use suffixed {uint,int}{8,16,32,64}_t types.

webrtc/base/win32regkey.h

 /*
  *  Copyright 2003 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 46 matching lines @@
 
   HRESULT Open(HKEY parent_key, const wchar_t* key_name, REGSAM sam_desired);
 
   // close this reg key
   HRESULT Close();
 
   // check if the key has a specified value
   bool HasValue(const wchar_t* value_name) const;
 
   // get the number of values for this key
-  uint32 GetValueCount();
+  uint32_t GetValueCount();
 
   // Called to get the value name for the given value name index
   // Use GetValueCount() to get the total value_name count for this key
   // Returns failure if no key at the specified index
   // If you modify the key while enumerating, the indexes will be out of order.
   // Since the index order is not guaranteed, you need to reset your counting
   // loop.
   // 'type' refers to REG_DWORD, REG_QWORD, etc..
   // 'type' can be NULL if not interested in the value type
   HRESULT GetValueNameAt(int index, std::wstring* value_name, DWORD* type);
 
   // check if the current key has the specified subkey
   bool HasSubkey(const wchar_t* key_name) const;
 
   // get the number of subkeys for this key
-  uint32 GetSubkeyCount();
+  uint32_t GetSubkeyCount();
 
   // Called to get the key name for the given key index
   // Use GetSubkeyCount() to get the total count for this key
   // Returns failure if no key at the specified index
   // If you modify the key while enumerating, the indexes will be out of order.
   // Since the index order is not guaranteed, you need to reset your counting
   // loop.
   HRESULT GetSubkeyNameAt(int index, std::wstring* key_name);
 
   // SETTERS
 
-  // set an int32 value - use when reading multiple values from a key
+  // set an int32_t value - use when reading multiple values from a key
   HRESULT SetValue(const wchar_t* value_name, DWORD value) const;
 
-  // set an int64 value
+  // set an int64_t value
   HRESULT SetValue(const wchar_t* value_name, DWORD64 value) const;
 
   // set a string value
   HRESULT SetValue(const wchar_t* value_name, const wchar_t* value) const;
 
   // set binary data
   HRESULT SetValue(const wchar_t* value_name,
-                   const uint8* value,
+                   const uint8_t* value,
                    DWORD byte_count) const;
 
   // set raw data, including type
   HRESULT SetValue(const wchar_t* value_name,
-                   const uint8* value,
+                   const uint8_t* value,
                    DWORD byte_count,
                    DWORD type) const;
 
   // GETTERS
 
-  // get an int32 value
+  // get an int32_t value
   HRESULT GetValue(const wchar_t* value_name, DWORD* value) const;
 
-  // get an int64 value
+  // get an int64_t value
   HRESULT GetValue(const wchar_t* value_name, DWORD64* value) const;
 
   // get a string value - the caller must free the return buffer
   HRESULT GetValue(const wchar_t* value_name, wchar_t** value) const;
 
   // get a string value
   HRESULT GetValue(const wchar_t* value_name, std::wstring* value) const;
 
   // get a std::vector<std::wstring> value from REG_MULTI_SZ type
   HRESULT GetValue(const wchar_t* value_name,
                    std::vector<std::wstring>* value) const;
 
   // get binary data - the caller must free the return buffer
   HRESULT GetValue(const wchar_t* value_name,
-                   uint8** value,
+                   uint8_t** value,
                    DWORD* byte_count) const;
 
   // get raw data, including type - the caller must free the return buffer
   HRESULT GetValue(const wchar_t* value_name,
-                   uint8** value,
+                   uint8_t** value,
                    DWORD* byte_count,
                    DWORD* type) const;
 
   // STATIC VERSIONS
 
   // flush
   static HRESULT FlushKey(const wchar_t* full_key_name);
 
   // check if a key exists
   static bool HasKey(const wchar_t* full_key_name);
 
   // check if the key has a specified value
   static bool HasValue(const wchar_t* full_key_name, const wchar_t* value_name);
 
   // SETTERS
 
-  // STATIC int32 set
+  // STATIC int32_t set
   static HRESULT SetValue(const wchar_t* full_key_name,
                           const wchar_t* value_name,
                           DWORD value);
 
-  // STATIC int64 set
+  // STATIC int64_t set
   static HRESULT SetValue(const wchar_t* full_key_name,
                           const wchar_t* value_name,
                           DWORD64 value);
 
   // STATIC float set
   static HRESULT SetValue(const wchar_t* full_key_name,
                           const wchar_t* value_name,
                           float value);
 
   // STATIC double set
   static HRESULT SetValue(const wchar_t* full_key_name,
                           const wchar_t* value_name,
                           double value);
 
   // STATIC string set
   static HRESULT SetValue(const wchar_t* full_key_name,
                           const wchar_t* value_name,
                           const wchar_t* value);
 
   // STATIC binary data set
   static HRESULT SetValue(const wchar_t* full_key_name,
                           const wchar_t* value_name,
-                          const uint8* value,
+                          const uint8_t* value,
                           DWORD byte_count);
 
   // STATIC multi-string set
   static HRESULT SetValueMultiSZ(const wchar_t* full_key_name,
                                  const TCHAR* value_name,
-                                 const uint8* value,
+                                 const uint8_t* value,
                                  DWORD byte_count);
 
   // GETTERS
 
-  // STATIC int32 get
+  // STATIC int32_t get
   static HRESULT GetValue(const wchar_t* full_key_name,
                           const wchar_t* value_name,
                           DWORD* value);
 
-  // STATIC int64 get
+  // STATIC int64_t get
   //
   // Note: if you are using time64 you should
   // likely use GetLimitedTimeValue (util.h) instead of this method.
   static HRESULT GetValue(const wchar_t* full_key_name,
                           const wchar_t* value_name,
                           DWORD64* value);
 
   // STATIC float get
   static HRESULT GetValue(const wchar_t* full_key_name,
                           const wchar_t* value_name,
@@ skipping 14 matching lines @@
                           std::wstring* value);
 
   // STATIC REG_MULTI_SZ get
   static HRESULT GetValue(const wchar_t* full_key_name,
                           const wchar_t* value_name,
                           std::vector<std::wstring>* value);
 
   // STATIC get binary data - the caller must free the return buffer
   static HRESULT GetValue(const wchar_t* full_key_name,
                           const wchar_t* value_name,
-                          uint8** value,
+                          uint8_t** value,
                           DWORD* byte_count);
 
   // Get type of a registry value
   static HRESULT GetValueType(const wchar_t* full_key_name,
                               const wchar_t* value_name,
                               DWORD* value_type);
 
   // delete a subkey of the current key (with no subkeys)
   HRESULT DeleteSubKey(const wchar_t* key_name);
 
@@ skipping 43 matching lines @@
                          const wchar_t* file_name);
 
   // Is the key empty: having no sub-keys and values
   static bool IsKeyEmpty(const wchar_t* full_key_name);
 
  private:
 
   // helper function to get any value from the registry
   // used when the size of the data is unknown
   HRESULT GetValueHelper(const wchar_t* value_name,
-                         DWORD* type, uint8** value,
+                         DWORD* type,
+                         uint8_t** value,
                          DWORD* byte_count) const;
 
   // helper function to get the parent key name and the subkey from a string
   // modifies the argument in place and returns the key name
   // Necessary for the static versions that use the full name of the reg key
   static std::wstring GetParentKeyInfo(std::wstring* key_name);
 
   // common SET Helper for the static case
   static HRESULT SetValueStaticHelper(const wchar_t* full_key_name,
                                       const wchar_t* value_name,
                                       DWORD type,
                                       LPVOID value,
                                       DWORD byte_count = 0);
 
   // common GET Helper for the static case
   static HRESULT GetValueStaticHelper(const wchar_t* full_key_name,
                                       const wchar_t* value_name,
                                       DWORD type,
                                       LPVOID value,
                                       DWORD* byte_count = NULL);
 
   // convert REG_MULTI_SZ bytes to string array
-  static HRESULT MultiSZBytesToStringArray(const uint8* buffer,
+  static HRESULT MultiSZBytesToStringArray(const uint8_t* buffer,
                                            DWORD byte_count,
                                            std::vector<std::wstring>* value);
 
   // the HKEY for the current key
   HKEY h_key_;
 
   // for unittest
   friend void RegKeyHelperFunctionsTest();
 
   RTC_DISALLOW_COPY_AND_ASSIGN(RegKey);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_WIN32REGKEY_H_