Remove uses of PlatformFile from leveldb

third_party/leveldatabase/env_chromium_win.cc

 // Copyright (c) 2013 The LevelDB Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "base/debug/trace_event.h"
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/win_util.h"
 #include "chromium_logger.h"
 #include "env_chromium_stdio.h"
 #include "env_chromium_win.h"
 
 using namespace leveldb;
 
 namespace leveldb_env {
@@ skipping 67 matching lines @@
       return MakeIOErrorWin(
           filename_, GetWindowsErrorMessage(err), kSequentialFileSkip, err);
     }
     return Status::OK();
   }
 };
 
 class ChromiumRandomAccessFileWin : public RandomAccessFile {
  private:
   std::string filename_;
-  ::base::PlatformFile file_;
+  mutable ::base::File file_;
   const UMALogger* uma_logger_;
 
  public:
   ChromiumRandomAccessFileWin(const std::string& fname,
-                           ::base::PlatformFile file,
-                           const UMALogger* uma_logger)
-      : filename_(fname), file_(file), uma_logger_(uma_logger) {}
-  virtual ~ChromiumRandomAccessFileWin() { ::base::ClosePlatformFile(file_); }
+                              ::base::File file,
+                              const UMALogger* uma_logger)
+      : filename_(fname), file_(file.Pass()), uma_logger_(uma_logger) {}
+  virtual ~ChromiumRandomAccessFileWin() {}
 
   virtual Status Read(uint64_t offset, size_t n, Slice* result, char* scratch)
       const {
     Status s;
-    int r = ::base::ReadPlatformFile(file_, offset, scratch, n);
+    int r = file_.Read(offset, scratch, n);
     *result = Slice(scratch, (r < 0) ? 0 : r);
     if (r < 0) {
       // An error: return a non-ok status
       s = MakeIOError(
           filename_, "Could not perform read", kRandomAccessFileRead);
       uma_logger_->RecordErrorAt(kRandomAccessFileRead);
     }
     return s;
   }
 };
@@ skipping 61 matching lines @@
     Status s = SyncParent();
     if (!s.ok())
       return s;
     tracker_->DidSyncDir(filename_);
   }
 
   DWORD written(0);
   if (!WriteFile(file_, data.data(), data.size(), &written, NULL)) {
     DWORD err = GetLastError();
     uma_logger_->RecordOSError(kWritableFileAppend,
-                               base::LastErrorToPlatformFileError(err));
+                               base::File::OSErrorToFileError(err));
     return MakeIOErrorWin(
         filename_, GetWindowsErrorMessage(err), kWritableFileAppend, err);
   }
   return Status::OK();
 }
 
 Status ChromiumWritableFileWin::Close() {
   Status result;
   DCHECK(file_ != INVALID_HANDLE_VALUE);
   if (!CloseHandle(file_)) {
@@ skipping 56 matching lines @@
   }
 }
 
 void ChromiumEnvWin::RecordOpenFilesLimit(const std::string& type) {
   // The Windows POSIX implementation (which this class doesn't use)
   // has an open file limit, but when using the Win32 API this is limited by
   // available memory, so no value to report.
 }
 
 Status ChromiumEnvWin::NewRandomAccessFile(const std::string& fname,
-                                             RandomAccessFile** result) {
-  int flags = ::base::PLATFORM_FILE_READ | ::base::PLATFORM_FILE_OPEN;
-  bool created;
-  ::base::PlatformFileError error_code;
-  ::base::PlatformFile file = ::base::CreatePlatformFile(
-      ChromiumEnv::CreateFilePath(fname), flags, &created, &error_code);
-  if (error_code == ::base::PLATFORM_FILE_OK) {
-    *result = new ChromiumRandomAccessFileWin(fname, file, this);
+                                           RandomAccessFile** result) {
+  int flags = ::base::File::FLAG_READ | ::base::File::FLAG_OPEN;
+  ::base::File file(ChromiumEnv::CreateFilePath(fname), flags);
+  if (file.IsValid()) {
+    *result = new ChromiumRandomAccessFileWin(fname, file.Pass(), this);
     RecordOpenFilesLimit("Success");
     return Status::OK();
   }
-  if (error_code == ::base::PLATFORM_FILE_ERROR_TOO_MANY_OPENED)
+  ::base::File::Error error_code = file.error_details();
+  if (error_code == ::base::File::FILE_ERROR_TOO_MANY_OPENED)
     RecordOpenFilesLimit("TooManyOpened");
   else
     RecordOpenFilesLimit("OtherError");
   *result = NULL;
   RecordOSError(kNewRandomAccessFile, error_code);
   return MakeIOErrorWin(fname,
-                          PlatformFileErrorString(error_code),
-                          kNewRandomAccessFile,
-                          error_code);
+                        FileErrorString(error_code),
+                        kNewRandomAccessFile,
+                        error_code);
 }
 
 Status ChromiumEnvWin::NewWritableFile(const std::string& fname,
                                          WritableFile** result) {
   *result = NULL;
   HANDLE f = CreateFile(base::UTF8ToUTF16(fname).c_str(),
                         GENERIC_WRITE,
                         FILE_SHARE_READ,
                         NULL,
                         CREATE_ALWAYS,
                         FILE_ATTRIBUTE_NORMAL,
                         NULL);
   if (f == INVALID_HANDLE_VALUE) {
     DWORD err = GetLastError();
     RecordErrorAt(kNewWritableFile);
     return MakeIOErrorWin(
         fname, GetWindowsErrorMessage(err), kNewWritableFile, err);
   } else {
     *result = new ChromiumWritableFileWin(fname, f, this, this, make_backup_);
     return Status::OK();
   }
 }
 
