LevelDB: Using base::File for all file I/O

third_party/leveldatabase/env_chromium_win.cc

Index: third_party/leveldatabase/env_chromium_win.cc
diff --git a/third_party/leveldatabase/env_chromium_win.cc b/third_party/leveldatabase/env_chromium_win.cc
deleted file mode 100644
index e37409e348f39ff562f50af3014377683bfe05f3..0000000000000000000000000000000000000000
--- a/third_party/leveldatabase/env_chromium_win.cc
+++ /dev/null
@@ -1,362 +0,0 @@
-// 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 "third_party/leveldatabase/env_chromium_win.h"
-
-#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 "third_party/leveldatabase/chromium_logger.h"
-#include "third_party/leveldatabase/env_chromium_stdio.h"
-
-using leveldb::ChromiumLogger;
-using leveldb::Logger;
-using leveldb::RandomAccessFile;
-using leveldb::SequentialFile;
-using leveldb::Slice;
-using leveldb::Status;
-using leveldb::WritableFile;
-
-namespace leveldb_env {
-
-namespace {
-
-static std::string GetWindowsErrorMessage(DWORD err) {
-  LPTSTR errorText(NULL);
-  FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
-                    FORMAT_MESSAGE_IGNORE_INSERTS,
-                NULL,
-                err,
-                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                (LPTSTR) & errorText,
-                0,
-                NULL);
-  if (errorText != NULL) {
-    std::string message(base::UTF16ToUTF8(errorText));
-    // FormatMessage adds CR/LF to messages so we remove it.
-    base::TrimWhitespace(message, base::TRIM_TRAILING, &message);
-    LocalFree(errorText);
-    return message;
-  } else {
-    return std::string();
-  }
-}
-
-class ChromiumSequentialFileWin : public SequentialFile {
- private:
-  std::string filename_;
-  HANDLE file_;
-  const UMALogger* uma_logger_;
-
- public:
-  ChromiumSequentialFileWin(const std::string& fname,
-                         HANDLE f,
-                         const UMALogger* uma_logger)
-      : filename_(fname), file_(f), uma_logger_(uma_logger) {
-    DCHECK(file_ != INVALID_HANDLE_VALUE);
-  }
-  virtual ~ChromiumSequentialFileWin() {
-    DCHECK(file_ != INVALID_HANDLE_VALUE);
-    CloseHandle(file_);
-    file_ = INVALID_HANDLE_VALUE;
-  }
-
-  virtual Status Read(size_t n, Slice* result, char* scratch) {
-    Status s;
-    DWORD bytes_read(0);
-    DCHECK(file_ != INVALID_HANDLE_VALUE);
-    if (ReadFile(file_, scratch, n, &bytes_read, NULL)) {
-      *result = Slice(scratch, bytes_read);
-    } else {
-      DWORD err = GetLastError();
-      s = MakeIOErrorWin(
-          filename_, GetWindowsErrorMessage(err), kSequentialFileRead, err);
-      uma_logger_->RecordErrorAt(kSequentialFileRead);
-      if (bytes_read > 0)
-        *result = Slice(scratch, bytes_read);
-    }
-    return s;
-  }
-
-  virtual Status Skip(uint64_t n) {
-    LARGE_INTEGER li;
-    li.QuadPart = n;
-    if (SetFilePointer(file_, li.LowPart, &li.HighPart, FILE_CURRENT) ==
-        INVALID_SET_FILE_POINTER) {
-      DWORD err = GetLastError();
-      uma_logger_->RecordErrorAt(kSequentialFileSkip);
-      return MakeIOErrorWin(
-          filename_, GetWindowsErrorMessage(err), kSequentialFileSkip, err);
-    }
-    return Status::OK();
-  }
-};
-
-class ChromiumRandomAccessFileWin : public RandomAccessFile {
- private:
-  std::string filename_;
-  mutable ::base::File file_;
-  const UMALogger* uma_logger_;
-
- public:
-  ChromiumRandomAccessFileWin(const std::string& fname,
-                              ::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 = 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;
-  }
-};
-
-}  // unnamed namespace
-
-Status MakeIOErrorWin(Slice filename,
-                        const std::string& message,
-                        MethodID method,
-                        DWORD error) {
-  char buf[512];
-  if (snprintf(buf,
-               sizeof(buf),
-               "%s (ChromeMethodErrno: %d::%s::%u)",
-               message.c_str(),
-               method,
-               MethodIDToString(method),
-               error) >= 0) {
-    return Status::IOError(filename, buf);
-  } else {
-    return Status::IOError(filename, "<unknown>");
-  }
-}
-
-ChromiumWritableFileWin::ChromiumWritableFileWin(
-    const std::string& fname,
-    HANDLE f,
-    const UMALogger* uma_logger,
-    WriteTracker* tracker,
-    bool make_backup)
-    : filename_(fname),
-      file_(f),
-      uma_logger_(uma_logger),
-      tracker_(tracker),
-      file_type_(kOther),
-      make_backup_(make_backup) {
-  DCHECK(f != INVALID_HANDLE_VALUE);
-  base::FilePath path = base::FilePath::FromUTF8Unsafe(fname);
-  if (FilePathToString(path.BaseName()).find("MANIFEST") == 0)
-    file_type_ = kManifest;
-  else if (ChromiumEnv::HasTableExtension(path))
-    file_type_ = kTable;
-  if (file_type_ != kManifest)
-    tracker_->DidCreateNewFile(filename_);
-  parent_dir_ = FilePathToString(ChromiumEnv::CreateFilePath(fname).DirName());
-}
-
-ChromiumWritableFileWin::~ChromiumWritableFileWin() {
-  if (file_ != INVALID_HANDLE_VALUE) {
-    // Ignoring any potential errors
-
-    CloseHandle(file_);
-    file_ = INVALID_HANDLE_VALUE;
-  }
-}
-
-Status ChromiumWritableFileWin::SyncParent() {
-  // On Windows no need to sync parent directory. It's metadata will be
-  // updated via the creation of the new file, without an explicit sync.
-  return Status();
-}
-
-Status ChromiumWritableFileWin::Append(const Slice& data) {
-  if (file_type_ == kManifest && tracker_->DoesDirNeedSync(filename_)) {
-    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::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_)) {
-    DWORD err = GetLastError();
-    result = MakeIOErrorWin(
-        filename_, GetWindowsErrorMessage(err), kWritableFileClose, err);
-    uma_logger_->RecordErrorAt(kWritableFileClose);
-  }
-  file_ = INVALID_HANDLE_VALUE;
-  return result;
-}
-
-Status ChromiumWritableFileWin::Flush() {
-  // Windows doesn't use POSIX file streams, so there are no file stream buffers
-  // to flush - this is a no-op.
-  return Status();
-}
-
-Status ChromiumWritableFileWin::Sync() {
-  TRACE_EVENT0("leveldb", "ChromiumEnvWin::Sync");
-  Status result;
-  DWORD error = ERROR_SUCCESS;
-
-  DCHECK(file_ != INVALID_HANDLE_VALUE);
-  if (!FlushFileBuffers(file_))
-    error = GetLastError();
-  if (error != ERROR_SUCCESS) {
-    result = MakeIOErrorWin(
-        filename_, GetWindowsErrorMessage(error), kWritableFileSync, error);
-    uma_logger_->RecordErrorAt(kWritableFileSync);
-  } else if (make_backup_ && file_type_ == kTable) {
-    bool success = ChromiumEnv::MakeBackup(filename_);
-    uma_logger_->RecordBackupResult(success);
-  }
-  return result;
-}
-
-ChromiumEnvWin::ChromiumEnvWin() {}
-
-ChromiumEnvWin::~ChromiumEnvWin() {}
-
-Status ChromiumEnvWin::NewSequentialFile(const std::string& fname,
-                                           SequentialFile** result) {
-  HANDLE f = CreateFile(base::UTF8ToUTF16(fname).c_str(),
-                        GENERIC_READ,
-                        FILE_SHARE_READ,
-                        NULL,
-                        OPEN_EXISTING,
-                        FILE_ATTRIBUTE_NORMAL,
-                        NULL);
-  if (f == INVALID_HANDLE_VALUE) {
-    *result = NULL;
-    DWORD err = GetLastError();
-    RecordOSError(kNewSequentialFile, err);
-    return MakeIOErrorWin(
-        fname, GetWindowsErrorMessage(err), kNewSequentialFile, err);
-  } else {
-    *result = new ChromiumSequentialFileWin(fname, f, this);
-    return Status::OK();
-  }
-}
-
-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::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();
-  }
-  ::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,
-                        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::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::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::File::Error return_value = base::File::FILE_OK;
-  if (last_error != ERROR_NO_MORE_FILES)
-    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