Convert base::MemoryMappedFile to use File instead of PlatformFile.

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/file_util.h"
 #include "base/files/file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 26 matching lines @@
     EXPECT_TRUE(file.IsValid());
     EXPECT_FALSE(file.created());
     EXPECT_EQ(base::File::FILE_OK, file.error());
 
     // This time verify closing the file.
     file.Close();
     EXPECT_FALSE(file.IsValid());
   }
 
   {
+    // Open an existing file through Initialize
+    File file;
+    file.Initialize(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
+    EXPECT_TRUE(file.IsValid());
+    EXPECT_FALSE(file.created());
+    EXPECT_EQ(base::File::FILE_OK, file.error());
+
+    // This time verify closing the file.
+    file.Close();
+    EXPECT_FALSE(file.IsValid());
+  }
+
+  {
     // Create a file that exists.
     File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_READ);
     EXPECT_FALSE(file.IsValid());
     EXPECT_FALSE(file.created());
     EXPECT_EQ(base::File::FILE_ERROR_EXISTS, file.error());
   }
 
   {
     // Create or overwrite a file.
     File file(file_path,
@@ skipping 157 matching lines @@
   int bytes_read = file.Read(0, data_read_1,
                              kTestDataSize + kAppendDataSize);
   EXPECT_EQ(kTestDataSize + kAppendDataSize, bytes_read);
   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(File, Truncate) {
+TEST(File, Length) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath file_path = temp_dir.path().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);
   EXPECT_EQ(kTestDataSize, bytes_written);
 
   // Extend the file.
   const int kExtendedFileLength = 10;
   int64 file_size = 0;
-  EXPECT_TRUE(file.Truncate(kExtendedFileLength));
+  EXPECT_TRUE(file.SetLength(kExtendedFileLength));
+  EXPECT_EQ(kExtendedFileLength, file.GetLength());
   EXPECT_TRUE(GetFileSize(file_path, &file_size));
   EXPECT_EQ(kExtendedFileLength, file_size);
 
   // Make sure the file was zero-padded.
   char data_read[32];
   int bytes_read = file.Read(0, data_read, static_cast<int>(file_size));
   EXPECT_EQ(file_size, bytes_read);
   for (int i = 0; i < kTestDataSize; i++)
     EXPECT_EQ(data_to_write[i], data_read[i]);
   for (int i = kTestDataSize; i < file_size; i++)
     EXPECT_EQ(0, data_read[i]);
 
   // Truncate the file.
   const int kTruncatedFileLength = 2;
-  EXPECT_TRUE(file.Truncate(kTruncatedFileLength));
+  EXPECT_TRUE(file.SetLength(kTruncatedFileLength));
+  EXPECT_EQ(kTruncatedFileLength, file.GetLength());
   EXPECT_TRUE(GetFileSize(file_path, &file_size));
   EXPECT_EQ(kTruncatedFileLength, file_size);
 
   // Make sure the file was truncated.
   bytes_read = file.Read(0, data_read, kTestDataSize);
   EXPECT_EQ(file_size, bytes_read);
   for (int i = 0; i < file_size; i++)
     EXPECT_EQ(data_to_write[i], data_read[i]);
 }
 
@@ skipping 83 matching lines @@
 
   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));
 }