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

base/files/file_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 "base/files/file.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::File;
 using base::FilePath;
 
 TEST(FileTest, Create) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("create_file_1");
+  FilePath file_path = temp_dir.GetPath().AppendASCII("create_file_1");
 
   {
     // Don't create a File at all.
     File file;
     EXPECT_FALSE(file.IsValid());
     EXPECT_EQ(base::File::FILE_ERROR_FAILED, file.error_details());
 
     File file2(base::File::FILE_ERROR_TOO_MANY_OPENED);
     EXPECT_FALSE(file2.IsValid());
     EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, file2.error_details());
@@ skipping 51 matching lines @@
     // Create or overwrite a file.
     File file(file_path,
               base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
     EXPECT_TRUE(file.IsValid());
     EXPECT_TRUE(file.created());
     EXPECT_EQ(base::File::FILE_OK, file.error_details());
   }
 
   {
     // Create a delete-on-close file.
-    file_path = temp_dir.path().AppendASCII("create_file_2");
+    file_path = temp_dir.GetPath().AppendASCII("create_file_2");
     File file(file_path,
               base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ |
                   base::File::FLAG_DELETE_ON_CLOSE);
     EXPECT_TRUE(file.IsValid());
     EXPECT_TRUE(file.created());
     EXPECT_EQ(base::File::FILE_OK, file.error_details());
   }
 
   EXPECT_FALSE(base::PathExists(file_path));
 }
 
 TEST(FileTest, Async) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("create_file");
+  FilePath file_path = temp_dir.GetPath().AppendASCII("create_file");
 
   {
     File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_ASYNC);
     EXPECT_TRUE(file.IsValid());
     EXPECT_TRUE(file.async());
   }
 
   {
     File file(file_path, base::File::FLAG_OPEN_ALWAYS);
     EXPECT_TRUE(file.IsValid());
     EXPECT_FALSE(file.async());
   }
 }
 
 TEST(FileTest, DeleteOpenFile) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("create_file_1");
+  FilePath file_path = temp_dir.GetPath().AppendASCII("create_file_1");
 
   // Create a file.
   File file(file_path,
             base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ |
                 base::File::FLAG_SHARE_DELETE);
   EXPECT_TRUE(file.IsValid());
   EXPECT_TRUE(file.created());
   EXPECT_EQ(base::File::FILE_OK, file.error_details());
 
   // Open an existing file and mark it as delete on close.
   File same_file(file_path,
                  base::File::FLAG_OPEN | base::File::FLAG_DELETE_ON_CLOSE |
                      base::File::FLAG_READ);
   EXPECT_TRUE(file.IsValid());
   EXPECT_FALSE(same_file.created());
   EXPECT_EQ(base::File::FILE_OK, same_file.error_details());
 
   // Close both handles and check that the file is gone.
   file.Close();
   same_file.Close();
   EXPECT_FALSE(base::PathExists(file_path));
 }
 
 TEST(FileTest, ReadWrite) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("read_write_file");
+  FilePath file_path = temp_dir.GetPath().AppendASCII("read_write_file");
   File file(file_path,
             base::File::FLAG_CREATE | base::File::FLAG_READ |
                 base::File::FLAG_WRITE);
   ASSERT_TRUE(file.IsValid());
 
   char data_to_write[] = "test";
   const int kTestDataSize = 4;
 
   // Write 0 bytes to the file.
   int bytes_written = file.Write(0, data_to_write, 0);
@@ skipping 51 matching lines @@
     EXPECT_EQ(data_to_write[i], data_read_2[i]);
   for (int i = kTestDataSize; i < kOffsetBeyondEndOfFile; i++)
     EXPECT_EQ(0, data_read_2[i]);
   for (int i = kOffsetBeyondEndOfFile; i < file_size; i++)
     EXPECT_EQ(data_to_write[i - kOffsetBeyondEndOfFile], data_read_2[i]);
 }
 
 TEST(FileTest, Append) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("append_file");
