Add FilePath to base namespace.

webkit/fileapi/local_file_system_operation.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/local_file_system_operation.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 175 matching lines @@
       base::Bind(&LocalFileSystemOperation::DidFileExists,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::GetMetadata(
     const FileSystemURL& url, const GetMetadataCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationGetMetadata));
 
   base::PlatformFileError result = SetUp(url, SETUP_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
-    callback.Run(result, base::PlatformFileInfo(), FilePath());
+    callback.Run(result, base::PlatformFileInfo(), base::FilePath());
     delete this;
     return;
   }
 
   async_file_util_->GetFileInfo(
       operation_context(), url,
       base::Bind(&LocalFileSystemOperation::DidGetMetadata,
                  base::Owned(this), callback));
 }
 
@@ skipping 158 matching lines @@
     cancel_callback_ = cancel_callback;
   }
 }
 
 LocalFileSystemOperation*
 LocalFileSystemOperation::AsLocalFileSystemOperation() {
   return this;
 }
 
 void LocalFileSystemOperation::SyncGetPlatformPath(const FileSystemURL& url,
-                                                   FilePath* platform_path) {
+                                                   base::FilePath* platform_path) {
   DCHECK(SetPendingOperationType(kOperationGetLocalPath));
 
   base::PlatformFileError result = SetUp(url, SETUP_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
     delete this;
     return;
   }
 
   FileSystemFileUtil* file_util = file_system_context()->GetFileUtil(
       url.type());
   DCHECK(file_util);
   file_util->GetLocalFilePath(operation_context(), url, platform_path);
 
   delete this;
 }
 
 void LocalFileSystemOperation::CreateSnapshotFile(
     const FileSystemURL& url,
     const SnapshotFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateSnapshotFile));
 
   base::PlatformFileError result = SetUp(url, SETUP_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
-    callback.Run(result, base::PlatformFileInfo(), FilePath(), NULL);
+    callback.Run(result, base::PlatformFileInfo(), base::FilePath(), NULL);
     delete this;
     return;
   }
 
   async_file_util_->CreateSnapshotFile(
       operation_context(), url,
       base::Bind(&LocalFileSystemOperation::DidCreateSnapshotFile,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::CopyInForeignFile(
-    const FilePath& src_local_disk_file_path,
+    const base::FilePath& src_local_disk_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopyInForeignFile));
 
   base::PlatformFileError result = SetUp(dest_url, SETUP_FOR_CREATE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
@@ skipping 237 matching lines @@
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   async_file_util_->MoveFileLocal(
       operation_context(), src_url, dest_url,
       base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::DoCopyInForeignFile(
-    const FilePath& src_local_disk_file_path,
+    const base::FilePath& src_local_disk_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   async_file_util_->CopyInForeignFile(
       operation_context(),
       src_local_disk_file_path, dest_url,
       base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::DoTruncate(const FileSystemURL& url,
@@ skipping 50 matching lines @@
   // The callback might be held by the delegate and Owned() may not work,
   // so just explicitly delete this now.
   callback.Run(rv);
   delete this;
 }
 
 void LocalFileSystemOperation::DidDirectoryExists(
     const StatusCallback& callback,
     base::PlatformFileError rv,
     const base::PlatformFileInfo& file_info,
-    const FilePath& unused) {
+    const base::FilePath& unused) {
   if (rv == base::PLATFORM_FILE_OK && !file_info.is_directory)
     rv = base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
   callback.Run(rv);
 }
 
 void LocalFileSystemOperation::DidFileExists(
     const StatusCallback& callback,
     base::PlatformFileError rv,
     const base::PlatformFileInfo& file_info,
-    const FilePath& unused) {
+    const base::FilePath& unused) {
   if (rv == base::PLATFORM_FILE_OK && file_info.is_directory)
     rv = base::PLATFORM_FILE_ERROR_NOT_A_FILE;
   callback.Run(rv);
 }
 
 void LocalFileSystemOperation::DidGetMetadata(
     const GetMetadataCallback& callback,
     base::PlatformFileError rv,
     const base::PlatformFileInfo& file_info,
-    const FilePath& platform_path) {
+    const base::FilePath& platform_path) {
   callback.Run(rv, file_info, platform_path);
 }
 
 void LocalFileSystemOperation::DidReadDirectory(
     const ReadDirectoryCallback& callback,
     base::PlatformFileError rv,
     const std::vector<base::FileUtilProxy::Entry>& entries,
     bool has_more) {
   callback.Run(rv, entries, has_more);
 }
@@ skipping 34 matching lines @@
     bool unused) {
   if (rv == base::PLATFORM_FILE_OK)
     CHECK_NE(base::kNullProcessHandle, peer_handle_);
   callback.Run(rv, file.ReleaseValue(), peer_handle_);
 }
 
 void LocalFileSystemOperation::DidCreateSnapshotFile(
     const SnapshotFileCallback& callback,
     base::PlatformFileError result,
     const base::PlatformFileInfo& file_info,
-    const FilePath& platform_path,
+    const base::FilePath& platform_path,
     SnapshotFilePolicy snapshot_policy) {
   scoped_refptr<ShareableFileReference> file_ref;
   if (result == base::PLATFORM_FILE_OK &&
       snapshot_policy == kSnapshotFileTemporary) {
     file_ref = ShareableFileReference::GetOrCreate(
         platform_path, ShareableFileReference::DELETE_ON_FINAL_RELEASE,
         file_system_context()->task_runners()->file_task_runner());
   }
   callback.Run(result, file_info, platform_path, file_ref);
 }
@@ skipping 52 matching lines @@
 }
 
 bool LocalFileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi