• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "storage/browser/fileapi/file_system_url.h"
6 
7 #include <sstream>
8 
9 #include "base/logging.h"
10 #include "base/strings/string_util.h"
11 #include "net/base/escape.h"
12 #include "storage/common/fileapi/file_system_types.h"
13 #include "storage/common/fileapi/file_system_util.h"
14 
15 namespace storage {
16 
17 namespace {
18 
19 }  // namespace
20 
FileSystemURL()21 FileSystemURL::FileSystemURL()
22     : is_valid_(false),
23       mount_type_(kFileSystemTypeUnknown),
24       type_(kFileSystemTypeUnknown),
25       mount_option_(COPY_SYNC_OPTION_NO_SYNC) {
26 }
27 
28 // static
CreateForTest(const GURL & url)29 FileSystemURL FileSystemURL::CreateForTest(const GURL& url) {
30   return FileSystemURL(url);
31 }
32 
CreateForTest(const GURL & origin,FileSystemType mount_type,const base::FilePath & virtual_path)33 FileSystemURL FileSystemURL::CreateForTest(const GURL& origin,
34                                            FileSystemType mount_type,
35                                            const base::FilePath& virtual_path) {
36   return FileSystemURL(origin, mount_type, virtual_path);
37 }
38 
CreateForTest(const GURL & origin,FileSystemType mount_type,const base::FilePath & virtual_path,const std::string & mount_filesystem_id,FileSystemType cracked_type,const base::FilePath & cracked_path,const std::string & filesystem_id,const FileSystemMountOption & mount_option)39 FileSystemURL FileSystemURL::CreateForTest(
40     const GURL& origin,
41     FileSystemType mount_type,
42     const base::FilePath& virtual_path,
43     const std::string& mount_filesystem_id,
44     FileSystemType cracked_type,
45     const base::FilePath& cracked_path,
46     const std::string& filesystem_id,
47     const FileSystemMountOption& mount_option) {
48   return FileSystemURL(origin,
49                        mount_type,
50                        virtual_path,
51                        mount_filesystem_id,
52                        cracked_type,
53                        cracked_path,
54                        filesystem_id,
55                        mount_option);
56 }
57 
FileSystemURL(const GURL & url)58 FileSystemURL::FileSystemURL(const GURL& url)
59     : mount_type_(kFileSystemTypeUnknown),
60       type_(kFileSystemTypeUnknown),
61       mount_option_(COPY_SYNC_OPTION_NO_SYNC) {
62   is_valid_ = ParseFileSystemSchemeURL(url, &origin_, &mount_type_,
63                                        &virtual_path_);
64   path_ = virtual_path_;
65   type_ = mount_type_;
66 }
67 
FileSystemURL(const GURL & origin,FileSystemType mount_type,const base::FilePath & virtual_path)68 FileSystemURL::FileSystemURL(const GURL& origin,
69                              FileSystemType mount_type,
70                              const base::FilePath& virtual_path)
71     : is_valid_(true),
72       origin_(origin),
73       mount_type_(mount_type),
74       virtual_path_(virtual_path.NormalizePathSeparators()),
75       type_(mount_type),
76       path_(virtual_path.NormalizePathSeparators()),
77       mount_option_(COPY_SYNC_OPTION_NO_SYNC) {
78 }
79 
FileSystemURL(const GURL & origin,FileSystemType mount_type,const base::FilePath & virtual_path,const std::string & mount_filesystem_id,FileSystemType cracked_type,const base::FilePath & cracked_path,const std::string & filesystem_id,const FileSystemMountOption & mount_option)80 FileSystemURL::FileSystemURL(const GURL& origin,
81                              FileSystemType mount_type,
82                              const base::FilePath& virtual_path,
83                              const std::string& mount_filesystem_id,
84                              FileSystemType cracked_type,
85                              const base::FilePath& cracked_path,
86                              const std::string& filesystem_id,
87                              const FileSystemMountOption& mount_option)
88     : is_valid_(true),
89       origin_(origin),
90       mount_type_(mount_type),
91       virtual_path_(virtual_path.NormalizePathSeparators()),
92       mount_filesystem_id_(mount_filesystem_id),
93       type_(cracked_type),
94       path_(cracked_path.NormalizePathSeparators()),
95       filesystem_id_(filesystem_id),
96       mount_option_(mount_option) {
97 }
98 
~FileSystemURL()99 FileSystemURL::~FileSystemURL() {}
100 
ToGURL() const101 GURL FileSystemURL::ToGURL() const {
102   if (!is_valid_)
103     return GURL();
104 
105   std::string url = GetFileSystemRootURI(origin_, mount_type_).spec();
106   if (url.empty())
107     return GURL();
108 
109   // Exactly match with DOMFileSystemBase::createFileSystemURL()'s encoding
110   // behavior, where the path is escaped by KURL::encodeWithURLEscapeSequences
111   // which is essentially encodeURIComponent except '/'.
112   std::string escaped = net::EscapeQueryParamValue(
113       virtual_path_.NormalizePathSeparatorsTo('/').AsUTF8Unsafe(),
114       false /* use_plus */);
115   ReplaceSubstringsAfterOffset(&escaped, 0, "%2F", "/");
116   url.append(escaped);
117 
118   // Build nested GURL.
119   return GURL(url);
120 }
121 
DebugString() const122 std::string FileSystemURL::DebugString() const {
123   if (!is_valid_)
124     return "invalid filesystem: URL";
125   std::ostringstream ss;
126   ss << GetFileSystemRootURI(origin_, mount_type_);
127 
128   // filesystem_id_ will be non empty for (and only for) cracked URLs.
129   if (!filesystem_id_.empty()) {
130     ss << virtual_path_.value();
131     ss << " (";
132     ss << GetFileSystemTypeString(type_) << "@" << filesystem_id_ << ":";
133     ss << path_.value();
134     ss << ")";
135   } else {
136     ss << path_.value();
137   }
138   return ss.str();
139 }
140 
IsParent(const FileSystemURL & child) const141 bool FileSystemURL::IsParent(const FileSystemURL& child) const {
142   return IsInSameFileSystem(child) &&
143          path().IsParent(child.path());
144 }
145 
IsInSameFileSystem(const FileSystemURL & other) const146 bool FileSystemURL::IsInSameFileSystem(const FileSystemURL& other) const {
147   return origin() == other.origin() &&
148          type() == other.type() &&
149          filesystem_id() == other.filesystem_id();
150 }
151 
operator ==(const FileSystemURL & that) const152 bool FileSystemURL::operator==(const FileSystemURL& that) const {
153   return origin_ == that.origin_ &&
154       type_ == that.type_ &&
155       path_ == that.path_ &&
156       filesystem_id_ == that.filesystem_id_ &&
157       is_valid_ == that.is_valid_;
158 }
159 
operator ()(const FileSystemURL & lhs,const FileSystemURL & rhs) const160 bool FileSystemURL::Comparator::operator()(const FileSystemURL& lhs,
161                                            const FileSystemURL& rhs) const {
162   DCHECK(lhs.is_valid_ && rhs.is_valid_);
163   if (lhs.origin_ != rhs.origin_)
164     return lhs.origin_ < rhs.origin_;
165   if (lhs.type_ != rhs.type_)
166     return lhs.type_ < rhs.type_;
167   if (lhs.filesystem_id_ != rhs.filesystem_id_)
168     return lhs.filesystem_id_ < rhs.filesystem_id_;
169   return lhs.path_ < rhs.path_;
170 }
171 
172 }  // namespace storage
173