Base: Move platform_file.* to files/base_file.*

base/files/base_file_win.cc

Index: base/files/base_file_win.cc
diff --git a/base/platform_file_win.cc b/base/files/base_file_win.cc
similarity index 46%
copy from base/platform_file_win.cc
copy to base/files/base_file_win.cc
index 07b5c48c22bf1add6aaf77e93cb63a0ee36d6da7..d2068a6c1fb9dc7a903b94d6a5487e07db11bd78 100644
--- a/base/platform_file_win.cc
+++ b/base/files/base_file_win.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/platform_file.h"
+#include "base/files/base_file.h"
 
 #include <io.h>
 
@@ -12,129 +12,157 @@
 #include "base/threading/thread_restrictions.h"
 
 namespace base {
-PlatformFile CreatePlatformFileUnsafe(const FilePath& name,
-                                      int flags,
-                                      bool* created,
-                                      PlatformFileError* error) {
+
+BaseFileError ErrorToBaseFileError(DWORD last_error) {
+  switch (last_error) {
+    case ERROR_SHARING_VIOLATION:
+      return BASE_FILE_ERROR_IN_USE;
+    case ERROR_FILE_EXISTS:
+      return BASE_FILE_ERROR_EXISTS;
+    case ERROR_FILE_NOT_FOUND:
+    case ERROR_PATH_NOT_FOUND:
+      return BASE_FILE_ERROR_NOT_FOUND;
+    case ERROR_ACCESS_DENIED:
+      return BASE_FILE_ERROR_ACCESS_DENIED;
+    case ERROR_TOO_MANY_OPEN_FILES:
+      return BASE_FILE_ERROR_TOO_MANY_OPENED;
+    case ERROR_OUTOFMEMORY:
+    case ERROR_NOT_ENOUGH_MEMORY:
+      return BASE_FILE_ERROR_NO_MEMORY;
+    case ERROR_HANDLE_DISK_FULL:
+    case ERROR_DISK_FULL:
+    case ERROR_DISK_RESOURCES_EXHAUSTED:
+      return BASE_FILE_ERROR_NO_SPACE;
+    case ERROR_USER_MAPPED_FILE:
+      return BASE_FILE_ERROR_INVALID_OPERATION;
+    case ERROR_NOT_READY:
+    case ERROR_SECTOR_NOT_FOUND:
+    case ERROR_DEV_NOT_EXIST:
+    case ERROR_IO_DEVICE:
+    case ERROR_FILE_CORRUPT:
+    case ERROR_DISK_CORRUPT:
+      return BASE_FILE_ERROR_IO;
+    default:
+      UMA_HISTOGRAM_SPARSE_SLOWLY("PlatformFile.UnknownErrors.Windows",
+                                  last_error);
+      return BASE_FILE_ERROR_FAILED;
+  }
+}
+
+void BaseFile::CreateBaseFileUnsafe(const FilePath& name, int flags) {
   base::ThreadRestrictions::AssertIOAllowed();
+  DCHECK(!IsValid());
 
   DWORD disposition = 0;
-  if (created)
-    *created = false;
 
-  if (flags & PLATFORM_FILE_OPEN)
+  if (flags & BASE_FILE_OPEN)
     disposition = OPEN_EXISTING;
 
-  if (flags & PLATFORM_FILE_CREATE) {
+  if (flags & BASE_FILE_CREATE) {
     DCHECK(!disposition);
     disposition = CREATE_NEW;
   }
 
-  if (flags & PLATFORM_FILE_OPEN_ALWAYS) {
+  if (flags & BASE_FILE_OPEN_ALWAYS) {
     DCHECK(!disposition);
     disposition = OPEN_ALWAYS;
   }
 
-  if (flags & PLATFORM_FILE_CREATE_ALWAYS) {
+  if (flags & BASE_FILE_CREATE_ALWAYS) {
     DCHECK(!disposition);
     disposition = CREATE_ALWAYS;
   }
 
-  if (flags & PLATFORM_FILE_OPEN_TRUNCATED) {
+  if (flags & BASE_FILE_OPEN_TRUNCATED) {
     DCHECK(!disposition);
-    DCHECK(flags & PLATFORM_FILE_WRITE);
+    DCHECK(flags & BASE_FILE_WRITE);
     disposition = TRUNCATE_EXISTING;
   }
 
   if (!disposition) {
     NOTREACHED();
-    return NULL;
+    return;
   }
 
   DWORD access = 0;
-  if (flags & PLATFORM_FILE_WRITE)
+  if (flags & BASE_FILE_WRITE)
     access = GENERIC_WRITE;
-  if (flags & PLATFORM_FILE_APPEND) {
+  if (flags & BASE_FILE_APPEND) {
     DCHECK(!access);
     access = FILE_APPEND_DATA;
   }
-  if (flags & PLATFORM_FILE_READ)
+  if (flags & BASE_FILE_READ)
     access |= GENERIC_READ;
-  if (flags & PLATFORM_FILE_WRITE_ATTRIBUTES)
+  if (flags & BASE_FILE_WRITE_ATTRIBUTES)
     access |= FILE_WRITE_ATTRIBUTES;
-  if (flags & PLATFORM_FILE_EXECUTE)
+  if (flags & BASE_FILE_EXECUTE)
     access |= GENERIC_EXECUTE;
 
-  DWORD sharing = (flags & PLATFORM_FILE_EXCLUSIVE_READ) ? 0 : FILE_SHARE_READ;
-  if (!(flags & PLATFORM_FILE_EXCLUSIVE_WRITE))
+  DWORD sharing = (flags & BASE_FILE_EXCLUSIVE_READ) ? 0 : FILE_SHARE_READ;
+  if (!(flags & BASE_FILE_EXCLUSIVE_WRITE))
     sharing |= FILE_SHARE_WRITE;
-  if (flags & PLATFORM_FILE_SHARE_DELETE)
+  if (flags & BASE_FILE_SHARE_DELETE)
     sharing |= FILE_SHARE_DELETE;
 
   DWORD create_flags = 0;
-  if (flags & PLATFORM_FILE_ASYNC)
+  if (flags & BASE_FILE_ASYNC)
     create_flags |= FILE_FLAG_OVERLAPPED;
-  if (flags & PLATFORM_FILE_TEMPORARY)
+  if (flags & BASE_FILE_TEMPORARY)
     create_flags |= FILE_ATTRIBUTE_TEMPORARY;
-  if (flags & PLATFORM_FILE_HIDDEN)
+  if (flags & BASE_FILE_HIDDEN)
     create_flags |= FILE_ATTRIBUTE_HIDDEN;
-  if (flags & PLATFORM_FILE_DELETE_ON_CLOSE)
+  if (flags & BASE_FILE_DELETE_ON_CLOSE)
     create_flags |= FILE_FLAG_DELETE_ON_CLOSE;
-  if (flags & PLATFORM_FILE_BACKUP_SEMANTICS)
+  if (flags & BASE_FILE_BACKUP_SEMANTICS)
     create_flags |= FILE_FLAG_BACKUP_SEMANTICS;
 
-  HANDLE file = CreateFile(name.value().c_str(), access, sharing, NULL,
-                           disposition, create_flags, NULL);
+  file_.Set(CreateFile(name.value().c_str(), access, sharing, NULL,
+                       disposition, create_flags, NULL));
 
-  if (created && (INVALID_HANDLE_VALUE != file)) {
-    if (flags & (PLATFORM_FILE_OPEN_ALWAYS))
-      *created = (ERROR_ALREADY_EXISTS != GetLastError());
-    else if (flags & (PLATFORM_FILE_CREATE_ALWAYS | PLATFORM_FILE_CREATE))
-      *created = true;
-  }
+  if (file_.IsValid()) {
+    error_ = BASE_FILE_OK;
+    async_ = ((flags & BASE_FILE_ASYNC) == BASE_FILE_ASYNC);
 
-  if (error) {
-    if (file != kInvalidPlatformFileValue)
-      *error = PLATFORM_FILE_OK;
-    else
-      *error = LastErrorToPlatformFileError(GetLastError());
+    if (flags & (BASE_FILE_OPEN_ALWAYS))
+      created_ = (ERROR_ALREADY_EXISTS != GetLastError());
+    else if (flags & (BASE_FILE_CREATE_ALWAYS | BASE_FILE_CREATE))
+      created_ = true;
+  } else {
+    error_ = ErrorToBaseFileError(GetLastError());
   }
-
-  return file;
 }
 
-FILE* FdopenPlatformFile(PlatformFile file, const char* mode) {
-  if (file == kInvalidPlatformFileValue)
-    return NULL;
-  int fd = _open_osfhandle(reinterpret_cast<intptr_t>(file), 0);
-  if (fd < 0)
-    return NULL;
-  return _fdopen(fd, mode);
+bool BaseFile::IsValid() const {
+  return file_.IsValid();
+}
+PlatformFile BaseFile::TakePlatformFile() {
+  return file_.Take();
 }
 
-bool ClosePlatformFile(PlatformFile file) {
+void BaseFile::Close() {
   base::ThreadRestrictions::AssertIOAllowed();
-  return (CloseHandle(file) != 0);
+  file_.Close();
 }
 
-int64 SeekPlatformFile(PlatformFile file,
-                       PlatformFileWhence whence,
-                       int64 offset) {
+int64 BaseFile::Seek(BaseFileWhence whence, int64 offset) {
   base::ThreadRestrictions::AssertIOAllowed();
-  if (file == kInvalidPlatformFileValue || offset < 0)
+  DCHECK(IsValid());
+  if (offset < 0)
     return -1;
 
   LARGE_INTEGER distance, res;
   distance.QuadPart = offset;
   DWORD move_method = static_cast<DWORD>(whence);
-  if (!SetFilePointerEx(file, distance, &res, move_method))
+  if (!SetFilePointerEx(file_, distance, &res, move_method))
     return -1;
   return res.QuadPart;
 }
 
-int ReadPlatformFile(PlatformFile file, int64 offset, char* data, int size) {
+int BaseFile::Read(int64 offset, char* data, int size) {
   base::ThreadRestrictions::AssertIOAllowed();
-  if (file == kInvalidPlatformFileValue || size < 0)
+  DCHECK(IsValid());
+  DCHECK(!async_);
+  if (size < 0)
     return -1;
 
   LARGE_INTEGER offset_li;
@@ -145,7 +173,7 @@ int ReadPlatformFile(PlatformFile file, int64 offset, char* data, int size) {
   overlapped.OffsetHigh = offset_li.HighPart;
 
   DWORD bytes_read;
-  if (::ReadFile(file, data, size, &bytes_read, &overlapped) != 0)
+  if (::ReadFile(file_, data, size, &bytes_read, &overlapped) != 0)
     return bytes_read;
   if (ERROR_HANDLE_EOF == GetLastError())
     return 0;
@@ -153,13 +181,15 @@ int ReadPlatformFile(PlatformFile file, int64 offset, char* data, int size) {
   return -1;
 }
 
-int ReadPlatformFileAtCurrentPos(PlatformFile file, char* data, int size) {
+int BaseFile::ReadAtCurrentPos(char* data, int size) {
   base::ThreadRestrictions::AssertIOAllowed();
-  if (file == kInvalidPlatformFileValue || size < 0)
+  DCHECK(IsValid());
+  DCHECK(!async_);
+  if (size < 0)
     return -1;
 
   DWORD bytes_read;
-  if (::ReadFile(file, data, size, &bytes_read, NULL) != 0)
+  if (::ReadFile(file_, data, size, &bytes_read, NULL) != 0)
     return bytes_read;
   if (ERROR_HANDLE_EOF == GetLastError())
     return 0;
@@ -167,21 +197,18 @@ int ReadPlatformFileAtCurrentPos(PlatformFile file, char* data, int size) {
   return -1;
 }
 
-int ReadPlatformFileNoBestEffort(PlatformFile file, int64 offset, char* data,
-                                 int size) {
-  return ReadPlatformFile(file, offset, data, size);
+int BaseFile::ReadNoBestEffort(int64 offset, char* data, int size) {
+  return Read(offset, data, size);
 }
 
-int ReadPlatformFileCurPosNoBestEffort(PlatformFile file,
-                                       char* data, int size) {
-  return ReadPlatformFileAtCurrentPos(file, data, size);
+int BaseFile::ReadAtCurrentPosNoBestEffort(char* data, int size) {
+  return ReadAtCurrentPos(data, size);
 }
 
-int WritePlatformFile(PlatformFile file, int64 offset,
-                      const char* data, int size) {
+int BaseFile::Write(int64 offset, const char* data, int size) {
   base::ThreadRestrictions::AssertIOAllowed();
-  if (file == kInvalidPlatformFileValue)
-    return -1;
+  DCHECK(IsValid());
+  DCHECK(!async_);
 
   LARGE_INTEGER offset_li;
   offset_li.QuadPart = offset;
@@ -191,72 +218,68 @@ int WritePlatformFile(PlatformFile file, int64 offset,
   overlapped.OffsetHigh = offset_li.HighPart;
 
   DWORD bytes_written;
-  if (::WriteFile(file, data, size, &bytes_written, &overlapped) != 0)
+  if (::WriteFile(file_, data, size, &bytes_written, &overlapped) != 0)
     return bytes_written;
 
   return -1;
 }
 
-int WritePlatformFileAtCurrentPos(PlatformFile file, const char* data,
-                                  int size) {
-  return WritePlatformFile(file, 0, data, size);
+int BaseFile::WriteAtCurrentPos(const char* data, int size) {
+  NOTREACHED();
+  return -1;
 }
 
-int WritePlatformFileCurPosNoBestEffort(PlatformFile file,
-                                        const char* data, int size) {
-  return WritePlatformFile(file, 0, data, size);
+int BaseFile::WriteAtCurrentPosNoBestEffort(const char* data, int size) {
+  return WriteAtCurrentPos(data, size);
 }
 
-bool TruncatePlatformFile(PlatformFile file, int64 length) {
+bool BaseFile::Truncate(int64 length) {
   base::ThreadRestrictions::AssertIOAllowed();
-  if (file == kInvalidPlatformFileValue)
-    return false;
+  DCHECK(IsValid());
 
   // Get the current file pointer.
   LARGE_INTEGER file_pointer;
   LARGE_INTEGER zero;
   zero.QuadPart = 0;
-  if (::SetFilePointerEx(file, zero, &file_pointer, FILE_CURRENT) == 0)
+  if (::SetFilePointerEx(file_, zero, &file_pointer, FILE_CURRENT) == 0)
     return false;
 
   LARGE_INTEGER length_li;
   length_li.QuadPart = length;
   // If length > file size, SetFilePointerEx() should extend the file
   // with zeroes on all Windows standard file systems (NTFS, FATxx).
-  if (!::SetFilePointerEx(file, length_li, NULL, FILE_BEGIN))
+  if (!::SetFilePointerEx(file_, length_li, NULL, FILE_BEGIN))
     return false;
 
   // Set the new file length and move the file pointer to its old position.
   // This is consistent with ftruncate()'s behavior, even when the file
   // pointer points to a location beyond the end of the file.
-  return ((::SetEndOfFile(file) != 0) &&
-          (::SetFilePointerEx(file, file_pointer, NULL, FILE_BEGIN) != 0));
+  return ((::SetEndOfFile(file_) != 0) &&
+          (::SetFilePointerEx(file_, file_pointer, NULL, FILE_BEGIN) != 0));
 }
 
-bool FlushPlatformFile(PlatformFile file) {
+bool BaseFile::Flush() {
   base::ThreadRestrictions::AssertIOAllowed();
-  return ((file != kInvalidPlatformFileValue) && ::FlushFileBuffers(file));
+  DCHECK(IsValid());
+  return ::FlushFileBuffers(file_) != FALSE;
 }
 
-bool TouchPlatformFile(PlatformFile file, const base::Time& last_access_time,
-                       const base::Time& last_modified_time) {
+bool BaseFile::SetTime(Time last_access_time, Time last_modified_time) {
   base::ThreadRestrictions::AssertIOAllowed();
-  if (file == kInvalidPlatformFileValue)
-    return false;
+  DCHECK(IsValid());
 
   FILETIME last_access_filetime = last_access_time.ToFileTime();
   FILETIME last_modified_filetime = last_modified_time.ToFileTime();
-  return (::SetFileTime(file, NULL, &last_access_filetime,
+  return (::SetFileTime(file_, NULL, &last_access_filetime,
                         &last_modified_filetime) != 0);
 }
 
-bool GetPlatformFileInfo(PlatformFile file, PlatformFileInfo* info) {
+bool BaseFile::GetInfo(BaseFileInfo* info) {
   base::ThreadRestrictions::AssertIOAllowed();
-  if (!info)
-    return false;
+  DCHECK(IsValid());
 
   BY_HANDLE_FILE_INFORMATION file_info;
-  if (GetFileInformationByHandle(file, &file_info) == 0)
+  if (GetFileInformationByHandle(file_, &file_info) == 0)
     return false;
 
   LARGE_INTEGER size;
@@ -265,61 +288,31 @@ bool GetPlatformFileInfo(PlatformFile file, PlatformFileInfo* info) {
   info->size = size.QuadPart;
   info->is_directory =
       (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
-  info->is_symbolic_link = false; // Windows doesn't have symbolic links.
+  info->is_symbolic_link = false;  // Windows doesn't have symbolic links.
   info->last_modified = base::Time::FromFileTime(file_info.ftLastWriteTime);
   info->last_accessed = base::Time::FromFileTime(file_info.ftLastAccessTime);
   info->creation_time = base::Time::FromFileTime(file_info.ftCreationTime);
   return true;
 }
 
-PlatformFileError LockPlatformFile(PlatformFile file) {
-  BOOL result = LockFile(file, 0, 0, MAXDWORD, MAXDWORD);
+BaseFileError BaseFile::Lock() {
+  DCHECK(IsValid());
+  BOOL result = LockFile(file_, 0, 0, MAXDWORD, MAXDWORD);
   if (!result)
-    return LastErrorToPlatformFileError(GetLastError());
-  return PLATFORM_FILE_OK;
+    return ErrorToBaseFileError(GetLastError());
+  return BASE_FILE_OK;
 }
 
-PlatformFileError UnlockPlatformFile(PlatformFile file) {
-  BOOL result = UnlockFile(file, 0, 0, MAXDWORD, MAXDWORD);
+BaseFileError BaseFile::Unlock() {
+  DCHECK(IsValid());
+  BOOL result = UnlockFile(file_, 0, 0, MAXDWORD, MAXDWORD);
   if (!result)
-    return LastErrorToPlatformFileError(GetLastError());
-  return PLATFORM_FILE_OK;
+    return ErrorToBaseFileError(GetLastError());
+  return BASE_FILE_OK;
 }
 
-PlatformFileError LastErrorToPlatformFileError(DWORD last_error) {
-  switch (last_error) {
-    case ERROR_SHARING_VIOLATION:
-      return PLATFORM_FILE_ERROR_IN_USE;
-    case ERROR_FILE_EXISTS:
-      return PLATFORM_FILE_ERROR_EXISTS;
-    case ERROR_FILE_NOT_FOUND:
-    case ERROR_PATH_NOT_FOUND:
-      return PLATFORM_FILE_ERROR_NOT_FOUND;
-    case ERROR_ACCESS_DENIED:
-      return PLATFORM_FILE_ERROR_ACCESS_DENIED;
-    case ERROR_TOO_MANY_OPEN_FILES:
-      return PLATFORM_FILE_ERROR_TOO_MANY_OPENED;
-    case ERROR_OUTOFMEMORY:
-    case ERROR_NOT_ENOUGH_MEMORY:
-      return PLATFORM_FILE_ERROR_NO_MEMORY;
-    case ERROR_HANDLE_DISK_FULL:
-    case ERROR_DISK_FULL:
-    case ERROR_DISK_RESOURCES_EXHAUSTED:
-      return PLATFORM_FILE_ERROR_NO_SPACE;
-    case ERROR_USER_MAPPED_FILE:
-      return PLATFORM_FILE_ERROR_INVALID_OPERATION;
-    case ERROR_NOT_READY:
-    case ERROR_SECTOR_NOT_FOUND:
-    case ERROR_DEV_NOT_EXIST:
-    case ERROR_IO_DEVICE:
-    case ERROR_FILE_CORRUPT:
-    case ERROR_DISK_CORRUPT:
-      return PLATFORM_FILE_ERROR_IO;
-    default:
-      UMA_HISTOGRAM_SPARSE_SLOWLY("PlatformFile.UnknownErrors.Windows",
-                                  last_error);
-      return PLATFORM_FILE_ERROR_FAILED;
-  }
+void BaseFile::SetPlatformFile(PlatformFile file) {
+  file_.Set(file);
 }
 
 }  // namespace base