1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
// Copyright (c) 2010 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.
#ifndef WEBKIT_FILEAPI_FILE_SYSTEM_PATH_MANAGER_H_
#define WEBKIT_FILEAPI_FILE_SYSTEM_PATH_MANAGER_H_
#pragma once
#include "base/callback.h"
#include "base/file_path.h"
#include "base/file_util.h"
#include "webkit/fileapi/file_system_types.h"
class GURL;
namespace base {
class MessageLoopProxy;
}
namespace fileapi {
// TODO(kinuko): Probably this module must be called FileSystemPathUtil
// or something similar.
// An interface to construct or crack sandboxed filesystem paths.
// Currently each sandboxed filesystem path looks like:
//
// <profile_dir>/FileSystem/<origin_identifier>/<type>/chrome-<unique>/...
//
// <type> is either one of "Temporary" or "Persistent".
class FileSystemPathManager {
public:
FileSystemPathManager(scoped_refptr<base::MessageLoopProxy> file_message_loop,
const FilePath& profile_path,
bool is_incognito,
bool allow_file_access_from_files);
~FileSystemPathManager();
// Callback for GetFileSystemRootPath.
// If the request is accepted and the root filesystem for the origin exists
// the callback is called with success=true and valid root_path and name.
// If the request is accepted, |create| is specified for
// GetFileSystemRootPath, and the root directory does not exist, it creates
// a new one and calls back with success=true if the creation has succeeded.
typedef Callback3<bool /* success */,
const FilePath& /* root_path */,
const std::string& /* name */>::Type GetRootPathCallback;
// Retrieves the root path for the given |origin_url| and |type|, and
// calls the given |callback| with the root path and name.
// If |create| is true this also creates the directory if it doesn't exist.
void GetFileSystemRootPath(const GURL& origin_url,
fileapi::FileSystemType type,
bool create,
GetRootPathCallback* callback);
// Cracks the given |path|, retrieves the information embedded in the path
// and populates |origin_url|, |type| and |virtual_path|. The |virtual_path|
// is a sandboxed path in the file system, i.e. the relative path to the
// filesystem root for the given domain and type.
bool CrackFileSystemPath(const FilePath& path,
GURL* origin_url,
FileSystemType* type,
FilePath* virtual_path) const;
// Returns true if the given |url|'s scheme is allowed to access
// filesystem.
bool IsAllowedScheme(const GURL& url) const;
// The FileSystem directory name.
static const FilePath::CharType kFileSystemDirectory[];
static const char kPersistentName[];
static const char kTemporaryName[];
const FilePath& base_path() const {
return base_path_;
}
// Checks if a given |name| contains any restricted names/chars in it.
static bool IsRestrictedFileName(const FilePath& filename);
// Returns the string for the given |type|.
// Returns an empty string if the |type| is invalid.
static std::string GetFileSystemTypeString(fileapi::FileSystemType type);
// Returns the origin identifier string, which is used as a part of the
// sandboxed path component, for the given |url|.
static std::string GetOriginIdentifierFromURL(const GURL& url);
// Gets a base directory path of the sandboxed filesystem that is
// specified by |origin_identifier| and |type|.
// |base_path| must be pointing the FileSystem's data directory
// under the profile directory, i.e. <profile_dir>/kFileSystemDirectory.
// Returns an empty path if any of the given parameters are invalid.
// Returned directory path does not contain 'unique' part, therefore
// it is not an actural root path for the filesystem.
static FilePath GetFileSystemBaseDirectoryForOriginAndType(
const FilePath& base_path,
const std::string& origin_identifier,
fileapi::FileSystemType type);
// Enumerates origins under the given |base_path|.
// This must be used on the FILE thread.
class OriginEnumerator {
public:
OriginEnumerator(const FilePath& base_path);
// Returns the next origin identifier. Returns empty if there are no
// more origins.
std::string Next();
bool HasTemporary();
bool HasPersistent();
const FilePath& path() { return current_; }
private:
file_util::FileEnumerator enumerator_;
FilePath current_;
};
private:
class GetFileSystemRootPathTask;
scoped_refptr<base::MessageLoopProxy> file_message_loop_;
const FilePath base_path_;
const bool is_incognito_;
const bool allow_file_access_from_files_;
DISALLOW_COPY_AND_ASSIGN(FileSystemPathManager);
};
} // namespace fileapi
#endif // WEBKIT_FILEAPI_FILE_SYSTEM_PATH_MANAGER_H_
|
