Add FilePath to base namespace.

webkit/fileapi/syncable/local_file_change_tracker.cc

 // Copyright (c) 2012 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/fileapi/syncable/local_file_change_tracker.h"
 
 #include <queue>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/syncable/local_file_sync_status.h"
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 
 namespace fileapi {
 
 namespace {
-const FilePath::CharType kDatabaseName[] =
+const base::FilePath::CharType kDatabaseName[] =
     FILE_PATH_LITERAL("LocalFileChangeTracker");
 const char kMark[] = "d";
 }  // namespace
 
 // A database class that stores local file changes in a local database. This
 // object must be destructed on file_task_runner.
 class LocalFileChangeTracker::TrackerDB {
  public:
-  explicit TrackerDB(const FilePath& base_path);
+  explicit TrackerDB(const base::FilePath& base_path);
 
   SyncStatusCode MarkDirty(const std::string& url);
   SyncStatusCode ClearDirty(const std::string& url);
   SyncStatusCode GetDirtyEntries(std::queue<FileSystemURL>* dirty_files);
 
  private:
   enum RecoveryOption {
     REPAIR_ON_CORRUPTION,
     FAIL_ON_CORRUPTION,
   };
 
   SyncStatusCode Init(RecoveryOption recovery_option);
   SyncStatusCode Repair(const std::string& db_path);
   void HandleError(const tracked_objects::Location& from_here,
                    const leveldb::Status& status);
 
-  const FilePath base_path_;
+  const base::FilePath base_path_;
   scoped_ptr<leveldb::DB> db_;
   SyncStatusCode db_status_;
 
   DISALLOW_COPY_AND_ASSIGN(TrackerDB);
 };
 
 LocalFileChangeTracker::ChangeInfo::ChangeInfo() : change_seq(-1) {}
 LocalFileChangeTracker::ChangeInfo::~ChangeInfo() {}
 
 // LocalFileChangeTracker ------------------------------------------------------
 
 LocalFileChangeTracker::LocalFileChangeTracker(
-    const FilePath& base_path,
+    const base::FilePath& base_path,
     base::SequencedTaskRunner* file_task_runner)
     : initialized_(false),
       file_task_runner_(file_task_runner),
       tracker_db_(new TrackerDB(base_path)),
       current_change_seq_(0),
       num_changes_(0) {
 }
 
 LocalFileChangeTracker::~LocalFileChangeTracker() {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 136 matching lines @@
   if (status != SYNC_STATUS_OK)
     return status;
 
   FileSystemFileUtil* file_util =
       file_system_context->GetFileUtil(kFileSystemTypeSyncable);
   DCHECK(file_util);
   scoped_ptr<FileSystemOperationContext> context(
       new FileSystemOperationContext(file_system_context));
 
   base::PlatformFileInfo file_info;
-  FilePath platform_path;
+  base::FilePath platform_path;
 
   while (!dirty_files.empty()) {
     const FileSystemURL url = dirty_files.front();
     dirty_files.pop();
     DCHECK_EQ(url.type(), kFileSystemTypeSyncable);
 
     switch (file_util->GetFileInfo(context.get(), url,
                                    &file_info, &platform_path)) {
       case base::PLATFORM_FILE_OK: {
         if (!file_info.is_directory) {
           RecordChange(url, FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                                        SYNC_FILE_TYPE_FILE));
           break;
         }
 
         RecordChange(url, FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                                      SYNC_FILE_TYPE_DIRECTORY));
 
         // Push files and directories in this directory into |dirty_files|.
         scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator(
             file_util->CreateFileEnumerator(context.get(),
                                             url,
                                             false /* recursive */));
-        FilePath path_each;
+        base::FilePath path_each;
         while (!(path_each = enumerator->Next()).empty()) {
           dirty_files.push(CreateSyncableFileSystemURL(
               url.origin(), url.filesystem_id(), path_each));
         }
         break;
       }
       case base::PLATFORM_FILE_ERROR_NOT_FOUND: {
         // File represented by |url| has already been deleted. Since we cannot
         // figure out if this file was directory or not from the URL, file
         // type is treated as SYNC_FILE_TYPE_UNKNOWN.
@@ skipping 26 matching lines @@
     UpdateNumChanges();
     return;
   }
   info.change_seq = current_change_seq_++;
   change_seqs_[info.change_seq] = url;
   UpdateNumChanges();
 }
 
 // TrackerDB -------------------------------------------------------------------
 
-LocalFileChangeTracker::TrackerDB::TrackerDB(const FilePath& base_path)
+LocalFileChangeTracker::TrackerDB::TrackerDB(const base::FilePath& base_path)
   : base_path_(base_path),
     db_status_(SYNC_STATUS_OK) {}
 
 SyncStatusCode LocalFileChangeTracker::TrackerDB::Init(
     RecoveryOption recovery_option) {
   if (db_.get() && db_status_ == SYNC_STATUS_OK)
     return SYNC_STATUS_OK;
 
   std::string path = FilePathToString(base_path_.Append(kDatabaseName));
   leveldb::Options options;
@@ skipping 108 matching lines @@
       db_.reset();
       return db_status_;
     }
     dirty_files->push(url);
     iter->Next();
   }
   return SYNC_STATUS_OK;
 }
 
 }  // namespace fileapi