+  FilePath file_path = temp_dir.GetPath().AppendASCII("append_file");
   File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_APPEND);
   ASSERT_TRUE(file.IsValid());
 
   char data_to_write[] = "test";
   const int kTestDataSize = 4;
 
   // Write 0 bytes to the file.
   int bytes_written = file.Write(0, data_to_write, 0);
   EXPECT_EQ(0, bytes_written);
 
@@ skipping 27 matching lines @@
   for (int i = 0; i < kTestDataSize; i++)
     EXPECT_EQ(data_to_write[i], data_read_1[i]);
   for (int i = 0; i < kAppendDataSize; i++)
     EXPECT_EQ(append_data_to_write[i], data_read_1[kTestDataSize + i]);
 }
 
 
 TEST(FileTest, Length) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("truncate_file");
+  FilePath file_path = temp_dir.GetPath().AppendASCII("truncate_file");
   File file(file_path,
             base::File::FLAG_CREATE | base::File::FLAG_READ |
                 base::File::FLAG_WRITE);
   ASSERT_TRUE(file.IsValid());
   EXPECT_EQ(0, file.GetLength());
 
   // Write "test" to the file.
   char data_to_write[] = "test";
   int kTestDataSize = 4;
   int bytes_written = file.Write(0, data_to_write, kTestDataSize);
@@ skipping 31 matching lines @@
 }
 
 // Flakily fails: http://crbug.com/86494
 #if defined(OS_ANDROID)
 TEST(FileTest, TouchGetInfo) {
 #else
 TEST(FileTest, DISABLED_TouchGetInfo) {
 #endif
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  File file(temp_dir.path().AppendASCII("touch_get_info_file"),
+  File file(temp_dir.GetPath().AppendASCII("touch_get_info_file"),
             base::File::FLAG_CREATE | base::File::FLAG_WRITE |
                 base::File::FLAG_WRITE_ATTRIBUTES);
   ASSERT_TRUE(file.IsValid());
 
   // Get info for a newly created file.
   base::File::Info info;
   EXPECT_TRUE(file.GetInfo(&info));
 
   // Add 2 seconds to account for possible rounding errors on
   // filesystems that use a 1s or 2s timestamp granularity.
@@ skipping 42 matching lines @@
             new_last_modified.ToInternalValue());
 #endif
 
   EXPECT_EQ(info.creation_time.ToInternalValue(),
             creation_time.ToInternalValue());
 }
 
 TEST(FileTest, ReadAtCurrentPosition) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("read_at_current_position");
+  FilePath file_path =
+      temp_dir.GetPath().AppendASCII("read_at_current_position");
   File file(file_path,
             base::File::FLAG_CREATE | base::File::FLAG_READ |
                 base::File::FLAG_WRITE);
   EXPECT_TRUE(file.IsValid());
 
   const char kData[] = "test";
   const int kDataSize = sizeof(kData) - 1;
   EXPECT_EQ(kDataSize, file.Write(0, kData, kDataSize));
 
   EXPECT_EQ(0, file.Seek(base::File::FROM_BEGIN, 0));
 
   char buffer[kDataSize];
   int first_chunk_size = kDataSize / 2;
   EXPECT_EQ(first_chunk_size, file.ReadAtCurrentPos(buffer, first_chunk_size));
   EXPECT_EQ(kDataSize - first_chunk_size,
             file.ReadAtCurrentPos(buffer + first_chunk_size,
                                   kDataSize - first_chunk_size));
   EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData));
 }
 
 TEST(FileTest, WriteAtCurrentPosition) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("write_at_current_position");
+  FilePath file_path =
+      temp_dir.GetPath().AppendASCII("write_at_current_position");
   File file(file_path,
             base::File::FLAG_CREATE | base::File::FLAG_READ |
                 base::File::FLAG_WRITE);
   EXPECT_TRUE(file.IsValid());
 
   const char kData[] = "test";
   const int kDataSize = sizeof(kData) - 1;
 
   int first_chunk_size = kDataSize / 2;
   EXPECT_EQ(first_chunk_size, file.WriteAtCurrentPos(kData, first_chunk_size));
   EXPECT_EQ(kDataSize - first_chunk_size,
             file.WriteAtCurrentPos(kData + first_chunk_size,
                                    kDataSize - first_chunk_size));
 
   char buffer[kDataSize];
   EXPECT_EQ(kDataSize, file.Read(0, buffer, kDataSize));
   EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData));
 }
 
 TEST(FileTest, Seek) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("seek_file");
