Remove PlatformFile from database/vfs_backend

webkit/browser/database/vfs_backend.cc

 // Copyright (c) 2011 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 "webkit/browser/database/vfs_backend.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "third_party/sqlite/sqlite3.h"
@@ skipping 37 matching lines @@
   return (file_type == SQLITE_OPEN_MAIN_DB) ||
          (file_type == SQLITE_OPEN_TEMP_DB) ||
          (file_type == SQLITE_OPEN_MAIN_JOURNAL) ||
          (file_type == SQLITE_OPEN_TEMP_JOURNAL) ||
          (file_type == SQLITE_OPEN_SUBJOURNAL) ||
          (file_type == SQLITE_OPEN_MASTER_JOURNAL) ||
          (file_type == SQLITE_OPEN_TRANSIENT_DB);
 }
 
 // static
-void VfsBackend::OpenFile(const base::FilePath& file_path,
-                          int desired_flags,
-                          base::PlatformFile* file_handle) {
+base::File VfsBackend::OpenFile(const base::FilePath& file_path,
+                                int desired_flags) {
   DCHECK(!file_path.empty());
 
   // Verify the flags for consistency and create the database
   // directory if it doesn't exist.
   if (!OpenFileFlagsAreConsistent(desired_flags) ||
-      !base::CreateDirectory(file_path.DirName()))
-    return;
+      !base::CreateDirectory(file_path.DirName())) {
+    return base::File();
+  }
 
   int flags = 0;
-  flags |= base::PLATFORM_FILE_READ;
+  flags |= base::File::FLAG_READ;
   if (desired_flags & SQLITE_OPEN_READWRITE)
-    flags |= base::PLATFORM_FILE_WRITE;
+    flags |= base::File::FLAG_WRITE;
 
-  if (!(desired_flags & SQLITE_OPEN_MAIN_DB)) {
-    flags |= base::PLATFORM_FILE_EXCLUSIVE_READ |
-             base::PLATFORM_FILE_EXCLUSIVE_WRITE;
-  }
+  if (!(desired_flags & SQLITE_OPEN_MAIN_DB))
+    flags |= base::File::FLAG_EXCLUSIVE_READ | base::File::FLAG_EXCLUSIVE_WRITE;
 
   flags |= ((desired_flags & SQLITE_OPEN_CREATE) ?
-      base::PLATFORM_FILE_OPEN_ALWAYS : base::PLATFORM_FILE_OPEN);
+           base::File::FLAG_OPEN_ALWAYS : base::File::FLAG_OPEN);
 
-  if (desired_flags & SQLITE_OPEN_EXCLUSIVE) {
-    flags |= base::PLATFORM_FILE_EXCLUSIVE_READ |
-             base::PLATFORM_FILE_EXCLUSIVE_WRITE;
-  }
+  if (desired_flags & SQLITE_OPEN_EXCLUSIVE)
+    flags |= base::File::FLAG_EXCLUSIVE_READ | base::File::FLAG_EXCLUSIVE_WRITE;
 
   if (desired_flags & SQLITE_OPEN_DELETEONCLOSE) {
-    flags |= base::PLATFORM_FILE_TEMPORARY | base::PLATFORM_FILE_HIDDEN |
-             base::PLATFORM_FILE_DELETE_ON_CLOSE;
+    flags |= base::File::FLAG_TEMPORARY | base::File::FLAG_HIDDEN |
+             base::File::FLAG_DELETE_ON_CLOSE;
   }
 
   // This flag will allow us to delete the file later on from the browser
   // process.
-  flags |= base::PLATFORM_FILE_SHARE_DELETE;
+  flags |= base::File::FLAG_SHARE_DELETE;
 
   // Try to open/create the DB file.
-  *file_handle =
-      base::CreatePlatformFile(file_path, flags, NULL, NULL);
+  return base::File(file_path, flags);
 }
 
 // static
-void VfsBackend::OpenTempFileInDirectory(
-    const base::FilePath& dir_path,
-    int desired_flags,
-    base::PlatformFile* file_handle) {
+base::File VfsBackend::OpenTempFileInDirectory(const base::FilePath& dir_path,
+                                               int desired_flags) {
   // We should be able to delete temp files when they're closed
   // and create them as needed
   if (!(desired_flags & SQLITE_OPEN_DELETEONCLOSE) ||
       !(desired_flags & SQLITE_OPEN_CREATE)) {
-    return;
+    return base::File();
   }
 
   // Get a unique temp file name in the database directory.
   base::FilePath temp_file_path;
   if (!base::CreateTemporaryFileInDir(dir_path, &temp_file_path))
-    return;
+    return base::File();
 
-  OpenFile(temp_file_path, desired_flags, file_handle);
+  return OpenFile(temp_file_path, desired_flags);
 }
 
 // static
 int VfsBackend::DeleteFile(const base::FilePath& file_path, bool sync_dir) {
   if (!base::PathExists(file_path))
     return SQLITE_OK;
   if (!base::DeleteFile(file_path, false))
     return SQLITE_IOERR_DELETE;
 
   int error_code = SQLITE_OK;
 #if defined(OS_POSIX)
   if (sync_dir) {
-    base::PlatformFile dir_fd = base::CreatePlatformFile(
-        file_path.DirName(), base::PLATFORM_FILE_READ, NULL, NULL);
-    if (dir_fd == base::kInvalidPlatformFileValue) {
+    base::File dir(file_path.DirName(), base::File::FLAG_READ);
+    if (dir.IsValid()) {
+      if (!dir.Flush())
+        error_code = SQLITE_IOERR_DIR_FSYNC;
+    } else {
       error_code = SQLITE_CANTOPEN;
-    } else {
-      if (fsync(dir_fd))
-        error_code = SQLITE_IOERR_DIR_FSYNC;
-      base::ClosePlatformFile(dir_fd);
     }
   }
 #endif
   return error_code;
 }
 
 // static
 uint32 VfsBackend::GetFileAttributes(const base::FilePath& file_path) {
 #if defined(OS_WIN)
   uint32 attributes = ::GetFileAttributes(file_path.value().c_str());
 #elif defined(OS_POSIX)
   uint32 attributes = 0;
   if (!access(file_path.value().c_str(), R_OK))
     attributes |= static_cast<uint32>(R_OK);
   if (!access(file_path.value().c_str(), W_OK))
     attributes |= static_cast<uint32>(W_OK);
   if (!attributes)
     attributes = -1;
 #endif
   return attributes;
 }
 
 // static
 int64 VfsBackend::GetFileSize(const base::FilePath& file_path) {
   int64 size = 0;
   return (base::GetFileSize(file_path, &size) ? size : 0);
 }
 
 } // namespace webkit_database