Switch to standard integer types in base/win/.

base/win/registry_unittest.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 "base/win/registry.h"
 
+#include <stdint.h>
+
 #include <cstring>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/win/windows_version.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace win {
 
 namespace {
@@ skipping 57 matching lines @@
   {
     ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, foo_key.c_str(),
                                       KEY_READ | KEY_SET_VALUE));
     ASSERT_TRUE(key.Valid());
 
     const wchar_t kStringValueName[] = L"StringValue";
     const wchar_t kDWORDValueName[] = L"DWORDValue";
     const wchar_t kInt64ValueName[] = L"Int64Value";
     const wchar_t kStringData[] = L"string data";
     const DWORD kDWORDData = 0xdeadbabe;
-    const int64 kInt64Data = 0xdeadbabedeadbabeLL;
+    const int64_t kInt64Data = 0xdeadbabedeadbabeLL;
 
     // Test value creation
     ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kStringValueName, kStringData));
     ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kDWORDValueName, kDWORDData));
     ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kInt64ValueName, &kInt64Data,
                                             sizeof(kInt64Data), REG_QWORD));
     EXPECT_EQ(3U, key.GetValueCount());
     EXPECT_TRUE(key.HasValue(kStringValueName));
     EXPECT_TRUE(key.HasValue(kDWORDValueName));
     EXPECT_TRUE(key.HasValue(kInt64ValueName));
 
     // Test Read
     std::wstring string_value;
     DWORD dword_value = 0;
-    int64 int64_value = 0;
+    int64_t int64_value = 0;
     ASSERT_EQ(ERROR_SUCCESS, key.ReadValue(kStringValueName, &string_value));
     ASSERT_EQ(ERROR_SUCCESS, key.ReadValueDW(kDWORDValueName, &dword_value));
     ASSERT_EQ(ERROR_SUCCESS, key.ReadInt64(kInt64ValueName, &int64_value));
     EXPECT_STREQ(kStringData, string_value.c_str());
     EXPECT_EQ(kDWORDData, dword_value);
     EXPECT_EQ(kInt64Data, int64_value);
 
     // Make sure out args are not touched if ReadValue fails
     const wchar_t* kNonExistent = L"NonExistent";
     ASSERT_NE(ERROR_SUCCESS, key.ReadValue(kNonExistent, &string_value));
@@ skipping 44 matching lines @@
   std::wstring foo_key(kRootKey);
   foo_key += L"\\Foo";
   ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, foo_key.c_str(),
                                       KEY_READ));
   ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, foo_key.c_str(),
                                     KEY_READ | KEY_SET_VALUE));
   ASSERT_TRUE(key.Valid());
 
   const wchar_t kName[] = L"name";
   // kData size is not a multiple of sizeof(wchar_t).
-  const uint8 kData[] = { 1, 2, 3, 4, 5 };
+  const uint8_t kData[] = {1, 2, 3, 4, 5};
   EXPECT_EQ(5u, arraysize(kData));
   ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kName, kData,
                                           arraysize(kData), REG_BINARY));
 
   RegistryValueIterator iterator(HKEY_CURRENT_USER, foo_key.c_str());
   ASSERT_TRUE(iterator.Valid());
   EXPECT_STREQ(kName, iterator.Name());
   // ValueSize() is in bytes.
   ASSERT_EQ(arraysize(kData), iterator.ValueSize());
   // Value() is NUL terminated.
@@ skipping 231 matching lines @@
   ASSERT_TRUE(key.StartWatching(Bind(&TestChangeDelegate::OnKeyChanged,
                                      Unretained(&delegate))));
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(delegate.WasCalled());
 }
 
 }  // namespace
 
 }  // namespace win
 }  // namespace base