Add FilePath to base namespace.

webkit/fileapi/file_system_util.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/file_system_util.h"
 
 #include "build/build_config.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebCString.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "webkit/fileapi/file_system_types.h"
 
 namespace fileapi {
 
 const char kPersistentDir[] = "/persistent";
 const char kTemporaryDir[] = "/temporary";
 const char kIsolatedDir[] = "/isolated";
 const char kExternalDir[] = "/external";
 const char kTestDir[] = "/test";
 
 // TODO(ericu): Consider removing support for '\', even on Windows, if possible.
 // There's a lot of test code that will need reworking, and we may have trouble
-// with FilePath elsewhere [e.g. DirName and other methods may also need
+// with base::FilePath elsewhere [e.g. DirName and other methods may also need
 // replacement].
-FilePath VirtualPath::BaseName(const FilePath& virtual_path) {
-  FilePath::StringType path = virtual_path.value();
+base::FilePath VirtualPath::BaseName(const base::FilePath& virtual_path) {
+  base::FilePath::StringType path = virtual_path.value();
 
   // Keep everything after the final separator, but if the pathname is only
   // one character and it's a separator, leave it alone.
-  while (path.size() > 1 && FilePath::IsSeparator(path[path.size() - 1]))
+  while (path.size() > 1 && base::FilePath::IsSeparator(path[path.size() - 1]))
     path.resize(path.size() - 1);
-  FilePath::StringType::size_type last_separator =
-      path.find_last_of(FilePath::kSeparators);
-  if (last_separator != FilePath::StringType::npos &&
+  base::FilePath::StringType::size_type last_separator =
+      path.find_last_of(base::FilePath::kSeparators);
+  if (last_separator != base::FilePath::StringType::npos &&
       last_separator < path.size() - 1)
     path.erase(0, last_separator + 1);
 
-  return FilePath(path);
+  return base::FilePath(path);
 }
 
 void VirtualPath::GetComponents(
-    const FilePath& path, std::vector<FilePath::StringType>* components) {
+    const base::FilePath& path, std::vector<base::FilePath::StringType>* components) {
   DCHECK(components);
   if (!components)
     return;
   components->clear();
   if (path.value().empty())
     return;
 
-  std::vector<FilePath::StringType> ret_val;
-  FilePath current = path;
-  FilePath base;
+  std::vector<base::FilePath::StringType> ret_val;
+  base::FilePath current = path;
+  base::FilePath base;
 
-  // Due to the way things are implemented, FilePath::DirName works here,
-  // whereas FilePath::BaseName doesn't.
+  // Due to the way things are implemented, base::FilePath::DirName works here,
+  // whereas base::FilePath::BaseName doesn't.
   while (current != current.DirName()) {
     base = BaseName(current);
     ret_val.push_back(base.value());
     current = current.DirName();
   }
 
   *components =
-      std::vector<FilePath::StringType>(ret_val.rbegin(), ret_val.rend());
+      std::vector<base::FilePath::StringType>(ret_val.rbegin(), ret_val.rend());
 }
 
 GURL GetFileSystemRootURI(const GURL& origin_url, FileSystemType type) {
   // origin_url is based on a security origin, so http://foo.com or file:///
   // instead of the corresponding filesystem URL.
   DCHECK(!origin_url.SchemeIsFileSystem());
 
   std::string url = "filesystem:" + origin_url.GetWithEmptyPath().spec();
   switch (type) {
   case kFileSystemTypeTemporary:
@@ skipping 105 matching lines @@
       return "Drive";
     case kFileSystemTypeSyncable:
       return "Syncable";
     case kFileSystemTypeUnknown:
       return "Unknown";
   }
   NOTREACHED();
   return std::string();
 }
 
-std::string FilePathToString(const FilePath& file_path) {
+std::string FilePathToString(const base::FilePath& file_path) {
 #if defined(OS_WIN)
   return UTF16ToUTF8(file_path.value());
 #elif defined(OS_POSIX)
   return file_path.value();
 #endif
 }
 
-FilePath StringToFilePath(const std::string& file_path_string) {
+base::FilePath StringToFilePath(const std::string& file_path_string) {
 #if defined(OS_WIN)
-  return FilePath(UTF8ToUTF16(file_path_string));
+  return base::FilePath(UTF8ToUTF16(file_path_string));
 #elif defined(OS_POSIX)
-  return FilePath(file_path_string);
+  return base::FilePath(file_path_string);
 #endif
 }
 
 WebKit::WebFileError PlatformFileErrorToWebFileError(
     base::PlatformFileError error_code) {
   switch (error_code) {
     case base::PLATFORM_FILE_ERROR_NOT_FOUND:
       return WebKit::WebFileErrorNotFound;
     case base::PLATFORM_FILE_ERROR_INVALID_OPERATION:
     case base::PLATFORM_FILE_ERROR_EXISTS:
@@ skipping 56 matching lines @@
 
 std::string GetIsolatedFileSystemRootURIString(
     const GURL& origin_url,
     const std::string& filesystem_id,
     const std::string& optional_root_name) {
   std::string root = GetFileSystemRootURI(origin_url,
                                           kFileSystemTypeIsolated).spec();
   root.append(filesystem_id);
   root.append("/");
   if (!optional_root_name.empty()) {
-    DCHECK(!FilePath::FromUTF8Unsafe(optional_root_name).ReferencesParent());
+    DCHECK(!base::FilePath::FromUTF8Unsafe(optional_root_name).ReferencesParent());
     root.append(optional_root_name);
     root.append("/");
   }
   return root;
 }
 
 }  // namespace fileapi