Switch to standard integer types in base/memory/.

base/memory/shared_memory_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
+#include <stdint.h>
+
 #include "base/atomicops.h"
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/memory/shared_memory_handle.h"
 #include "base/process/kill.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/test/multiprocess_test.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
 #if defined(OS_POSIX)
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif
 
 namespace base {
 
 namespace {
 
 #if !defined(OS_MACOSX)
 // Each thread will open the shared memory.  Each thread will take a different 4
 // byte int pointer, and keep changing it, with some small pauses in between.
 // Verify that each thread's value in the shared memory is always correct.
 class MultipleThreadMain : public PlatformThread::Delegate {
  public:
-  explicit MultipleThreadMain(int16 id) : id_(id) {}
+  explicit MultipleThreadMain(int16_t id) : id_(id) {}
   ~MultipleThreadMain() override {}
 
   static void CleanUp() {
     SharedMemory memory;
     memory.Delete(s_test_name_);
   }
 
   // PlatformThread::Delegate interface.
   void ThreadMain() override {
-    const uint32 kDataSize = 1024;
+    const uint32_t kDataSize = 1024;
     SharedMemory memory;
     bool rv = memory.CreateNamedDeprecated(s_test_name_, true, kDataSize);
     EXPECT_TRUE(rv);
     rv = memory.Map(kDataSize);
     EXPECT_TRUE(rv);
     int* ptr = static_cast<int*>(memory.memory()) + id_;
     EXPECT_EQ(0, *ptr);
 
     for (int idx = 0; idx < 100; idx++) {
       *ptr = idx;
       PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
       EXPECT_EQ(*ptr, idx);
     }
     // Reset back to 0 for the next test that uses the same name.
     *ptr = 0;
 
     memory.Close();
   }
 
  private:
-  int16 id_;
+  int16_t id_;
 
   static const char s_test_name_[];
 
   DISALLOW_COPY_AND_ASSIGN(MultipleThreadMain);
 };
 
 const char MultipleThreadMain::s_test_name_[] =
     "SharedMemoryOpenThreadTest";
 #endif  // !defined(OS_MACOSX)
 
 }  // namespace
 
 // Android/Mac doesn't support SharedMemory::Open/Delete/
 // CreateNamedDeprecated(openExisting=true)
 #if !defined(OS_ANDROID) && !defined(OS_MACOSX)
 TEST(SharedMemoryTest, OpenClose) {
-  const uint32 kDataSize = 1024;
+  const uint32_t kDataSize = 1024;
   std::string test_name = "SharedMemoryOpenCloseTest";
 
   // Open two handles to a memory segment, confirm that they are mapped
   // separately yet point to the same space.
   SharedMemory memory1;
   bool rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory1.Open(test_name, false);
@@ skipping 27 matching lines @@
   // Close the second memory segment.
   memory2.Close();
 
   rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory2.Delete(test_name);
   EXPECT_TRUE(rv);
 }
 
 TEST(SharedMemoryTest, OpenExclusive) {
-  const uint32 kDataSize = 1024;
-  const uint32 kDataSize2 = 2048;
+  const uint32_t kDataSize = 1024;
+  const uint32_t kDataSize2 = 2048;
   std::ostringstream test_name_stream;
   test_name_stream << "SharedMemoryOpenExclusiveTest."
                    << Time::Now().ToDoubleT();
   std::string test_name = test_name_stream.str();
 
   // Open two handles to a memory segment and check that
   // open_existing_deprecated works as expected.
   SharedMemory memory1;
   bool rv = memory1.CreateNamedDeprecated(test_name, false, kDataSize);
   EXPECT_TRUE(rv);
@@ skipping 91 matching lines @@
   int threadcounts[] = { 1, kNumThreads };
   for (size_t i = 0; i < arraysize(threadcounts); i++) {
     int numthreads = threadcounts[i];
     scoped_ptr<PlatformThreadHandle[]> thread_handles;
     scoped_ptr<MultipleThreadMain*[]> thread_delegates;
 
     thread_handles.reset(new PlatformThreadHandle[numthreads]);
     thread_delegates.reset(new MultipleThreadMain*[numthreads]);
 
     // Spawn the threads.
-    for (int16 index = 0; index < numthreads; index++) {
+    for (int16_t index = 0; index < numthreads; index++) {
       PlatformThreadHandle pth;
       thread_delegates[index] = new MultipleThreadMain(index);
       EXPECT_TRUE(PlatformThread::Create(0, thread_delegates[index], &pth));
       thread_handles[index] = pth;
     }
 
     // Wait for the threads to finish.
     for (int index = 0; index < numthreads; index++) {
       PlatformThread::Join(thread_handles[index]);
       delete thread_delegates[index];
     }
   }
   MultipleThreadMain::CleanUp();
 }
 #endif
 
 // Allocate private (unique) shared memory with an empty string for a
 // name.  Make sure several of them don't point to the same thing as
 // we might expect if the names are equal.
 TEST(SharedMemoryTest, AnonymousPrivate) {
   int i, j;
   int count = 4;
   bool rv;
-  const uint32 kDataSize = 8192;
+  const uint32_t kDataSize = 8192;
 
   scoped_ptr<SharedMemory[]> memories(new SharedMemory[count]);
   scoped_ptr<int*[]> pointers(new int*[count]);
   ASSERT_TRUE(memories.get());
   ASSERT_TRUE(pointers.get());
 
   for (i = 0; i < count; i++) {
     rv = memories[i].CreateAndMapAnonymous(kDataSize);
     EXPECT_TRUE(rv);
     int* ptr = static_cast<int*>(memories[i].memory());
@@ skipping 131 matching lines @@
   ASSERT_TRUE(shmem.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
   SharedMemory readonly(shared_handle, /*readonly=*/true);
 
   ASSERT_TRUE(readonly.Map(contents.size()));
   EXPECT_EQ(contents,
             StringPiece(static_cast<const char*>(readonly.memory()),
                         contents.size()));
 }
 
 TEST(SharedMemoryTest, MapAt) {
-  ASSERT_TRUE(SysInfo::VMAllocationGranularity() >= sizeof(uint32));
+  ASSERT_TRUE(SysInfo::VMAllocationGranularity() >= sizeof(uint32_t));
   const size_t kCount = SysInfo::VMAllocationGranularity();
-  const size_t kDataSize = kCount * sizeof(uint32);
+  const size_t kDataSize = kCount * sizeof(uint32_t);
 
   SharedMemory memory;
   ASSERT_TRUE(memory.CreateAndMapAnonymous(kDataSize));
-  uint32* ptr = static_cast<uint32*>(memory.memory());
+  uint32_t* ptr = static_cast<uint32_t*>(memory.memory());
   ASSERT_NE(ptr, static_cast<void*>(NULL));
 
   for (size_t i = 0; i < kCount; ++i) {
     ptr[i] = i;
   }
 
   memory.Unmap();
 
   off_t offset = SysInfo::VMAllocationGranularity();
   ASSERT_TRUE(memory.MapAt(offset, kDataSize - offset));
-  offset /= sizeof(uint32);
-  ptr = static_cast<uint32*>(memory.memory());
+  offset /= sizeof(uint32_t);
+  ptr = static_cast<uint32_t*>(memory.memory());
   ASSERT_NE(ptr, static_cast<void*>(NULL));
   for (size_t i = offset; i < kCount; ++i) {
     EXPECT_EQ(ptr[i - offset], i);
   }
 }
 
 TEST(SharedMemoryTest, MapTwice) {
-  const uint32 kDataSize = 1024;
+  const uint32_t kDataSize = 1024;
   SharedMemory memory;
   bool rv = memory.CreateAndMapAnonymous(kDataSize);
   EXPECT_TRUE(rv);
 
   void* old_address = memory.memory();
 
   rv = memory.Map(kDataSize);
   EXPECT_FALSE(rv);
   EXPECT_EQ(old_address, memory.memory());
 }
 
 #if defined(OS_POSIX)
 // This test is not applicable for iOS (crbug.com/399384).
 #if !defined(OS_IOS)
 // Create a shared memory object, mmap it, and mprotect it to PROT_EXEC.
 TEST(SharedMemoryTest, AnonymousExecutable) {
-  const uint32 kTestSize = 1 << 16;
+  const uint32_t kTestSize = 1 << 16;
 
   SharedMemory shared_memory;
   SharedMemoryCreateOptions options;
   options.size = kTestSize;
   options.executable = true;
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   // The Mach functionality is tested in shared_memory_mac_unittest.cc.
   options.type = SharedMemoryHandle::POSIX;
 #endif
 
@@ skipping 17 matching lines @@
     old_umask_ = umask(target_mask);
   }
   ~ScopedUmaskSetter() { umask(old_umask_); }
  private:
   mode_t old_umask_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedUmaskSetter);
 };
 
 // Create a shared memory object, check its permissions.
 TEST(SharedMemoryTest, FilePermissionsAnonymous) {
-  const uint32 kTestSize = 1 << 8;
+  const uint32_t kTestSize = 1 << 8;
 
   SharedMemory shared_memory;
   SharedMemoryCreateOptions options;
   options.size = kTestSize;
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   // The Mach functionality is tested in shared_memory_mac_unittest.cc.
   options.type = SharedMemoryHandle::POSIX;
 #endif
   // Set a file mode creation mask that gives all permissions.
   ScopedUmaskSetter permissive_mask(S_IWGRP | S_IWOTH);
@@ skipping 127 matching lines @@
       errors++;
     int* ptr = static_cast<int*>(memory.memory());
 
     // This runs concurrently in multiple processes. Writes need to be atomic.
     subtle::Barrier_AtomicIncrement(ptr, 1);
     memory.Close();
     return errors;
   }
 
   static const char s_test_name_[];
-  static const uint32 s_data_size_;
+  static const uint32_t s_data_size_;
 };
 
 const char SharedMemoryProcessTest::s_test_name_[] = "MPMem";
-const uint32 SharedMemoryProcessTest::s_data_size_ = 1024;
+const uint32_t SharedMemoryProcessTest::s_data_size_ = 1024;
 
 TEST_F(SharedMemoryProcessTest, SharedMemoryAcrossProcesses) {
   const int kNumTasks = 5;
 
   SharedMemoryProcessTest::CleanUp();
 
   // Create a shared memory region. Set the first word to 0.
   SharedMemory memory;
   bool rv = memory.CreateNamedDeprecated(s_test_name_, true, s_data_size_);
   ASSERT_TRUE(rv);
@@ skipping 23 matching lines @@
   memory.Close();
   SharedMemoryProcessTest::CleanUp();
 }
 
 MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
   return SharedMemoryProcessTest::TaskTestMain();
 }
 #endif  // !defined(OS_IOS) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 
 }  // namespace base