Add SharedMemory version of PersistentMemoryAllocator.

base/metrics/persistent_memory_allocator_unittest.cc

 // Copyright 2015 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/metrics/persistent_memory_allocator.h"
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/shared_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/strings/safe_sprintf.h"
 #include "base/threading/simple_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace {
 
 const uint32_t TEST_MEMORY_SIZE = 1 << 20;   // 1 MiB
 const uint32_t TEST_MEMORY_PAGE = 64 << 10;  // 64 KiB
@@ skipping 358 matching lines @@
 
 TEST(LocalPersistentMemoryAllocatorTest, CreationTest) {
   LocalPersistentMemoryAllocator allocator(TEST_MEMORY_SIZE, 42, "");
   EXPECT_EQ(42U, allocator.Id());
   EXPECT_NE(0U, allocator.Allocate(24, 1));
   EXPECT_FALSE(allocator.IsFull());
   EXPECT_FALSE(allocator.IsCorrupt());
 }
 
 
+//----- SharedPersistentMemoryAllocator ----------------------------------------
+
+TEST(SharedPersistentMemoryAllocatorTest, CreationTest) {
+  SharedMemoryHandle shared_handle;
+
+  PersistentMemoryAllocator::MemoryInfo meminfo1;
+  Reference r123, r456, r789;
+  {
+    scoped_ptr<SharedMemory> shmem1(new SharedMemory());
+    ASSERT_TRUE(shmem1->CreateAndMapAnonymous(TEST_MEMORY_SIZE));
+    SharedPersistentMemoryAllocator local(std::move(shmem1), TEST_ID, "",
+                                          false);
+    EXPECT_FALSE(local.IsReadonly());
+    r123 = local.Allocate(123, 123);
+    r456 = local.Allocate(456, 456);
+    r789 = local.Allocate(789, 789);
+    local.MakeIterable(r123);
+    local.SetType(r456, 654);
+    local.MakeIterable(r789);
+    local.GetMemoryInfo(&meminfo1);
+    EXPECT_FALSE(local.IsFull());
+    EXPECT_FALSE(local.IsCorrupt());
+
+    ASSERT_TRUE(local.GetSharedMemory()->ShareToProcess(
+                    GetCurrentProcessHandle(),
+                    &shared_handle));
+  }
+
+  // Read-only test.
+  scoped_ptr<SharedMemory> shmem2(new SharedMemory(shared_handle,
+                                                   /*readonly=*/true));
+  ASSERT_TRUE(shmem2->Map(TEST_MEMORY_SIZE));
+
+  SharedPersistentMemoryAllocator shalloc2(std::move(shmem2), 0, "", true);
+  EXPECT_TRUE(shalloc2.IsReadonly());
+  EXPECT_EQ(TEST_ID, shalloc2.Id());
+  EXPECT_FALSE(shalloc2.IsFull());
+  EXPECT_FALSE(shalloc2.IsCorrupt());
+
+  PersistentMemoryAllocator::Iterator iter2;
+  uint32_t type;
+  shalloc2.CreateIterator(&iter2);
+  EXPECT_EQ(r123, shalloc2.GetNextIterable(&iter2, &type));
+  EXPECT_EQ(r789, shalloc2.GetNextIterable(&iter2, &type));
+  EXPECT_EQ(0U, shalloc2.GetNextIterable(&iter2, &type));
+
+  EXPECT_EQ(123U, shalloc2.GetType(r123));
+  EXPECT_EQ(654U, shalloc2.GetType(r456));
+  EXPECT_EQ(789U, shalloc2.GetType(r789));
+
+  PersistentMemoryAllocator::MemoryInfo meminfo2;
+  shalloc2.GetMemoryInfo(&meminfo2);
+  EXPECT_EQ(meminfo1.total, meminfo2.total);
+  EXPECT_EQ(meminfo1.free, meminfo2.free);
+
+  // Read/write test.
+  scoped_ptr<SharedMemory> shmem3(new SharedMemory(shared_handle,
+                                                   /*readonly=*/false));
+  ASSERT_TRUE(shmem3->Map(TEST_MEMORY_SIZE));
+
+  SharedPersistentMemoryAllocator shalloc3(std::move(shmem3), 0, "", false);
+  EXPECT_FALSE(shalloc3.IsReadonly());
+  EXPECT_EQ(TEST_ID, shalloc3.Id());
+  EXPECT_FALSE(shalloc3.IsFull());
+  EXPECT_FALSE(shalloc3.IsCorrupt());
+
+  PersistentMemoryAllocator::Iterator iter3;
+  shalloc3.CreateIterator(&iter3);
+  EXPECT_EQ(r123, shalloc3.GetNextIterable(&iter3, &type));
+  EXPECT_EQ(r789, shalloc3.GetNextIterable(&iter3, &type));
+  EXPECT_EQ(0U, shalloc3.GetNextIterable(&iter3, &type));
+
+  EXPECT_EQ(123U, shalloc3.GetType(r123));
+  EXPECT_EQ(654U, shalloc3.GetType(r456));
+  EXPECT_EQ(789U, shalloc3.GetType(r789));
+
+  PersistentMemoryAllocator::MemoryInfo meminfo3;
+  shalloc3.GetMemoryInfo(&meminfo3);
+  EXPECT_EQ(meminfo1.total, meminfo3.total);
+  EXPECT_EQ(meminfo1.free, meminfo3.free);
+
+  // Interconnectivity test.
+  Reference obj = shalloc3.Allocate(42, 42);
+  ASSERT_TRUE(obj);
+  shalloc3.MakeIterable(obj);
+  EXPECT_EQ(obj, shalloc2.GetNextIterable(&iter2, &type));
+  EXPECT_EQ(42U, type);
+}
+
+
 //----- FilePersistentMemoryAllocator ------------------------------------------
 
 TEST(FilePersistentMemoryAllocatorTest, CreationTest) {
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath file_path = temp_dir.path().AppendASCII("persistent_memory");
 
   PersistentMemoryAllocator::MemoryInfo meminfo1;
   Reference r123, r456, r789;
   {
@@ skipping 13 matching lines @@
     ASSERT_TRUE(writer.IsValid());
     writer.Write(0, (const char*)local.data(), local.used());
   }
 
   scoped_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
   mmfile->Initialize(file_path);
   EXPECT_TRUE(mmfile->IsValid());
   const size_t mmlength = mmfile->length();
   EXPECT_GE(meminfo1.total, mmlength);
 
-  FilePersistentMemoryAllocator file(mmfile.release(), 0, "");
+  FilePersistentMemoryAllocator file(std::move(mmfile), 0, "");
   EXPECT_TRUE(file.IsReadonly());
   EXPECT_EQ(TEST_ID, file.Id());
   EXPECT_FALSE(file.IsFull());
   EXPECT_FALSE(file.IsCorrupt());
 
   PersistentMemoryAllocator::Iterator iter;
   uint32_t type;
   file.CreateIterator(&iter);
   EXPECT_EQ(r123, file.GetNextIterable(&iter, &type));
   EXPECT_EQ(r789, file.GetNextIterable(&iter, &type));
@@ skipping 32 matching lines @@
       ASSERT_TRUE(writer.IsValid());
       writer.Write(0, (const char*)local.data(), filesize);
     }
     ASSERT_TRUE(PathExists(file_path));
 
     mmfile.reset(new MemoryMappedFile());
     mmfile->Initialize(file_path);
     EXPECT_EQ(filesize, mmfile->length());
     if (FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile)) {
       // Just need to make sure it doesn't crash.
-      FilePersistentMemoryAllocator allocator(mmfile.release(), 0, "");
+      FilePersistentMemoryAllocator allocator(std::move(mmfile), 0, "");
       (void)allocator;  // Ensure compiler can't optimize-out above variable.
     } else {
       // For filesize >= minsize, the file must be acceptable. This
       // else clause (file-not-acceptable) should be reached only if
       // filesize < minsize.
       EXPECT_LT(filesize, minsize);
     }
 
 #if !DCHECK_IS_ON()  // DCHECK builds will die at a NOTREACHED().
     strings::SafeSPrintf(filename, "memory_%d_B", filesize);
     file_path = temp_dir.path().AppendASCII(filename);
     ASSERT_FALSE(PathExists(file_path));
     {
       File writer(file_path, File::FLAG_CREATE | File::FLAG_WRITE);
       ASSERT_TRUE(writer.IsValid());
       writer.Write(0, (const char*)garbage.get(), filesize);
     }
     ASSERT_TRUE(PathExists(file_path));
 
     mmfile.reset(new MemoryMappedFile());
     mmfile->Initialize(file_path);
     EXPECT_EQ(filesize, mmfile->length());
     if (FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile)) {
       // Just need to make sure it doesn't crash.
-      FilePersistentMemoryAllocator allocator(mmfile.release(), 0, "") ;
+      FilePersistentMemoryAllocator allocator(std::move(mmfile), 0, "");
       EXPECT_TRUE(allocator.IsCorrupt());  // Garbage data so it should be.
     } else {
       // For filesize >= minsize, the file must be acceptable. This
       // else clause (file-not-acceptable) should be reached only if
       // filesize < minsize.
       EXPECT_GT(minsize, filesize);
     }
 #endif
   }
 }
 
 }  // namespace base