Switch to standard integer types in chrome/.

chrome/installer/util/registry_key_backup.cc

 // Copyright (c) 2011 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 "chrome/installer/util/registry_key_backup.h"
 
+#include <stdint.h>
+
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/win/registry.h"
 
 using base::win::RegKey;
 
 namespace {
 
 const REGSAM kKeyReadNoNotify = (KEY_READ) & ~(KEY_NOTIFY);
 
 // A container for a registry value.
 class ValueData {
  public:
   ValueData();
   ~ValueData();
 
   // Initializes this object with a name (the first |name_size| characters in
   // |name_buffer|, |type|, and data (the first |data_size| bytes in |data|).
-  void Initialize(const wchar_t* name_buffer, DWORD name_size,
-                  DWORD type, const uint8* data, DWORD data_size);
+  void Initialize(const wchar_t* name_buffer,
+                  DWORD name_size,
+                  DWORD type,
+                  const uint8_t* data,
+                  DWORD data_size);
 
   // The possibly empty name of this value.
   const std::wstring& name_str() const { return name_; }
 
   // The name of this value, or NULL for the default (unnamed) value.
   const wchar_t* name() const { return name_.empty() ? NULL : name_.c_str(); }
 
   // The type of this value.
   DWORD type() const { return type_; }
 
   // A pointer to a buffer of |data_len()| bytes containing the value's data,
   // or NULL if the value has no data.
-  const uint8* data() const { return data_.empty() ? NULL : &data_[0]; }
+  const uint8_t* data() const { return data_.empty() ? NULL : &data_[0]; }
 
   // The size, in bytes, of the value's data.
   DWORD data_len() const { return static_cast<DWORD>(data_.size()); }
 
  private:
   // This value's name, or the empty string if this is the default (unnamed)
   // value.
   std::wstring name_;
   // This value's data.
-  std::vector<uint8> data_;
+  std::vector<uint8_t> data_;
   // This value's type (e.g., REG_DWORD, REG_SZ, REG_QWORD, etc).
   DWORD type_;
 
   // Copy constructible and assignable for use in STL containers.
 };
 
 }  // namespace
 
 // A container for a registry key, its values, and its subkeys.
 class RegistryKeyBackup::KeyData {
@@ skipping 21 matching lines @@
 
   // Copy constructible and assignable for use in STL containers.
 };
 
 ValueData::ValueData() : type_(REG_NONE) {
 }
 
 ValueData::~ValueData() {
 }
 
-void ValueData::Initialize(
-    const wchar_t* name_buffer,
-    DWORD name_size,
-    DWORD type,
-    const uint8* data,
-    DWORD data_size) {
+void ValueData::Initialize(const wchar_t* name_buffer,
+                           DWORD name_size,
+                           DWORD type,
+                           const uint8_t* data,
+                           DWORD data_size) {
   name_.assign(name_buffer, name_size);
   type_ = type;
   data_.assign(data, data + data_size);
 }
 
 RegistryKeyBackup::KeyData::KeyData() {
 }
 
 RegistryKeyBackup::KeyData::~KeyData() {
 }
@@ skipping 14 matching lines @@
   if (result != ERROR_SUCCESS) {
     LOG(ERROR) << "Failed getting info of key to backup, result: " << result;
     return false;
   }
   DWORD max_name_len = std::max(max_subkey_name_len, max_value_name_len) + 1;
   std::vector<wchar_t> name_buffer(max_name_len);
 
   // Backup the values.
   if (num_values != 0) {
     values.reserve(num_values);
-    std::vector<uint8> value_buffer(max_value_len != 0 ? max_value_len : 1);
+    std::vector<uint8_t> value_buffer(max_value_len != 0 ? max_value_len : 1);
     DWORD name_size = 0;
     DWORD value_type = REG_NONE;
     DWORD value_size = 0;
 
     for (DWORD i = 0; i < num_values; ) {
       name_size = static_cast<DWORD>(name_buffer.size());
       value_size = static_cast<DWORD>(value_buffer.size());
       result = RegEnumValue(key.Handle(), i, &name_buffer[0], &name_size,
                             NULL, &value_type, &value_buffer[0], &value_size);
       switch (result) {
@@ skipping 173 matching lines @@
     } else {
       success = key_data_->WriteTo(&dest_key);
       LOG_IF(ERROR, !success) << "Failed to write key data.";
     }
   } else {
     success = true;
   }
 
   return success;
 }