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

webrtc/base/win32regkey.cc

 /*
  *  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 82 matching lines @@
                          const TCHAR* value) {
   ASSERT(full_key_name != NULL);
   ASSERT(value != NULL);
 
   return SetValueStaticHelper(full_key_name, value_name,
                               REG_SZ, const_cast<wchar_t*>(value));
 }
 
 HRESULT RegKey::SetValue(const wchar_t* full_key_name,
                          const wchar_t* value_name,
-                         const uint8* value,
+                         const uint8_t* value,
                          DWORD byte_count) {
   ASSERT(full_key_name != NULL);
 
   return SetValueStaticHelper(full_key_name, value_name, REG_BINARY,
-                              const_cast<uint8*>(value), byte_count);
+                              const_cast<uint8_t*>(value), byte_count);
 }
 
 HRESULT RegKey::SetValueMultiSZ(const wchar_t* full_key_name,
                                 const wchar_t* value_name,
-                                const uint8* value,
+                                const uint8_t* value,
                                 DWORD byte_count) {
   ASSERT(full_key_name != NULL);
 
   return SetValueStaticHelper(full_key_name, value_name, REG_MULTI_SZ,
-                              const_cast<uint8*>(value), byte_count);
+                              const_cast<uint8_t*>(value), byte_count);
 }
 
 HRESULT RegKey::GetValue(const wchar_t* full_key_name,
                          const wchar_t* value_name,
                          DWORD* value) {
   ASSERT(full_key_name != NULL);
   ASSERT(value != NULL);
 
   return GetValueStaticHelper(full_key_name, value_name, REG_DWORD, value);
 }
@@ skipping 72 matching lines @@
                          const wchar_t* value_name,
                          std::vector<std::wstring>* value) {
   ASSERT(full_key_name != NULL);
   ASSERT(value != NULL);
 
   return GetValueStaticHelper(full_key_name, value_name, REG_MULTI_SZ, value);
 }
 
 HRESULT RegKey::GetValue(const wchar_t* full_key_name,
                          const wchar_t* value_name,
-                         uint8** value,
+                         uint8_t** value,
                          DWORD* byte_count) {
   ASSERT(full_key_name != NULL);
   ASSERT(value != NULL);
   ASSERT(byte_count != NULL);
 
   return GetValueStaticHelper(full_key_name, value_name,
                               REG_BINARY, value, byte_count);
 }
 
 HRESULT RegKey::DeleteSubKey(const wchar_t* key_name) {
@@ skipping 178 matching lines @@
         case REG_DWORD:
           hr = key.SetValue(value_name, *(static_cast<DWORD*>(value)));
           break;
         case REG_QWORD:
           hr = key.SetValue(value_name, *(static_cast<DWORD64*>(value)));
           break;
         case REG_SZ:
           hr = key.SetValue(value_name, static_cast<const wchar_t*>(value));
           break;
         case REG_BINARY:
-          hr = key.SetValue(value_name, static_cast<const uint8*>(value),
+          hr = key.SetValue(value_name, static_cast<const uint8_t*>(value),
                             byte_count);
           break;
         case REG_MULTI_SZ:
-          hr = key.SetValue(value_name, static_cast<const uint8*>(value),
+          hr = key.SetValue(value_name, static_cast<const uint8_t*>(value),
                             byte_count, type);
           break;
         default:
           ASSERT(false);
           hr = HRESULT_FROM_WIN32(ERROR_DATATYPE_MISMATCH);
           break;
       }
       // close the key after writing
       HRESULT temp_hr = key.Close();
       if (hr == S_OK) {
@@ skipping 29 matching lines @@
           hr = key.GetValue(value_name, reinterpret_cast<DWORD64*>(value));
           break;
         case REG_SZ:
           hr = key.GetValue(value_name, reinterpret_cast<wchar_t**>(value));
           break;
         case REG_MULTI_SZ:
           hr = key.GetValue(value_name, reinterpret_cast<
                                             std::vector<std::wstring>*>(value));
           break;
         case REG_BINARY:
-          hr = key.GetValue(value_name, reinterpret_cast<uint8**>(value),
+          hr = key.GetValue(value_name, reinterpret_cast<uint8_t**>(value),
                             byte_count);
           break;
         default:
           ASSERT(false);
           hr = HRESULT_FROM_WIN32(ERROR_DATATYPE_MISMATCH);
           break;
       }
       // close the key after writing
       HRESULT temp_hr = key.Close();
       if (hr == S_OK) {
         hr = temp_hr;
       }
     }
   }
   return hr;
 }
 
 // GET helper
 HRESULT RegKey::GetValueHelper(const wchar_t* value_name,
                                DWORD* type,
-                               uint8** value,
+                               uint8_t** value,
                                DWORD* byte_count) const {
   ASSERT(byte_count != NULL);
   ASSERT(value != NULL);
   ASSERT(type != NULL);
 
   // init return buffer
   *value = NULL;
 
   // get the size of the return data buffer
   LONG res = ::SHQueryValueEx(h_key_, value_name, NULL, type, NULL, byte_count);
@@ skipping 105 matching lines @@
     }
 
     ASSERT((hr != S_OK) || (type == REG_SZ) ||
            (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
   }
 
   return hr;
 }
 
 // convert REG_MULTI_SZ bytes to string array
-HRESULT RegKey::MultiSZBytesToStringArray(const uint8* buffer,
+HRESULT RegKey::MultiSZBytesToStringArray(const uint8_t* buffer,
                                           DWORD byte_count,
                                           std::vector<std::wstring>* value) {
   ASSERT(buffer != NULL);
   ASSERT(value != NULL);
 
   const wchar_t* data = reinterpret_cast<const wchar_t*>(buffer);
   DWORD data_len = byte_count / sizeof(wchar_t);
   value->clear();
   if (data_len > 1) {
     // must be terminated by two null characters
@@ skipping 11 matching lines @@
   return S_OK;
 }
 
 // get a std::vector<std::wstring> value from REG_MULTI_SZ type
 HRESULT RegKey::GetValue(const wchar_t* value_name,
                          std::vector<std::wstring>* value) const {
   ASSERT(value != NULL);
 
   DWORD byte_count = 0;
   DWORD type = 0;
-  uint8* buffer = 0;
+  uint8_t* buffer = 0;
 
   // first get the size of the buffer
   HRESULT hr = GetValueHelper(value_name, &type, &buffer, &byte_count);
   ASSERT((hr != S_OK) || (type == REG_MULTI_SZ));
 
   if (SUCCEEDED(hr)) {
     hr = MultiSZBytesToStringArray(buffer, byte_count, value);
   }
 
   return hr;
 }
 
 // Binary data Get
 HRESULT RegKey::GetValue(const wchar_t* value_name,
-                         uint8** value,
+                         uint8_t** value,
                          DWORD* byte_count) const {
   ASSERT(byte_count != NULL);
   ASSERT(value != NULL);
 
   DWORD type = 0;
   HRESULT hr = GetValueHelper(value_name, &type, value, byte_count);
   ASSERT((hr != S_OK) || (type == REG_MULTI_SZ) || (type == REG_BINARY));
   return hr;
 }
 
 // Raw data get
 HRESULT RegKey::GetValue(const wchar_t* value_name,
-                         uint8** value,
+                         uint8_t** value,
                          DWORD* byte_count,
-                         DWORD*type) const {
+                         DWORD* type) const {
   ASSERT(type != NULL);
   ASSERT(byte_count != NULL);
   ASSERT(value != NULL);
 
   return GetValueHelper(value_name, type, value, byte_count);
 }
 
 // Int32 set
 HRESULT RegKey::SetValue(const wchar_t* value_name, DWORD value) const {
   ASSERT(h_key_ != NULL);
 
-  LONG res = ::RegSetValueEx(h_key_, value_name, NULL, REG_DWORD,
-                             reinterpret_cast<const uint8*>(&value),
-                             sizeof(DWORD));
+  LONG res =
+      ::RegSetValueEx(h_key_, value_name, NULL, REG_DWORD,
+                      reinterpret_cast<const uint8_t*>(&value), sizeof(DWORD));
   return HRESULT_FROM_WIN32(res);
 }
 
 // Int64 set
 HRESULT RegKey::SetValue(const wchar_t* value_name, DWORD64 value) const {
   ASSERT(h_key_ != NULL);
 
   LONG res = ::RegSetValueEx(h_key_, value_name, NULL, REG_QWORD,
-                             reinterpret_cast<const uint8*>(&value),
+                             reinterpret_cast<const uint8_t*>(&value),
                              sizeof(DWORD64));
   return HRESULT_FROM_WIN32(res);
 }
 
 // String set
 HRESULT RegKey::SetValue(const wchar_t* value_name,
                          const wchar_t* value) const {
   ASSERT(value != NULL);
   ASSERT(h_key_ != NULL);
 
   LONG res = ::RegSetValueEx(h_key_, value_name, NULL, REG_SZ,
-                             reinterpret_cast<const uint8*>(value),
+                             reinterpret_cast<const uint8_t*>(value),
                              (lstrlen(value) + 1) * sizeof(wchar_t));
   return HRESULT_FROM_WIN32(res);
 }
 
 // Binary data set
 HRESULT RegKey::SetValue(const wchar_t* value_name,
-                         const uint8* value,
+                         const uint8_t* value,
                          DWORD byte_count) const {
   ASSERT(h_key_ != NULL);
 
   // special case - if 'value' is NULL make sure byte_count is zero
   if (value == NULL) {
     byte_count = 0;
   }
 
   LONG res = ::RegSetValueEx(h_key_, value_name, NULL,
                              REG_BINARY, value, byte_count);
   return HRESULT_FROM_WIN32(res);
 }
 
 // Raw data set
 HRESULT RegKey::SetValue(const wchar_t* value_name,
-                         const uint8* value,
+                         const uint8_t* value,
                          DWORD byte_count,
                          DWORD type) const {
   ASSERT(value != NULL);
   ASSERT(h_key_ != NULL);
 
   LONG res = ::RegSetValueEx(h_key_, value_name, NULL, type, value, byte_count);
   return HRESULT_FROM_WIN32(res);
 }
 
 bool RegKey::HasKey(const wchar_t* full_key_name) {
@@ skipping 215 matching lines @@
     parent_key = L"";
   } else {
     parent_key = key_name->substr(0, index);
     *key_name = key_name->substr(index + 1, key_name->length() - index - 1);
   }
 
   return parent_key;
 }
 
 // get the number of values for this key
-uint32 RegKey::GetValueCount() {
+uint32_t RegKey::GetValueCount() {
   DWORD num_values = 0;
 
   if (ERROR_SUCCESS != ::RegQueryInfoKey(
         h_key_,  // key handle
         NULL,  // buffer for class name
         NULL,  // size of class string
         NULL,  // reserved
         NULL,  // number of subkeys
         NULL,  // longest subkey size
         NULL,  // longest class string
@@ skipping 22 matching lines @@
   res = ::RegEnumValue(h_key_, index, value_name_buf, &value_name_buf_size,
                        NULL, type, NULL, NULL);
 
   if (res == ERROR_SUCCESS) {
     value_name->assign(value_name_buf);
   }
 
   return HRESULT_FROM_WIN32(res);
 }
 
-uint32 RegKey::GetSubkeyCount() {
+uint32_t RegKey::GetSubkeyCount() {
   // number of values for key
   DWORD num_subkeys = 0;
 
   if (ERROR_SUCCESS != ::RegQueryInfoKey(
           h_key_,  // key handle
           NULL,  // buffer for class name
           NULL,  // size of class string
           NULL,  // reserved
           &num_subkeys,  // number of subkeys
           NULL,  // longest subkey size
@@ skipping 72 matching lines @@
     }
     CloseHandle(token);
   } else {
     LOG_GLE(LS_ERROR) << "OpenProcessToken(GetCurrentProcess) failed";
   }
 
   return ret;
 }
 
 }  // namespace rtc