Add FilePath to base namespace.

webkit/plugins/ppapi/ppb_file_ref_impl.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/plugins/ppapi/ppb_file_ref_impl.h"
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/escape.h"
@@ skipping 37 matching lines @@
   return true;
 }
 
 void TrimTrailingSlash(std::string* path) {
   // If this path ends with a slash, then normalize it away unless path is the
   // root path.
   if (path->size() > 1 && path->at(path->size() - 1) == '/')
     path->erase(path->size() - 1, 1);
 }
 
-std::string GetNameForExternalFilePath(const FilePath& in_path) {
-  const FilePath::StringType& path = in_path.value();
-  size_t pos = path.rfind(FilePath::kSeparators[0]);
-  CHECK(pos != FilePath::StringType::npos);
+std::string GetNameForExternalFilePath(const base::FilePath& in_path) {
+  const base::FilePath::StringType& path = in_path.value();
+  size_t pos = path.rfind(base::FilePath::kSeparators[0]);
+  CHECK(pos != base::FilePath::StringType::npos);
 #if defined(OS_WIN)
   return WideToUTF8(path.substr(pos + 1));
 #elif defined(OS_POSIX)
   return path.substr(pos + 1);
 #else
 #error "Unsupported platform."
 #endif
 }
 
 std::string GetNameForVirtualFilePath(const std::string& path) {
   if (path.size() == 1 && path[0] == '/')
     return path;
 
   // There should always be a leading slash at least!
   size_t pos = path.rfind('/');
   CHECK(pos != std::string::npos);
   return path.substr(pos + 1);
 }
 
 }  // namespace
 
 PPB_FileRef_Impl::PPB_FileRef_Impl(const PPB_FileRef_CreateInfo& info,
                                    PPB_FileSystem_Impl* file_system)
     : PPB_FileRef_Shared(::ppapi::OBJECT_IS_IMPL, info),
       file_system_(file_system),
       external_file_system_path_() {
 }
 
 PPB_FileRef_Impl::PPB_FileRef_Impl(const PPB_FileRef_CreateInfo& info,
-                                   const FilePath& external_file_path)
+                                   const base::FilePath& external_file_path)
     : PPB_FileRef_Shared(::ppapi::OBJECT_IS_IMPL, info),
       file_system_(),
       external_file_system_path_(external_file_path) {
 }
 
 PPB_FileRef_Impl::~PPB_FileRef_Impl() {
 }
 
 // static
 PPB_FileRef_Impl* PPB_FileRef_Impl::CreateInternal(PP_Resource pp_file_system,
@@ skipping 23 matching lines @@
   TrimTrailingSlash(&info.path);
 
   info.name = GetNameForVirtualFilePath(info.path);
 
   return new PPB_FileRef_Impl(info, file_system);
 }
 
 // static
 PPB_FileRef_Impl* PPB_FileRef_Impl::CreateExternal(
     PP_Instance instance,
-    const FilePath& external_file_path,
+    const base::FilePath& external_file_path,
     const std::string& display_name) {
   PPB_FileRef_CreateInfo info;
   info.resource = HostResource::MakeInstanceOnly(instance);
   info.file_system_type = PP_FILESYSTEMTYPE_EXTERNAL;
   if (display_name.empty())
     info.name = GetNameForExternalFilePath(external_file_path);
   else
     info.name = display_name;
 
   return new PPB_FileRef_Impl(info, external_file_path);
@@ skipping 96 matching lines @@
 PP_Var PPB_FileRef_Impl::GetAbsolutePath() {
   if (GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL)
     return GetPath();
   if (!external_path_var_.get()) {
     external_path_var_ = new StringVar(
         external_file_system_path_.AsUTF8Unsafe());
   }
   return external_path_var_->GetPPVar();
 }
 
-FilePath PPB_FileRef_Impl::GetSystemPath() const {
+base::FilePath PPB_FileRef_Impl::GetSystemPath() const {
   if (GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL) {
     NOTREACHED();
-    return FilePath();
+    return base::FilePath();
   }
   return external_file_system_path_;
 }
 
 GURL PPB_FileRef_Impl::GetFileSystemURL() const {
   if (GetFileSystemType() != PP_FILESYSTEMTYPE_LOCALPERSISTENT &&
       GetFileSystemType() != PP_FILESYSTEMTYPE_LOCALTEMPORARY &&
       GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL) {
     NOTREACHED();
     return GURL();
@@ skipping 14 matching lines @@
   return file_system_ && file_system_->opened();
 }
 
 bool PPB_FileRef_Impl::IsValidNonExternalFileSystem() const {
   return file_system_ && file_system_->opened() &&
       file_system_->type() != PP_FILESYSTEMTYPE_EXTERNAL;
 }
 
 }  // namespace ppapi
 }  // namespace webkit