Switch to standard integer types in base/memory/.

base/memory/discardable_shared_memory_unittest.cc

 // Copyright 2014 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/basictypes.h"
+#include <stdint.h>
+
 #include "base/memory/discardable_shared_memory.h"
 #include "base/process/process_metrics.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace {
 
 class TestDiscardableSharedMemory : public DiscardableSharedMemory {
  public:
   TestDiscardableSharedMemory() {}
 
   explicit TestDiscardableSharedMemory(SharedMemoryHandle handle)
       : DiscardableSharedMemory(handle) {}
 
   void SetNow(Time now) { now_ = now; }
 
  private:
   // Overriden from DiscardableSharedMemory:
   Time Now() const override { return now_; }
 
   Time now_;
 };
 
 TEST(DiscardableSharedMemoryTest, CreateAndMap) {
-  const uint32 kDataSize = 1024;
+  const uint32_t kDataSize = 1024;
 
   TestDiscardableSharedMemory memory;
   bool rv = memory.CreateAndMap(kDataSize);
   ASSERT_TRUE(rv);
   EXPECT_GE(memory.mapped_size(), kDataSize);
   EXPECT_TRUE(memory.IsMemoryLocked());
 }
 
 TEST(DiscardableSharedMemoryTest, CreateFromHandle) {
-  const uint32 kDataSize = 1024;
+  const uint32_t kDataSize = 1024;
 
   TestDiscardableSharedMemory memory1;
   bool rv = memory1.CreateAndMap(kDataSize);
   ASSERT_TRUE(rv);
 
   SharedMemoryHandle shared_handle;
   ASSERT_TRUE(
       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
 
   TestDiscardableSharedMemory memory2(shared_handle);
   rv = memory2.Map(kDataSize);
   ASSERT_TRUE(rv);
   EXPECT_TRUE(memory2.IsMemoryLocked());
 }
 
 TEST(DiscardableSharedMemoryTest, LockAndUnlock) {
-  const uint32 kDataSize = 1024;
+  const uint32_t kDataSize = 1024;
 
   TestDiscardableSharedMemory memory1;
   bool rv = memory1.CreateAndMap(kDataSize);
   ASSERT_TRUE(rv);
 
   // Memory is initially locked. Unlock it.
   memory1.SetNow(Time::FromDoubleT(1));
   memory1.Unlock(0, 0);
   EXPECT_FALSE(memory1.IsMemoryLocked());
 
@@ skipping 33 matching lines @@
   rv = memory1.IsMemoryResident();
   EXPECT_TRUE(rv);
   EXPECT_TRUE(memory1.IsMemoryLocked());
 
   // Unlock first instance.
   memory1.SetNow(Time::FromDoubleT(4));
   memory1.Unlock(0, 0);
 }
 
 TEST(DiscardableSharedMemoryTest, Purge) {
-  const uint32 kDataSize = 1024;
+  const uint32_t kDataSize = 1024;
 
   TestDiscardableSharedMemory memory1;
   bool rv = memory1.CreateAndMap(kDataSize);
   ASSERT_TRUE(rv);
 
   SharedMemoryHandle shared_handle;
   ASSERT_TRUE(
       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
 
@@ skipping 21 matching lines @@
   EXPECT_TRUE(rv);
 
   // Lock should fail as memory has been purged.
   auto lock_rv = memory2.Lock(0, 0);
   EXPECT_EQ(DiscardableSharedMemory::FAILED, lock_rv);
 
   ASSERT_FALSE(memory2.IsMemoryResident());
 }
 
 TEST(DiscardableSharedMemoryTest, LastUsed) {
-  const uint32 kDataSize = 1024;
+  const uint32_t kDataSize = 1024;
 
   TestDiscardableSharedMemory memory1;
   bool rv = memory1.CreateAndMap(kDataSize);
   ASSERT_TRUE(rv);
 
   SharedMemoryHandle shared_handle;
   ASSERT_TRUE(
       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
 
@@ skipping 47 matching lines @@
   // The failed purge attempt should have updated usage time to the correct
   // value.
   EXPECT_TRUE(memory1.last_known_usage().is_null());
 
   // Purge should succeed now that usage time is correct.
   rv = memory1.Purge(Time::FromDoubleT(7));
   EXPECT_TRUE(rv);
 }
 
 TEST(DiscardableSharedMemoryTest, LockShouldAlwaysFailAfterSuccessfulPurge) {
-  const uint32 kDataSize = 1024;
+  const uint32_t kDataSize = 1024;
 
   TestDiscardableSharedMemory memory1;
   bool rv = memory1.CreateAndMap(kDataSize);
   ASSERT_TRUE(rv);
 
   SharedMemoryHandle shared_handle;
   ASSERT_TRUE(
       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
 
   TestDiscardableSharedMemory memory2(shared_handle);
   rv = memory2.Map(kDataSize);
   ASSERT_TRUE(rv);
 
   memory2.SetNow(Time::FromDoubleT(1));
   memory2.Unlock(0, 0);
 
   rv = memory2.Purge(Time::FromDoubleT(2));
   EXPECT_TRUE(rv);
 
   // Lock should fail as memory has been purged.
   auto lock_rv = memory2.Lock(0, 0);
   EXPECT_EQ(DiscardableSharedMemory::FAILED, lock_rv);
 }
 
 TEST(DiscardableSharedMemoryTest, LockAndUnlockRange) {
-  const uint32 kDataSize = 32;
+  const uint32_t kDataSize = 32;
 
-  uint32 data_size_in_bytes = kDataSize * base::GetPageSize();
+  uint32_t data_size_in_bytes = kDataSize * base::GetPageSize();
 
   TestDiscardableSharedMemory memory1;
   bool rv = memory1.CreateAndMap(data_size_in_bytes);
   ASSERT_TRUE(rv);
 
   SharedMemoryHandle shared_handle;
   ASSERT_TRUE(
       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
 
@@ skipping 38 matching lines @@
   // The failed purge attempt should have updated usage time to the correct
   // value.
   EXPECT_EQ(Time::FromDoubleT(8), memory1.last_known_usage());
 
   // Purge should now succeed.
   rv = memory1.Purge(Time::FromDoubleT(10));
   EXPECT_TRUE(rv);
 }
 
 TEST(DiscardableSharedMemoryTest, MappedSize) {
-  const uint32 kDataSize = 1024;
+  const uint32_t kDataSize = 1024;
 
   TestDiscardableSharedMemory memory;
   bool rv = memory.CreateAndMap(kDataSize);
   ASSERT_TRUE(rv);
 
   EXPECT_LE(kDataSize, memory.mapped_size());
 
   // Mapped size should be 0 after memory segment has been unmapped.
   rv = memory.Unmap();
   EXPECT_TRUE(rv);
   EXPECT_EQ(0u, memory.mapped_size());
 }
 
 TEST(DiscardableSharedMemoryTest, Close) {
-  const uint32 kDataSize = 1024;
+  const uint32_t kDataSize = 1024;
 
   TestDiscardableSharedMemory memory;
   bool rv = memory.CreateAndMap(kDataSize);
   ASSERT_TRUE(rv);
 
   // Mapped size should be unchanged after memory segment has been closed.
   memory.Close();
   EXPECT_LE(kDataSize, memory.mapped_size());
 
   // Memory is initially locked. Unlock it.
   memory.SetNow(Time::FromDoubleT(1));
   memory.Unlock(0, 0);
 
   // Lock and unlock memory.
   auto lock_rv = memory.Lock(0, 0);
   EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv);
   memory.SetNow(Time::FromDoubleT(2));
   memory.Unlock(0, 0);
 }
 
 // This test checks that zero-filled pages are returned after purging a segment
 // when DISCARDABLE_SHARED_MEMORY_ZERO_FILL_ON_DEMAND_PAGES_AFTER_PURGE is
 // defined and MADV_REMOVE is supported.
 #if defined(DISCARDABLE_SHARED_MEMORY_ZERO_FILL_ON_DEMAND_PAGES_AFTER_PURGE)
 TEST(DiscardableSharedMemoryTest, ZeroFilledPagesAfterPurge) {
-  const uint32 kDataSize = 1024;
+  const uint32_t kDataSize = 1024;
 
   TestDiscardableSharedMemory memory1;
   bool rv = memory1.CreateAndMap(kDataSize);
   ASSERT_TRUE(rv);
 
   SharedMemoryHandle shared_handle;
   ASSERT_TRUE(
       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
 
@@ skipping 10 matching lines @@
   EXPECT_FALSE(memory1.IsMemoryLocked());
 
   // Memory is unlocked, but our usage timestamp is incorrect.
   rv = memory1.Purge(Time::FromDoubleT(2));
   EXPECT_FALSE(rv);
   rv = memory1.Purge(Time::FromDoubleT(3));
   EXPECT_TRUE(rv);
 
   // Check that reading memory after it has been purged is returning
   // zero-filled pages.
-  uint8 expected_data[kDataSize] = {};
+  uint8_t expected_data[kDataSize] = {};
   EXPECT_EQ(memcmp(memory2.memory(), expected_data, kDataSize), 0);
 }
 #endif
 
 }  // namespace
 }  // namespace base