Replace FilePath with base::FilePath.

ppapi/proxy/flash_file_resource.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 "ppapi/proxy/flash_file_resource.h"
 
 #include "base/file_path.h"
 #include "ipc/ipc_message.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ skipping 42 matching lines @@
                                     const char* path,
                                     int32_t mode,
                                     PP_FileHandle* file) {
   return OpenFileHelper(path, PepperFilePath::DOMAIN_MODULE_LOCAL, mode, file);
 }
 
 int32_t FlashFileResource::RenameFile(PP_Instance /*instance*/,
                                       const char* path_from,
                                       const char* path_to) {
   PepperFilePath pepper_from(PepperFilePath::DOMAIN_MODULE_LOCAL,
-                             FilePath::FromUTF8Unsafe(path_from));
+                             base::FilePath::FromUTF8Unsafe(path_from));
   PepperFilePath pepper_to(PepperFilePath::DOMAIN_MODULE_LOCAL,
-                           FilePath::FromUTF8Unsafe(path_to));
+                           base::FilePath::FromUTF8Unsafe(path_to));
 
   int32_t error = SyncCall<IPC::Message>(
       BROWSER, PpapiHostMsg_FlashFile_RenameFile(pepper_from, pepper_to));
 
   return error;
 }
 
 int32_t FlashFileResource::DeleteFileOrDir(PP_Instance /*instance*/,
                                            const char* path,
                                            PP_Bool recursive) {
   PepperFilePath pepper_path(PepperFilePath::DOMAIN_MODULE_LOCAL,
-                             FilePath::FromUTF8Unsafe(path));
+                             base::FilePath::FromUTF8Unsafe(path));
 
   int32_t error = SyncCall<IPC::Message>(
       BROWSER, PpapiHostMsg_FlashFile_DeleteFileOrDir(pepper_path,
                                                       PP_ToBool(recursive)));
 
   return error;
 }
 
 int32_t FlashFileResource::CreateDir(PP_Instance /*instance*/,
                                      const char* path) {
   PepperFilePath pepper_path(PepperFilePath::DOMAIN_MODULE_LOCAL,
-                             FilePath::FromUTF8Unsafe(path));
+                             base::FilePath::FromUTF8Unsafe(path));
 
   int32_t error = SyncCall<IPC::Message>(BROWSER,
       PpapiHostMsg_FlashFile_CreateDir(pepper_path));
 
   return error;
 }
 
 int32_t FlashFileResource::QueryFile(PP_Instance /*instance*/,
                                      const char* path,
                                      PP_FileInfo* info) {
   return QueryFileHelper(path, PepperFilePath::DOMAIN_MODULE_LOCAL, info);
 }
 
 int32_t FlashFileResource::GetDirContents(PP_Instance /*instance*/,
                                           const char* path,
                                           PP_DirContents_Dev** contents) {
   ppapi::DirContents entries;
   PepperFilePath pepper_path(PepperFilePath::DOMAIN_MODULE_LOCAL,
-                             FilePath::FromUTF8Unsafe(path));
+                             base::FilePath::FromUTF8Unsafe(path));
 
   int32_t error = SyncCall<PpapiPluginMsg_FlashFile_GetDirContentsReply>(
       BROWSER, PpapiHostMsg_FlashFile_GetDirContents(pepper_path), &entries);
 
   if (error == PP_OK) {
     // Copy the serialized dir entries to the output struct.
     *contents = new PP_DirContents_Dev;
     (*contents)->count = static_cast<int32_t>(entries.size());
     (*contents)->entries = new PP_DirEntry_Dev[entries.size()];
     for (size_t i = 0; i < entries.size(); i++) {
@@ skipping 56 matching lines @@
 int32_t FlashFileResource::OpenFileHelper(const std::string& path,
                                           PepperFilePath::Domain domain_type,
                                           int32_t mode,
                                           PP_FileHandle* file) {
   int flags = 0;
   if (path.empty() ||
       !ppapi::PepperFileOpenFlagsToPlatformFileFlags(mode, &flags) ||
       !file)
     return PP_ERROR_BADARGUMENT;
 
-  PepperFilePath pepper_path(domain_type, FilePath::FromUTF8Unsafe(path));
+  PepperFilePath pepper_path(domain_type, base::FilePath::FromUTF8Unsafe(path));
 
   IPC::Message unused;
   ResourceMessageReplyParams reply_params;
   int32_t error = GenericSyncCall(BROWSER,
       PpapiHostMsg_FlashFile_OpenFile(pepper_path, flags), &unused,
       &reply_params);
   if (error != PP_OK)
     return error;
 
   IPC::PlatformFileForTransit transit_file;
   if (!reply_params.TakeFileHandleAtIndex(0, &transit_file))
     return PP_ERROR_FAILED;
 
   *file = IPC::PlatformFileForTransitToPlatformFile(transit_file);
   return PP_OK;
 }
 
 int32_t FlashFileResource::QueryFileHelper(const std::string& path,
                                            PepperFilePath::Domain domain_type,
                                            PP_FileInfo* info) {
   if (path.empty() || !info)
     return PP_ERROR_BADARGUMENT;
 
   base::PlatformFileInfo file_info;
-  PepperFilePath pepper_path(domain_type, FilePath::FromUTF8Unsafe(path));
+  PepperFilePath pepper_path(domain_type, base::FilePath::FromUTF8Unsafe(path));
 
   int32_t error = SyncCall<PpapiPluginMsg_FlashFile_QueryFileReply>(BROWSER,
       PpapiHostMsg_FlashFile_QueryFile(pepper_path), &file_info);
 
   if (error == PP_OK) {
     info->size = file_info.size;
     info->creation_time = TimeToPPTime(file_info.creation_time);
     info->last_access_time = TimeToPPTime(file_info.last_accessed);
     info->last_modified_time = TimeToPPTime(file_info.last_modified);
     info->system_type = PP_FILESYSTEMTYPE_EXTERNAL;
     if (file_info.is_directory)
       info->type = PP_FILETYPE_DIRECTORY;
     else
       info->type = PP_FILETYPE_REGULAR;
   }
 
   return error;
 }
 
 }  // namespace proxy
 }  // namespace ppapi