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
|
// 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.
#ifndef STORAGE_COMMON_FILEAPI_FILE_SYSTEM_TYPES_H_
#define STORAGE_COMMON_FILEAPI_FILE_SYSTEM_TYPES_H_
#include "third_party/WebKit/public/platform/WebFileSystemType.h"
namespace storage {
enum FileSystemType {
// Indicates uninitialized or invalid filesystem type.
kFileSystemTypeUnknown = -1,
// ------------------------------------------------------------------------
// Public FileSystem types, that are embedded in filesystem: URL and exposed
// to WebKit/renderer. Both Chrome and WebKit know how to handle these types.
// Following two types are for TEMPORARY or PERSISTENT filesystems that
// can be used by webapps via standard app-facing API
// as defined in File API: Directories and System.
// http://www.w3.org/TR/file-system-api/#temporary-vs.-persistent-storage
// They are sandboxed filesystems; all the files in the filesystems are
// placed under the profile directory with path obfuscation and quota
// enforcement.
kFileSystemTypeTemporary = blink::WebFileSystemTypeTemporary,
kFileSystemTypePersistent = blink::WebFileSystemTypePersistent,
// Indicates non-sandboxed isolated filesystem.
kFileSystemTypeIsolated = blink::WebFileSystemTypeIsolated,
// Indicates filesystems that are mounted externally via
// ExternalMountPoints with a well-known mount name. The mounted
// filesystems can be sandboxed or non-sandboxed. (E.g. Chrome OS mounts
// non-sandboxed removable media folder with a name 'removable', while
// chrome.syncFileSystem mounts a sandboxed filesystem with a name
// 'syncfs'.)
kFileSystemTypeExternal = blink::WebFileSystemTypeExternal,
// ------------------------------------------------------------------------
// Marks the beginning of internal type enum. (This is not the actual fs type)
kFileSystemInternalTypeEnumStart = 99,
// Private FileSystem types, that should not appear in filesystem: URL as
// WebKit has no idea how to handle those types.
//
// One can register (mount) a new file system with a private file system type
// using IsolatedContext. Files in such file systems can be accessed via
// either Isolated or External public file system types (depending on
// how the file system is registered).
// See the comments for IsolatedContext and/or FileSystemURL for more details.
// Should be used only for testing.
kFileSystemTypeTest,
// Indicates a local filesystem where we can access files using native
// local path.
kFileSystemTypeNativeLocal,
// Indicates a local filesystem where we can access files using native
// local path, but with restricted access.
// Restricted native local file system is in read-only mode.
kFileSystemTypeRestrictedNativeLocal,
// Indicates a transient, isolated file system for dragged files (which could
// contain multiple dragged paths in the virtual root).
kFileSystemTypeDragged,
// Indicates media filesystem which we can access with same manner to
// regular filesystem.
kFileSystemTypeNativeMedia,
// Indicates media filesystem to which we need special protocol to access,
// such as MTP or PTP.
kFileSystemTypeDeviceMedia,
// Indicates a Picasa virtual filesystem provided by Media Galleries API.
kFileSystemTypePicasa,
// Indicates a synthetic iTunes filesystem.
kFileSystemTypeItunes,
// Indicates a Drive filesystem which provides access to Google Drive.
kFileSystemTypeDrive,
// Indicates a Syncable sandboxed filesystem which can be backed by a
// cloud storage service.
kFileSystemTypeSyncable,
// Indicates a special filesystem type for internal file sync operation
// for Syncable sandboxed filesystems. The file system is overlayed, i.e.
// points to the same sandboxed filesystem as that of kFileSystemTypeSyncable,
// but the changes made with this filesystem type are not recorded for
// further sync.
kFileSystemTypeSyncableForInternalSync,
// Indicates an external filesystem accessible by file paths from platform
// Apps. As of writing, on non Chrome OS platform, this is merely a
// kFileSystemTypeNativeLocal. On Chrome OS, the path is parsed by
// the handlers of kFileSystemTypeExternal.
kFileSystemTypeNativeForPlatformApp,
// Indicates an isolated filesystem which is supposed to contain one
// temporary which is supposed to go away when the last reference of
// its snapshot is dropped.
// This type is useful for creating a blob reference for a temporary
// file which must go away when the blob's last reference is dropped.
kFileSystemTypeForTransientFile,
// Sandboxed private filesystem. This filesystem cannot be opened
// via regular OpenFileSystem, and provides private filesystem space for
// given identifier in each origin.
kFileSystemTypePluginPrivate,
// A filesystem that is mounted via the Privet storage protocol.
kFileSystemTypeCloudDevice,
// A filesystem that is mounted via the FileSystemProvider API.
kFileSystemTypeProvided,
// A media filesystem such as MTP or PTP, mounted as a file storage not
// limited to media files.
kFileSystemTypeDeviceMediaAsFileStorage,
// --------------------------------------------------------------------
// Marks the end of internal type enum. (This is not the actual fs type)
// New internal filesystem types must be added above this line.
kFileSystemInternalTypeEnumEnd,
};
} // namespace storage
#endif // STORAGE_COMMON_FILEAPI_FILE_SYSTEM_TYPES_H_
|
