Harden allocator for file-backed memory.

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 <memory>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 82 matching lines @@
 };
 
 TEST_F(PersistentMemoryAllocatorTest, AllocateAndIterate) {
   allocator_->CreateTrackingHistograms(allocator_->Name());
 
   std::string base_name(TEST_NAME);
   EXPECT_EQ(TEST_ID, allocator_->Id());
   EXPECT_TRUE(allocator_->used_histogram_);
   EXPECT_EQ("UMA.PersistentAllocator." + base_name + ".UsedPct",
             allocator_->used_histogram_->histogram_name());
+  EXPECT_EQ(PersistentMemoryAllocator::MEMORY_INITIALIZED,
+            allocator_->GetMemoryState());
 
   // Get base memory info for later comparison.
   PersistentMemoryAllocator::MemoryInfo meminfo0;
   allocator_->GetMemoryInfo(&meminfo0);
   EXPECT_EQ(TEST_MEMORY_SIZE, meminfo0.total);
   EXPECT_GT(meminfo0.total, meminfo0.free);
 
   // Validate allocation of test object and make sure it can be referenced
   // and all metadata looks correct.
   TestObject1* obj1 = allocator_->New<TestObject1>();
@@ skipping 134 matching lines @@
 
   // Ensure that GetNextOfObject works.
   PersistentMemoryAllocator::Iterator iter1d(allocator_.get());
   EXPECT_EQ(obj2, iter1d.GetNextOfObject<TestObject2>());
   EXPECT_EQ(nullptr, iter1d.GetNextOfObject<TestObject2>());
 
   // Ensure that deleting an object works.
   allocator_->Delete(obj2);
   PersistentMemoryAllocator::Iterator iter1z(allocator_.get());
   EXPECT_EQ(nullptr, iter1z.GetNextOfObject<TestObject2>());
+
+  // Ensure that the memory state can be set.
+  allocator_->SetMemoryState(PersistentMemoryAllocator::MEMORY_DELETED);
+  EXPECT_EQ(PersistentMemoryAllocator::MEMORY_DELETED,
+            allocator_->GetMemoryState());
 }
 
 TEST_F(PersistentMemoryAllocatorTest, PageTest) {
   // This allocation will go into the first memory page.
   Reference block1 = allocator_->Allocate(TEST_MEMORY_PAGE / 2, 1);
   EXPECT_LT(0U, block1);
   EXPECT_GT(TEST_MEMORY_PAGE, block1);
 
   // This allocation won't fit in same page as previous block.
   Reference block2 =
@@ skipping 417 matching lines @@
     ASSERT_TRUE(writer.IsValid());
     writer.Write(0, (const char*)local.data(), local.used());
   }
 
   std::unique_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(std::move(mmfile), 0, 0, "", true);
-  EXPECT_TRUE(file.IsReadonly());
+  FilePersistentMemoryAllocator file(std::move(mmfile), 0, 0, "", false);
+  EXPECT_FALSE(file.IsReadonly());
   EXPECT_EQ(TEST_ID, file.Id());
   EXPECT_FALSE(file.IsFull());
   EXPECT_FALSE(file.IsCorrupt());
 
   PersistentMemoryAllocator::Iterator iter(&file);
   uint32_t type;
   EXPECT_EQ(r123, iter.GetNext(&type));
   EXPECT_EQ(r789, iter.GetNext(&type));
   EXPECT_EQ(0U, iter.GetNext(&type));
 
   EXPECT_EQ(123U, file.GetType(r123));
   EXPECT_EQ(654U, file.GetType(r456));
   EXPECT_EQ(789U, file.GetType(r789));
 
   PersistentMemoryAllocator::MemoryInfo meminfo2;
   file.GetMemoryInfo(&meminfo2);
   EXPECT_GE(meminfo1.total, meminfo2.total);
   EXPECT_GE(meminfo1.free, meminfo2.free);
   EXPECT_EQ(mmlength, meminfo2.total);
   EXPECT_EQ(0U, meminfo2.free);
+
+  // There's no way of knowing if Flush actually does anything but at least
+  // verify that it runs without CHECK violations.
+  file.Flush(false);
+  file.Flush(true);
 }
 
 TEST(FilePersistentMemoryAllocatorTest, ExtendTest) {
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath file_path = temp_dir.GetPath().AppendASCII("extend_test");
   MemoryMappedFile::Region region = {0, 16 << 10};  // 16KiB maximum size.
 
   // Start with a small but valid file of persistent data.
   ASSERT_FALSE(PathExists(file_path));
@@ skipping 131 matching lines @@
       // 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  // !defined(OS_NACL)
 
 }  // namespace base