Add FilePath to base namespace.

webkit/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/database/vfs_backend.h"
 
 #include "base/file_path.h"
 #include "base/file_util.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 FilePath& file_path,
+void VfsBackend::OpenFile(const base::FilePath& file_path,
                           int desired_flags,
                           base::PlatformFile* file_handle) {
   DCHECK(!file_path.empty());
 
   // Verify the flags for consistency and create the database
   // directory if it doesn't exist.
   if (!OpenFileFlagsAreConsistent(desired_flags) ||
       !file_util::CreateDirectory(file_path.DirName()))
     return;
 
@@ skipping 24 matching lines @@
   // process.
   flags |= base::PLATFORM_FILE_SHARE_DELETE;
 
   // Try to open/create the DB file.
   *file_handle =
       base::CreatePlatformFile(file_path, flags, NULL, NULL);
 }
 
 // static
 void VfsBackend::OpenTempFileInDirectory(
-    const FilePath& dir_path,
+    const base::FilePath& dir_path,
     int desired_flags,
     base::PlatformFile* file_handle) {
   // 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;
   }
 
   // Get a unique temp file name in the database directory.
-  FilePath temp_file_path;
+  base::FilePath temp_file_path;
   if (!file_util::CreateTemporaryFileInDir(dir_path, &temp_file_path))
     return;
 
   OpenFile(temp_file_path, desired_flags, file_handle);
 }
 
 // static
-int VfsBackend::DeleteFile(const FilePath& file_path, bool sync_dir) {
+int VfsBackend::DeleteFile(const base::FilePath& file_path, bool sync_dir) {
   if (!file_util::PathExists(file_path))
     return SQLITE_OK;
   if (!file_util::Delete(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) {
       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 FilePath& file_path) {
+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 FilePath& file_path) {
+int64 VfsBackend::GetFileSize(const base::FilePath& file_path) {
   int64 size = 0;
   return (file_util::GetFileSize(file_path, &size) ? size : 0);
 }
 
 } // namespace webkit_database