Remove uses of PlatformFile from leveldb

third_party/leveldatabase/env_chromium.h

 // 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.
 
 #ifndef THIRD_PARTY_LEVELDATABASE_ENV_CHROMIUM_H_
 #define THIRD_PARTY_LEVELDATABASE_ENV_CHROMIUM_H_
 
 #include <deque>
 #include <map>
 #include <set>
 
+#include "base/files/file.h"
 #include "base/metrics/histogram.h"
-#include "base/platform_file.h"
 #include "leveldb/env.h"
 #include "port/port_chromium.h"
 #include "util/mutexlock.h"
 
 namespace leveldb_env {
 
 enum MethodID {
   kSequentialFileRead,
   kSequentialFileSkip,
   kRandomAccessFileRead,
@@ skipping 20 matching lines @@
 
 const char* MethodIDToString(MethodID method);
 
 leveldb::Status MakeIOError(leveldb::Slice filename,
                             const char* message,
                             MethodID method,
                             int saved_errno);
 leveldb::Status MakeIOError(leveldb::Slice filename,
                             const char* message,
                             MethodID method,
-                            base::PlatformFileError error);
+                            base::File::Error error);
 leveldb::Status MakeIOError(leveldb::Slice filename,
                             const char* message,
                             MethodID method);
 
 enum ErrorParsingResult {
   METHOD_ONLY,
   METHOD_AND_PFE,
   METHOD_AND_ERRNO,
   NONE,
 };
 
 ErrorParsingResult ParseMethodAndError(const char* string,
                                        MethodID* method,
                                        int* error);
 int GetCorruptionCode(const leveldb::Status& status);
 int GetNumCorruptionCodes();
 std::string GetCorruptionMessage(const leveldb::Status& status);
 bool IndicatesDiskFull(const leveldb::Status& status);
 bool IsIOError(const leveldb::Status& status);
 bool IsCorruption(const leveldb::Status& status);
 std::string FilePathToString(const base::FilePath& file_path);
 
 class UMALogger {
  public:
   virtual void RecordErrorAt(MethodID method) const = 0;
   virtual void RecordOSError(MethodID method, int saved_errno) const = 0;
   virtual void RecordOSError(MethodID method,
-                             base::PlatformFileError error) const = 0;
+                             base::File::Error error) const = 0;
   virtual void RecordBackupResult(bool success) const = 0;
 };
 
 class RetrierProvider {
  public:
   virtual int MaxRetryTimeMillis() const = 0;
   virtual base::HistogramBase* GetRetryTimeHistogram(MethodID method) const = 0;
   virtual base::HistogramBase* GetRecoveredFromErrorHistogram(
       MethodID method) const = 0;
 };
 
 class WriteTracker {
  public:
   virtual void DidCreateNewFile(const std::string& fname) = 0;
   virtual bool DoesDirNeedSync(const std::string& fname) = 0;
   virtual void DidSyncDir(const std::string& fname) = 0;
 };
 
 class ChromiumEnv : public leveldb::Env,
                     public UMALogger,
                     public RetrierProvider,
                     public WriteTracker {
  public:
   static bool MakeBackup(const std::string& fname);
   static base::FilePath CreateFilePath(const std::string& file_path);
-  static const char* PlatformFileErrorString(
-      const ::base::PlatformFileError& error);
+  static const char* FileErrorString(::base::File::Error error);
   static bool HasTableExtension(const base::FilePath& path);
   virtual ~ChromiumEnv();
 
   virtual bool FileExists(const std::string& fname);
   virtual leveldb::Status GetChildren(const std::string& dir,
                                       std::vector<std::string>* result);
   virtual leveldb::Status DeleteFile(const std::string& fname);
   virtual leveldb::Status CreateDir(const std::string& name);
   virtual leveldb::Status DeleteDir(const std::string& name);
   virtual leveldb::Status GetFileSize(const std::string& fname, uint64_t* size);
   virtual leveldb::Status RenameFile(const std::string& src,
                                      const std::string& dst);
   virtual leveldb::Status LockFile(const std::string& fname,
                                    leveldb::FileLock** lock);
   virtual leveldb::Status UnlockFile(leveldb::FileLock* lock);
   virtual void Schedule(void (*function)(void*), void* arg);
   virtual void StartThread(void (*function)(void* arg), void* arg);
   virtual leveldb::Status GetTestDirectory(std::string* path);
   virtual uint64_t NowMicros();
   virtual void SleepForMicroseconds(int micros);
 
  protected:
   ChromiumEnv();
 
   virtual void DidCreateNewFile(const std::string& fname);
   virtual bool DoesDirNeedSync(const std::string& fname);
   virtual void DidSyncDir(const std::string& fname);
-  virtual base::PlatformFileError GetDirectoryEntries(
+  virtual base::File::Error GetDirectoryEntries(
       const base::FilePath& dir_param,
       std::vector<base::FilePath>* result) const = 0;
   virtual void RecordErrorAt(MethodID method) const;
   virtual void RecordOSError(MethodID method, int saved_errno) const;
   virtual void RecordOSError(MethodID method,
-                             base::PlatformFileError error) const;
+                             base::File::Error error) const;
   base::HistogramBase* GetMaxFDHistogram(const std::string& type) const;
   base::HistogramBase* GetOSErrorHistogram(MethodID method, int limit) const;
 
   std::string name_;
   bool make_backup_;
 
  private:
   // File locks may not be exclusive within a process (e.g. on POSIX). Track
   // locks held by the ChromiumEnv to prevent access within the process.
   class LockTable {
@@ skipping 47 matching lines @@
     void (*function)(void*);
   };
   typedef std::deque<BGItem> BGQueue;
   BGQueue queue_;
   LockTable locks_;
 };
 
 }  // namespace leveldb_env
 
 #endif