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#ifndef STORAGE_BROWSER_FILEAPI_FILE_SYSTEM_URL_H_
6#define STORAGE_BROWSER_FILEAPI_FILE_SYSTEM_URL_H_
7
8#include <set>
9#include <string>
10
11#include "base/files/file_path.h"
12#include "storage/browser/storage_browser_export.h"
13#include "storage/common/fileapi/file_system_mount_option.h"
14#include "storage/common/fileapi/file_system_types.h"
15#include "url/gurl.h"
16
17namespace storage {
18
19// A class representing a filesystem URL which consists of origin URL,
20// type and an internal path used inside the filesystem.
21//
22// When a FileSystemURL instance is created for a GURL (for filesystem: scheme),
23// each accessor method would return following values:
24//
25// Example: For a URL 'filesystem:http://foo.com/temporary/foo/bar':
26//   origin() returns 'http://foo.com',
27//   mount_type() returns kFileSystemTypeTemporary,
28//   virtual_path() returns 'foo/bar',
29//   type() returns the same value as mount_type(),
30//   path() returns the same value as virtual_path(),
31//
32// All other accessors return empty or invalid value.
33//
34// FileSystemURL can also be created to represent a 'cracked' filesystem URL if
35// the original URL's type/path is pointing to a mount point which can be
36// further resolved to a lower filesystem type/path.
37//
38// Example: Assume a path '/media/removable' is mounted at mount name
39// 'mount_name' with type kFileSystemTypeFoo as an external file system.
40//
41// The original URL would look like:
42//     'filesystem:http://bar.com/external/mount_name/foo/bar':
43//
44// FileSystemURL('http://bar.com',
45//               kFileSystemTypeExternal,
46//               'mount_name/foo/bar'
47//               'mount_name',
48//               kFileSystemTypeFoo,
49//               '/media/removable/foo/bar');
50// would create a FileSystemURL whose accessors return:
51//
52//   origin() returns 'http://bar.com',
53//   mount_type() returns kFileSystemTypeExternal,
54//   virtual_path() returns 'mount_name/foo/bar',
55//   type() returns the kFileSystemTypeFoo,
56//   path() returns '/media/removable/foo/bar',
57//
58// Note that in either case virtual_path() always returns the path part after
59// 'type' part in the original URL, and mount_type() always returns the 'type'
60// part in the original URL.
61//
62// Additionally, following accessors would return valid values:
63//   filesystem_id() returns 'mount_name'.
64//
65// It is impossible to directly create a valid FileSystemURL instance (except by
66// using CreatedForTest methods, which should not be used in production code).
67// To get a valid FileSystemURL, one of the following methods can be used:
68// <Friend>::CrackURL, <Friend>::CreateCrackedFileSystemURL, where <Friend> is
69// one of the friended classes.
70//
71// TODO(ericu): Look into making virtual_path() [and all FileSystem API virtual
72// paths] just an std::string, to prevent platform-specific base::FilePath
73// behavior from getting invoked by accident. Currently the base::FilePath
74// returned here needs special treatment, as it may contain paths that are
75// illegal on the current platform.
76// To avoid problems, use VirtualPath::BaseName and
77// VirtualPath::GetComponents instead of the base::FilePath methods.
78class STORAGE_EXPORT FileSystemURL {
79 public:
80  FileSystemURL();
81  ~FileSystemURL();
82
83  // Methods for creating FileSystemURL without attempting to crack them.
84  // Should be used only in tests.
85  static FileSystemURL CreateForTest(const GURL& url);
86  static FileSystemURL CreateForTest(const GURL& origin,
87                                     FileSystemType mount_type,
88                                     const base::FilePath& virtual_path);
89  static FileSystemURL CreateForTest(const GURL& origin,
90                                     FileSystemType mount_type,
91                                     const base::FilePath& virtual_path,
92                                     const std::string& mount_filesystem_id,
93                                     FileSystemType cracked_type,
94                                     const base::FilePath& cracked_path,
95                                     const std::string& filesystem_id,
96                                     const FileSystemMountOption& mount_option);
97
98  // Returns true if this instance represents a valid FileSystem URL.
99  bool is_valid() const { return is_valid_; }
100
101  // Returns the origin part of this URL. See the class comment for details.
102  const GURL& origin() const { return origin_; }
103
104  // Returns the type part of this URL. See the class comment for details.
105  FileSystemType type() const { return type_; }
106
107  // Returns the cracked path of this URL. See the class comment for details.
108  const base::FilePath& path() const { return path_; }
109
110  // Returns the original path part of this URL.
111  // See the class comment for details.
112  // TODO(kinuko): this must return std::string.
113  const base::FilePath& virtual_path() const { return virtual_path_; }
114
115  // Returns the filesystem ID/mount name for isolated/external filesystem URLs.
116  // See the class comment for details.
117  const std::string& filesystem_id() const { return filesystem_id_; }
118  const std::string& mount_filesystem_id() const {
119    return mount_filesystem_id_;
120  }
121
122  FileSystemType mount_type() const { return mount_type_; }
123
124  const FileSystemMountOption& mount_option() const { return mount_option_; }
125
126  // Returns the formatted URL of this instance.
127  GURL ToGURL() const;
128
129  std::string DebugString() const;
130
131  // Returns true if this URL is a strict parent of the |child|.
132  bool IsParent(const FileSystemURL& child) const;
133
134  bool IsInSameFileSystem(const FileSystemURL& other) const;
135
136  bool operator==(const FileSystemURL& that) const;
137
138  bool operator!=(const FileSystemURL& that) const {
139    return !(*this == that);
140  }
141
142  struct STORAGE_EXPORT Comparator {
143    bool operator() (const FileSystemURL& lhs, const FileSystemURL& rhs) const;
144  };
145
146 private:
147  friend class FileSystemContext;
148  friend class ExternalMountPoints;
149  friend class IsolatedContext;
150
151  explicit FileSystemURL(const GURL& filesystem_url);
152  FileSystemURL(const GURL& origin,
153                FileSystemType mount_type,
154                const base::FilePath& virtual_path);
155  // Creates a cracked FileSystemURL.
156  FileSystemURL(const GURL& origin,
157                FileSystemType mount_type,
158                const base::FilePath& virtual_path,
159                const std::string& mount_filesystem_id,
160                FileSystemType cracked_type,
161                const base::FilePath& cracked_path,
162                const std::string& filesystem_id,
163                const FileSystemMountOption& mount_option);
164
165  bool is_valid_;
166
167  // Values parsed from the original URL.
168  GURL origin_;
169  FileSystemType mount_type_;
170  base::FilePath virtual_path_;
171
172  // Values obtained by cracking URLs.
173  // |mount_filesystem_id_| is retrieved from the first round of cracking,
174  // and the rest of the fields are from recursive cracking. Permission
175  // checking on the top-level mount information should be done with the former,
176  // and the low-level file operation should be implemented with the latter.
177  std::string mount_filesystem_id_;
178  FileSystemType type_;
179  base::FilePath path_;
180  std::string filesystem_id_;
181  FileSystemMountOption mount_option_;
182};
183
184typedef std::set<FileSystemURL, FileSystemURL::Comparator> FileSystemURLSet;
185
186}  // namespace storage
187
188#endif  // STORAGE_BROWSER_FILEAPI_FILE_SYSTEM_URL_H_
189