+  FilePath file_path = temp_dir.GetPath().AppendASCII("seek_file");
   File file(file_path,
             base::File::FLAG_CREATE | base::File::FLAG_READ |
                 base::File::FLAG_WRITE);
   ASSERT_TRUE(file.IsValid());
 
   const int64_t kOffset = 10;
   EXPECT_EQ(kOffset, file.Seek(base::File::FROM_BEGIN, kOffset));
   EXPECT_EQ(2 * kOffset, file.Seek(base::File::FROM_CURRENT, kOffset));
   EXPECT_EQ(kOffset, file.Seek(base::File::FROM_CURRENT, -kOffset));
   EXPECT_TRUE(file.SetLength(kOffset * 2));
   EXPECT_EQ(kOffset, file.Seek(base::File::FROM_END, -kOffset));
 }
 
 TEST(FileTest, Duplicate) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("file");
+  FilePath file_path = temp_dir.GetPath().AppendASCII("file");
   File file(file_path,(base::File::FLAG_CREATE |
                        base::File::FLAG_READ |
                        base::File::FLAG_WRITE));
   ASSERT_TRUE(file.IsValid());
 
   File file2(file.Duplicate());
   ASSERT_TRUE(file2.IsValid());
 
   // Write through one handle, close it, read through the other.
   static const char kData[] = "now is a good time.";
   static const int kDataLen = sizeof(kData) - 1;
 
   ASSERT_EQ(0, file.Seek(base::File::FROM_CURRENT, 0));
   ASSERT_EQ(0, file2.Seek(base::File::FROM_CURRENT, 0));
   ASSERT_EQ(kDataLen, file.WriteAtCurrentPos(kData, kDataLen));
   ASSERT_EQ(kDataLen, file.Seek(base::File::FROM_CURRENT, 0));
   ASSERT_EQ(kDataLen, file2.Seek(base::File::FROM_CURRENT, 0));
   file.Close();
   char buf[kDataLen];
   ASSERT_EQ(kDataLen, file2.Read(0, &buf[0], kDataLen));
   ASSERT_EQ(std::string(kData, kDataLen), std::string(&buf[0], kDataLen));
 }
 
 TEST(FileTest, DuplicateDeleteOnClose) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath file_path = temp_dir.path().AppendASCII("file");
+  FilePath file_path = temp_dir.GetPath().AppendASCII("file");
   File file(file_path,(base::File::FLAG_CREATE |
                        base::File::FLAG_READ |
                        base::File::FLAG_WRITE |
                        base::File::FLAG_DELETE_ON_CLOSE));
   ASSERT_TRUE(file.IsValid());
   File file2(file.Duplicate());
   ASSERT_TRUE(file2.IsValid());
   file.Close();
   file2.Close();
   ASSERT_FALSE(base::PathExists(file_path));
 }
 
 #if defined(OS_WIN)
 TEST(FileTest, GetInfoForDirectory) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath empty_dir = temp_dir.path().Append(FILE_PATH_LITERAL("gpfi_test"));
+  FilePath empty_dir =
+      temp_dir.GetPath().Append(FILE_PATH_LITERAL("gpfi_test"));
   ASSERT_TRUE(CreateDirectory(empty_dir));
 
   base::File dir(
       ::CreateFile(empty_dir.value().c_str(),
                    GENERIC_READ | GENERIC_WRITE,
                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                    NULL,
                    OPEN_EXISTING,
                    FILE_FLAG_BACKUP_SEMANTICS,  // Needed to open a directory.
                    NULL));
   ASSERT_TRUE(dir.IsValid());
 
   base::File::Info info;
   EXPECT_TRUE(dir.GetInfo(&info));
   EXPECT_TRUE(info.is_directory);
   EXPECT_FALSE(info.is_symbolic_link);
   EXPECT_EQ(0, info.size);
 }
 #endif  // defined(OS_WIN)