Switch to standard integer types in chrome/.

chrome/installer/util/set_reg_value_work_item.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/set_reg_value_work_item.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/win/registry.h"
 #include "chrome/installer/util/logging_installer.h"
 
 namespace {
 
 // Transforms |str_value| into the byte-by-byte representation of its underlying
 // string, stores the result in |binary_data|.
 void StringToBinaryData(const std::wstring& str_value,
-                        std::vector<uint8>* binary_data) {
+                        std::vector<uint8_t>* binary_data) {
   DCHECK(binary_data);
-  const uint8* data = reinterpret_cast<const uint8*>(str_value.c_str());
+  const uint8_t* data = reinterpret_cast<const uint8_t*>(str_value.c_str());
   binary_data->assign(data, data + (str_value.length() + 1) * sizeof(wchar_t));
 }
 
 // Transforms |binary_data| into its wstring representation (assuming
 // |binary_data| is a sequence of wchar_t's).
-void BinaryDataToString(const std::vector<uint8>& binary_data,
+void BinaryDataToString(const std::vector<uint8_t>& binary_data,
                         std::wstring* str_value) {
   DCHECK(str_value);
   if (binary_data.size() < sizeof(wchar_t)) {
     str_value->clear();
     return;
   }
 
   str_value->assign(reinterpret_cast<const wchar_t*>(&binary_data[0]),
                     binary_data.size() / sizeof(wchar_t));
 
@@ skipping 40 matching lines @@
       key_path_(key_path),
       value_name_(value_name),
       overwrite_(overwrite),
       wow64_access_(wow64_access),
       type_(REG_DWORD),
       previous_type_(0),
       status_(SET_VALUE) {
   DCHECK(wow64_access == 0 ||
          wow64_access == KEY_WOW64_32KEY ||
          wow64_access == KEY_WOW64_64KEY);
-  const uint8* data = reinterpret_cast<const uint8*>(&value_data);
+  const uint8_t* data = reinterpret_cast<const uint8_t*>(&value_data);
   value_.assign(data, data + sizeof(value_data));
 }
 
 SetRegValueWorkItem::SetRegValueWorkItem(HKEY predefined_root,
                                          const std::wstring& key_path,
                                          REGSAM wow64_access,
                                          const std::wstring& value_name,
-                                         int64 value_data,
+                                         int64_t value_data,
                                          bool overwrite)
     : predefined_root_(predefined_root),
       key_path_(key_path),
       value_name_(value_name),
       overwrite_(overwrite),
       wow64_access_(wow64_access),
       type_(REG_QWORD),
       previous_type_(0),
       status_(SET_VALUE) {
   DCHECK(wow64_access == 0 ||
          wow64_access == KEY_WOW64_32KEY ||
          wow64_access == KEY_WOW64_64KEY);
-  const uint8* data = reinterpret_cast<const uint8*>(&value_data);
+  const uint8_t* data = reinterpret_cast<const uint8_t*>(&value_data);
   value_.assign(data, data + sizeof(value_data));
 }
 
 SetRegValueWorkItem::SetRegValueWorkItem(
     HKEY predefined_root,
     const std::wstring& key_path,
     REGSAM wow64_access,
     const std::wstring& value_name,
     const GetValueFromExistingCallback& get_value_callback)
     : predefined_root_(predefined_root),
@@ skipping 110 matching lines @@
     result = key.WriteValue(value_name_.c_str(), previous_value,
                             static_cast<DWORD>(previous_value_.size()),
                             previous_type_);
     VLOG(1) << "rollback: restoring " << value_name_ << " error: " << result;
   } else {
     NOTREACHED();
   }
 
   status_ = VALUE_ROLL_BACK;
 }