Replace FilePath with base::FilePath.

third_party/leveldatabase/env_chromium.cc

 // Copyright (c) 2011 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 <deque>
 #include <errno.h>
 #include <stdio.h>
 #include "base/at_exit.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 56 matching lines @@
 
 // Wide-char safe fopen wrapper.
 FILE* fopen_internal(const char* fname, const char* mode) {
 #if defined(OS_WIN)
   return _wfopen(UTF8ToUTF16(fname).c_str(), ASCIIToUTF16(mode).c_str());
 #else
   return fopen(fname, mode);
 #endif
 }
 
-::FilePath CreateFilePath(const std::string& file_path) {
+base::FilePath CreateFilePath(const std::string& file_path) {
 #if defined(OS_WIN)
-  return FilePath(UTF8ToUTF16(file_path));
+  return base::FilePath(UTF8ToUTF16(file_path));
 #else
-  return FilePath(file_path);
+  return base::FilePath(file_path);
 #endif
 }
 
-std::string FilePathToString(const ::FilePath& file_path) {
+std::string FilePathToString(const base::FilePath& file_path) {
 #if defined(OS_WIN)
   return UTF16ToUTF8(file_path.value());
 #else
   return file_path.value();
 #endif
 }
 
 bool sync_parent(const std::string& fname) {
 #if !defined(OS_WIN)
-  FilePath parent_dir = CreateFilePath(fname).DirName();
+  base::FilePath parent_dir = CreateFilePath(fname).DirName();
   int parent_fd = HANDLE_EINTR(open(FilePathToString(parent_dir).c_str(), O_RDONLY));
   if (parent_fd < 0)
     return false;
   HANDLE_EINTR(fsync(parent_fd));
   HANDLE_EINTR(close(parent_fd));
 #endif
   return true;
 }
 
 enum UmaEntry {
@@ skipping 27 matching lines @@
 };
 
 }  // namespace
 
 namespace leveldb {
 
 namespace {
 
 class Thread;
 
-static const ::FilePath::CharType kLevelDBTestDirectoryPrefix[]
+static const base::FilePath::CharType kLevelDBTestDirectoryPrefix[]
     = FILE_PATH_LITERAL("leveldb-test-");
 
 const char* PlatformFileErrorString(const ::base::PlatformFileError& error) {
   switch (error) {
     case ::base::PLATFORM_FILE_ERROR_FAILED:
       return "Opening file failed.";
     case ::base::PLATFORM_FILE_ERROR_IN_USE:
       return "File currently in use.";
     case ::base::PLATFORM_FILE_ERROR_EXISTS:
       return "File already exists.";
@@ skipping 220 matching lines @@
 
   virtual bool FileExists(const std::string& fname) {
     return ::file_util::PathExists(CreateFilePath(fname));
   }
 
   virtual Status GetChildren(const std::string& dir,
                              std::vector<std::string>* result) {
     result->clear();
     ::file_util::FileEnumerator iter(
         CreateFilePath(dir), false, ::file_util::FileEnumerator::FILES);
-    ::FilePath current = iter.Next();
+    base::FilePath current = iter.Next();
     while (!current.empty()) {
       result->push_back(FilePathToString(current.BaseName()));
       current = iter.Next();
     }
     // TODO(jorlow): Unfortunately, the FileEnumerator swallows errors, so
     //               we'll always return OK. Maybe manually check for error
     //               conditions like the file not existing?
     return Status::OK();
   }
 
@@ skipping 34 matching lines @@
       s = Status::IOError(fname, "Could not determine file size.");
       RecordErrorAt(kGetFileSize);
     } else {
       *size = static_cast<uint64_t>(signed_size);
     }
     return s;
   }
 
   virtual Status RenameFile(const std::string& src, const std::string& dst) {
     Status result;
-    FilePath src_file_path = CreateFilePath(src);
+    base::FilePath src_file_path = CreateFilePath(src);
     if (!::file_util::PathExists(src_file_path))
       return result;
     if (!::file_util::ReplaceFile(src_file_path, CreateFilePath(dst))) {
       result = Status::IOError(src, "Could not rename file.");
       RecordErrorAt(kRenamefile);
     } else {
       sync_parent(dst);
       if (src != dst)
         sync_parent(src);
     }
@@ skipping 103 matching lines @@
  protected:
   void InitHistograms(const std::string& uma_title);
 
  private:
   // BGThread() is the body of the background thread
   void BGThread();
   static void BGThreadWrapper(void* arg) {
     reinterpret_cast<ChromiumEnv*>(arg)->BGThread();
   }
 
-  FilePath test_directory_;
+  base::FilePath test_directory_;
 
   size_t page_size_;
   ::base::Lock mu_;
   ::base::ConditionVariable bgsignal_;
   bool started_bgthread_;
 
   // Entry per Schedule() call
   struct BGItem { void* arg; void (*function)(void*); };
   typedef std::deque<BGItem> BGQueue;
   BGQueue queue_;
@@ skipping 104 matching lines @@
 
 Env* IDBEnv() {
   return idb_env.Pointer();
 }
 
 Env* Env::Default() {
   return default_env.Pointer();
 }
 
 }