//base: Make ScopedTempDir::path() a GetPath() with a DCHECK

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 595 matching lines @@
   EXPECT_EQ(42U, type);
 }
 
 
 #if !defined(OS_NACL)
 //----- FilePersistentMemoryAllocator ------------------------------------------
 
 TEST(FilePersistentMemoryAllocatorTest, CreationTest) {
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("persistent_memory");
+  FilePath file_path = temp_dir.GetPath().AppendASCII("persistent_memory");
 
   PersistentMemoryAllocator::MemoryInfo meminfo1;
   Reference r123, r456, r789;
   {
     LocalPersistentMemoryAllocator local(TEST_MEMORY_SIZE, TEST_ID, "");
     EXPECT_FALSE(local.IsReadonly());
     r123 = local.Allocate(123, 123);
     r456 = local.Allocate(456, 456);
     r789 = local.Allocate(789, 789);
     local.MakeIterable(r123);
@@ skipping 34 matching lines @@
   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);
 }
 
 TEST(FilePersistentMemoryAllocatorTest, ExtendTest) {
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("extend_test");
+  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));
   {
     LocalPersistentMemoryAllocator local(TEST_MEMORY_SIZE, TEST_ID, "");
     local.Allocate(1, 1);
     local.Allocate(11, 11);
 
     File writer(file_path, File::FLAG_CREATE | File::FLAG_WRITE);
@@ skipping 45 matching lines @@
   local.MakeIterable(local.Allocate(1, 1));
   local.MakeIterable(local.Allocate(11, 11));
   const size_t minsize = local.used();
   std::unique_ptr<char[]> garbage(new char[minsize]);
   RandBytes(garbage.get(), minsize);
 
   std::unique_ptr<MemoryMappedFile> mmfile;
   char filename[100];
   for (size_t filesize = minsize; filesize > 0; --filesize) {
     strings::SafeSPrintf(filename, "memory_%d_A", filesize);
-    FilePath file_path = temp_dir.path().AppendASCII(filename);
+    FilePath file_path = temp_dir.GetPath().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*)local.data(), filesize);
     }
     ASSERT_TRUE(PathExists(file_path));
 
     // Request read/write access for some sizes that are a multple of the
     // allocator's alignment size. The allocator is strict about file size
@@ skipping 29 matching lines @@
       // Ensure that short files are detected as corrupt and full files are not.
       EXPECT_EQ(filesize != minsize, allocator.IsCorrupt());
     } 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);
     }
 
     strings::SafeSPrintf(filename, "memory_%d_B", filesize);
-    file_path = temp_dir.path().AppendASCII(filename);
+    file_path = temp_dir.GetPath().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(file_path, file_flags), map_access);
     EXPECT_EQ(filesize, mmfile->length());
     if (FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, read_only)) {
       // Make sure construction doesn't crash. It will, however, cause
       // error messages warning about about a corrupted memory segment.
       FilePersistentMemoryAllocator allocator(std::move(mmfile), 0, 0, "",
                                               read_only);
       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  // !defined(OS_NACL)
 
 }  // namespace base