-base::PlatformFileError ChromiumEnvWin::GetDirectoryEntries(
+base::File::Error ChromiumEnvWin::GetDirectoryEntries(
     const base::FilePath& dir_param,
     std::vector<base::FilePath>* result) const {
   result->clear();
   base::FilePath dir_filepath = dir_param.Append(FILE_PATH_LITERAL("*"));
   WIN32_FIND_DATA find_data;
   HANDLE find_handle = FindFirstFile(dir_filepath.value().c_str(), &find_data);
   if (find_handle == INVALID_HANDLE_VALUE) {
     DWORD last_error = GetLastError();
     if (last_error == ERROR_FILE_NOT_FOUND)
-      return base::PLATFORM_FILE_OK;
-    return base::LastErrorToPlatformFileError(last_error);
+      return base::File::FILE_OK;
+    return base::File::OSErrorToFileError(last_error);
   }
   do {
     base::FilePath filepath(find_data.cFileName);
     base::FilePath::StringType basename = filepath.BaseName().value();
     if (basename == FILE_PATH_LITERAL(".") ||
         basename == FILE_PATH_LITERAL(".."))
       continue;
     result->push_back(filepath.BaseName());
   } while (FindNextFile(find_handle, &find_data));
   DWORD last_error = GetLastError();
-  base::PlatformFileError return_value = base::PLATFORM_FILE_OK;
+  base::File::Error return_value = base::File::FILE_OK;
   if (last_error != ERROR_NO_MORE_FILES)
-    return_value = base::LastErrorToPlatformFileError(last_error);
+    return_value = base::File::OSErrorToFileError(last_error);
   FindClose(find_handle);
   return return_value;
 }
 
 Status ChromiumEnvWin::NewLogger(const std::string& fname, Logger** result) {
   FILE* f = _wfopen(base::UTF8ToUTF16(fname).c_str(), L"w");
   if (f == NULL) {
     *result = NULL;
     int saved_errno = errno;
     RecordOSError(kNewLogger, saved_errno);
     return MakeIOError(fname, strerror(saved_errno), kNewLogger, saved_errno);
   } else {
     *result = new ChromiumLogger(f);
     return Status::OK();
   }
 }
 
 void ChromiumEnvWin::RecordOSError(MethodID method, DWORD error) const {
   RecordErrorAt(method);
   GetOSErrorHistogram(method, ERANGE + 1)->Add(error);
 }
 
 }  // namespace leveldb_env