Add FilePath to base namespace.

webkit/fileapi/file_system_url.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_url.h"
 
 #include <sstream>
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "net/base/escape.h"
 #include "webkit/fileapi/external_mount_points.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/isolated_context.h"
 
 namespace fileapi {
 
 namespace {
 
 bool ParseFileSystemURL(const GURL& url,
                         GURL* origin_url,
                         FileSystemType* type,
-                        FilePath* file_path) {
+                        base::FilePath* file_path) {
   GURL origin;
   FileSystemType file_system_type = kFileSystemTypeUnknown;
 
   if (!url.is_valid() || !url.SchemeIsFileSystem())
     return false;
   DCHECK(url.inner_url());
 
   std::string inner_path = url.inner_url()->path();
 
   const struct {
@@ skipping 18 matching lines @@
     return false;
 
   std::string path = net::UnescapeURLComponent(url.path(),
       net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS |
       net::UnescapeRule::CONTROL_CHARS);
 
   // Ensure the path is relative.
   while (!path.empty() && path[0] == '/')
     path.erase(0, 1);
 
-  FilePath converted_path = FilePath::FromUTF8Unsafe(path);
+  base::FilePath converted_path = base::FilePath::FromUTF8Unsafe(path);
 
   // All parent references should have been resolved in the renderer.
   if (converted_path.ReferencesParent())
     return false;
 
   if (origin_url)
     *origin_url = url.GetOrigin();
   if (type)
     *type = file_system_type;
   if (file_path)
@@ skipping 11 matching lines @@
       mount_type_(kFileSystemTypeUnknown) {
 }
 
 // static
 FileSystemURL FileSystemURL::CreateForTest(const GURL& url) {
   return FileSystemURL(url);
 }
 
 FileSystemURL FileSystemURL::CreateForTest(const GURL& origin,
                                            FileSystemType type,
-                                           const FilePath& path) {
+                                           const base::FilePath& path) {
   return FileSystemURL(origin, type, path);
 }
 
 FileSystemURL::FileSystemURL(const GURL& url)
     : type_(kFileSystemTypeUnknown),
       mount_type_(kFileSystemTypeUnknown) {
   is_valid_ = ParseFileSystemURL(url, &origin_, &type_, &path_);
   mount_type_ = type_;
 }
 
 FileSystemURL::FileSystemURL(const GURL& origin,
                              FileSystemType type,
-                             const FilePath& path)
+                             const base::FilePath& path)
     : is_valid_(true),
       origin_(origin),
       type_(type),
       mount_type_(type),
       path_(path.NormalizePathSeparators()) {
 }
 
 FileSystemURL::FileSystemURL(const GURL& origin,
                              FileSystemType original_type,
-                             const FilePath& original_path,
+                             const base::FilePath& original_path,
                              const std::string& filesystem_id,
                              FileSystemType cracked_type,
-                             const FilePath& cracked_path)
+                             const base::FilePath& cracked_path)
     : is_valid_(true),
       origin_(origin),
       type_(cracked_type),
       mount_type_(original_type),
       path_(cracked_path.NormalizePathSeparators()),
       filesystem_id_(filesystem_id),
       virtual_path_(original_path.NormalizePathSeparators()) {
 }
 
 FileSystemURL::~FileSystemURL() {}
@@ skipping 10 matching lines @@
     ss << " (";
     ss << GetFileSystemTypeString(type_) << "@" << filesystem_id_ << ":";
     ss << path_.value();
     ss << ")";
   } else {
     ss << path_.value();
   }
   return ss.str();
 }
 
-FileSystemURL FileSystemURL::WithPath(const FilePath& path) const {
+FileSystemURL FileSystemURL::WithPath(const base::FilePath& path) const {
   FileSystemURL url = *this;
   url.path_ = path;
   url.virtual_path_.clear();
   return url;
 }
 
 bool FileSystemURL::IsParent(const FileSystemURL& child) const {
   return origin() == child.origin() &&
          type() == child.type() &&
          filesystem_id() == child.filesystem_id() &&
@@ skipping 14 matching lines @@
   if (lhs.origin_ != rhs.origin_)
     return lhs.origin_ < rhs.origin_;
   if (lhs.type_ != rhs.type_)
     return lhs.type_ < rhs.type_;
   if (lhs.filesystem_id_ != rhs.filesystem_id_)
     return lhs.filesystem_id_ < rhs.filesystem_id_;
   return lhs.path_ < rhs.path_;
 }
 
 }  // namespace fileapi