Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(527)

Side by Side Diff: webkit/browser/chromeos/fileapi/cros_mount_point_provider.cc

Issue 17644006: Move files under webkit/browser/fileapi/... to chrome/browser/chromeos/fileapi/... (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: address review comments. Created 7 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
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 "webkit/browser/chromeos/fileapi/cros_mount_point_provider.h"
6
7 #include "base/logging.h"
8 #include "base/memory/scoped_ptr.h"
9 #include "base/message_loop.h"
10 #include "base/path_service.h"
11 #include "base/strings/stringprintf.h"
12 #include "base/strings/utf_string_conversions.h"
13 #include "base/synchronization/lock.h"
14 #include "chromeos/dbus/cros_disks_client.h"
15 #include "third_party/WebKit/public/platform/WebCString.h"
16 #include "third_party/WebKit/public/platform/WebFileSystem.h"
17 #include "third_party/WebKit/public/platform/WebString.h"
18 #include "webkit/browser/chromeos/fileapi/file_access_permissions.h"
19 #include "webkit/browser/chromeos/fileapi/remote_file_stream_writer.h"
20 #include "webkit/browser/chromeos/fileapi/remote_file_system_operation.h"
21 #include "webkit/browser/fileapi/async_file_util_adapter.h"
22 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
23 #include "webkit/browser/fileapi/external_mount_points.h"
24 #include "webkit/browser/fileapi/file_system_context.h"
25 #include "webkit/browser/fileapi/file_system_file_stream_reader.h"
26 #include "webkit/browser/fileapi/file_system_operation_context.h"
27 #include "webkit/browser/fileapi/file_system_task_runners.h"
28 #include "webkit/browser/fileapi/file_system_url.h"
29 #include "webkit/browser/fileapi/isolated_context.h"
30 #include "webkit/browser/fileapi/isolated_file_util.h"
31 #include "webkit/browser/fileapi/local_file_stream_writer.h"
32 #include "webkit/browser/fileapi/local_file_system_operation.h"
33
34 namespace {
35
36 const char kChromeUIScheme[] = "chrome";
37
38 } // namespace
39
40 namespace chromeos {
41
42 // static
43 bool CrosMountPointProvider::CanHandleURL(const fileapi::FileSystemURL& url) {
44 if (!url.is_valid())
45 return false;
46 return url.type() == fileapi::kFileSystemTypeNativeLocal ||
47 url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal ||
48 url.type() == fileapi::kFileSystemTypeDrive;
49 }
50
51 CrosMountPointProvider::CrosMountPointProvider(
52 scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy,
53 scoped_refptr<fileapi::ExternalMountPoints> mount_points,
54 fileapi::ExternalMountPoints* system_mount_points)
55 : special_storage_policy_(special_storage_policy),
56 file_access_permissions_(new FileAccessPermissions()),
57 local_file_util_(new fileapi::AsyncFileUtilAdapter(
58 new fileapi::IsolatedFileUtil())),
59 mount_points_(mount_points),
60 system_mount_points_(system_mount_points) {
61 }
62
63 CrosMountPointProvider::~CrosMountPointProvider() {
64 }
65
66 void CrosMountPointProvider::AddSystemMountPoints() {
67 // RegisterFileSystem() is no-op if the mount point with the same name
68 // already exists, hence it's safe to call without checking if a mount
69 // point already exists or not.
70
71 // TODO(satorux): "Downloads" directory should probably be per-profile. For
72 // this to be per-profile, a unique directory path should be chosen per
73 // profile, and the mount point should be added to
74 // mount_points_. crbug.com/247236
75 base::FilePath home_path;
76 if (PathService::Get(base::DIR_HOME, &home_path)) {
77 system_mount_points_->RegisterFileSystem(
78 "Downloads",
79 fileapi::kFileSystemTypeNativeLocal,
80 home_path.AppendASCII("Downloads"));
81 }
82
83 system_mount_points_->RegisterFileSystem(
84 "archive",
85 fileapi::kFileSystemTypeNativeLocal,
86 chromeos::CrosDisksClient::GetArchiveMountPoint());
87 system_mount_points_->RegisterFileSystem(
88 "removable",
89 fileapi::kFileSystemTypeNativeLocal,
90 chromeos::CrosDisksClient::GetRemovableDiskMountPoint());
91 system_mount_points_->RegisterFileSystem(
92 "oem",
93 fileapi::kFileSystemTypeRestrictedNativeLocal,
94 base::FilePath(FILE_PATH_LITERAL("/usr/share/oem")));
95 }
96
97 bool CrosMountPointProvider::CanHandleType(fileapi::FileSystemType type) const {
98 switch (type) {
99 case fileapi::kFileSystemTypeExternal:
100 case fileapi::kFileSystemTypeDrive:
101 case fileapi::kFileSystemTypeRestrictedNativeLocal:
102 case fileapi::kFileSystemTypeNativeLocal:
103 case fileapi::kFileSystemTypeNativeForPlatformApp:
104 return true;
105 default:
106 return false;
107 }
108 }
109
110 void CrosMountPointProvider::OpenFileSystem(
111 const GURL& origin_url,
112 fileapi::FileSystemType type,
113 fileapi::OpenFileSystemMode mode,
114 const OpenFileSystemCallback& callback) {
115 DCHECK(fileapi::IsolatedContext::IsIsolatedType(type));
116 // Nothing to validate for external filesystem.
117 callback.Run(base::PLATFORM_FILE_OK);
118 }
119
120 fileapi::FileSystemQuotaUtil* CrosMountPointProvider::GetQuotaUtil() {
121 // No quota support.
122 return NULL;
123 }
124
125 void CrosMountPointProvider::DeleteFileSystem(
126 const GURL& origin_url,
127 fileapi::FileSystemType type,
128 fileapi::FileSystemContext* context,
129 const DeleteFileSystemCallback& callback) {
130 NOTREACHED();
131 callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
132 }
133
134 bool CrosMountPointProvider::IsAccessAllowed(
135 const fileapi::FileSystemURL& url) const {
136 if (!url.is_valid())
137 return false;
138
139 // Permit access to mount points from internal WebUI.
140 const GURL& origin_url = url.origin();
141 if (origin_url.SchemeIs(kChromeUIScheme))
142 return true;
143
144 // No extra check is needed for isolated file systems.
145 if (url.mount_type() == fileapi::kFileSystemTypeIsolated)
146 return true;
147
148 if (!CanHandleURL(url))
149 return false;
150
151 std::string extension_id = origin_url.host();
152 // Check first to make sure this extension has fileBrowserHander permissions.
153 if (!special_storage_policy_->IsFileHandler(extension_id))
154 return false;
155
156 return file_access_permissions_->HasAccessPermission(extension_id,
157 url.virtual_path());
158 }
159
160 void CrosMountPointProvider::GrantFullAccessToExtension(
161 const std::string& extension_id) {
162 DCHECK(special_storage_policy_->IsFileHandler(extension_id));
163 if (!special_storage_policy_->IsFileHandler(extension_id))
164 return;
165
166 std::vector<fileapi::MountPoints::MountPointInfo> files;
167 mount_points_->AddMountPointInfosTo(&files);
168 system_mount_points_->AddMountPointInfosTo(&files);
169
170 for (size_t i = 0; i < files.size(); ++i) {
171 file_access_permissions_->GrantAccessPermission(
172 extension_id,
173 base::FilePath::FromUTF8Unsafe(files[i].name));
174 }
175 }
176
177 void CrosMountPointProvider::GrantFileAccessToExtension(
178 const std::string& extension_id, const base::FilePath& virtual_path) {
179 // All we care about here is access from extensions for now.
180 DCHECK(special_storage_policy_->IsFileHandler(extension_id));
181 if (!special_storage_policy_->IsFileHandler(extension_id))
182 return;
183
184 std::string id;
185 fileapi::FileSystemType type;
186 base::FilePath path;
187 if (!mount_points_->CrackVirtualPath(virtual_path, &id, &type, &path) &&
188 !system_mount_points_->CrackVirtualPath(virtual_path,
189 &id, &type, &path)) {
190 return;
191 }
192
193 if (type == fileapi::kFileSystemTypeRestrictedNativeLocal) {
194 LOG(ERROR) << "Can't grant access for restricted mount point";
195 return;
196 }
197
198 file_access_permissions_->GrantAccessPermission(extension_id, virtual_path);
199 }
200
201 void CrosMountPointProvider::RevokeAccessForExtension(
202 const std::string& extension_id) {
203 file_access_permissions_->RevokePermissions(extension_id);
204 }
205
206 std::vector<base::FilePath> CrosMountPointProvider::GetRootDirectories() const {
207 std::vector<fileapi::MountPoints::MountPointInfo> mount_points;
208 mount_points_->AddMountPointInfosTo(&mount_points);
209 system_mount_points_->AddMountPointInfosTo(&mount_points);
210
211 std::vector<base::FilePath> root_dirs;
212 for (size_t i = 0; i < mount_points.size(); ++i)
213 root_dirs.push_back(mount_points[i].path);
214 return root_dirs;
215 }
216
217 fileapi::FileSystemFileUtil* CrosMountPointProvider::GetFileUtil(
218 fileapi::FileSystemType type) {
219 DCHECK(type == fileapi::kFileSystemTypeNativeLocal ||
220 type == fileapi::kFileSystemTypeRestrictedNativeLocal);
221 return local_file_util_->sync_file_util();
222 }
223
224 fileapi::AsyncFileUtil* CrosMountPointProvider::GetAsyncFileUtil(
225 fileapi::FileSystemType type) {
226 DCHECK(type == fileapi::kFileSystemTypeNativeLocal ||
227 type == fileapi::kFileSystemTypeRestrictedNativeLocal);
228 return local_file_util_.get();
229 }
230
231 fileapi::CopyOrMoveFileValidatorFactory*
232 CrosMountPointProvider::GetCopyOrMoveFileValidatorFactory(
233 fileapi::FileSystemType type, base::PlatformFileError* error_code) {
234 DCHECK(error_code);
235 *error_code = base::PLATFORM_FILE_OK;
236 return NULL;
237 }
238
239 fileapi::FilePermissionPolicy CrosMountPointProvider::GetPermissionPolicy(
240 const fileapi::FileSystemURL& url, int permissions) const {
241 if (url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal &&
242 (permissions & ~fileapi::kReadFilePermissions)) {
243 // Restricted file system is read-only.
244 return fileapi::FILE_PERMISSION_ALWAYS_DENY;
245 }
246
247 if (!IsAccessAllowed(url))
248 return fileapi::FILE_PERMISSION_ALWAYS_DENY;
249
250 // Permit access to mount points from internal WebUI.
251 const GURL& origin_url = url.origin();
252 if (origin_url.SchemeIs(kChromeUIScheme))
253 return fileapi::FILE_PERMISSION_ALWAYS_ALLOW;
254
255 if (url.mount_type() == fileapi::kFileSystemTypeIsolated) {
256 // Permissions in isolated filesystems should be examined with
257 // FileSystem permission.
258 return fileapi::FILE_PERMISSION_USE_FILESYSTEM_PERMISSION;
259 }
260
261 // Also apply system's file permission by default.
262 return fileapi::FILE_PERMISSION_USE_FILE_PERMISSION;
263 }
264
265 fileapi::FileSystemOperation* CrosMountPointProvider::CreateFileSystemOperation(
266 const fileapi::FileSystemURL& url,
267 fileapi::FileSystemContext* context,
268 base::PlatformFileError* error_code) const {
269 DCHECK(url.is_valid());
270
271 if (url.type() == fileapi::kFileSystemTypeDrive) {
272 fileapi::RemoteFileSystemProxyInterface* remote_proxy =
273 GetRemoteProxy(url.filesystem_id());
274 if (!remote_proxy) {
275 *error_code = base::PLATFORM_FILE_ERROR_NOT_FOUND;
276 return NULL;
277 }
278 return new chromeos::RemoteFileSystemOperation(remote_proxy);
279 }
280
281 DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal ||
282 url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal);
283 scoped_ptr<fileapi::FileSystemOperationContext> operation_context(
284 new fileapi::FileSystemOperationContext(context));
285 operation_context->set_root_path(GetFileSystemRootPath(url));
286 return new fileapi::LocalFileSystemOperation(url, context,
287 operation_context.Pass());
288 }
289
290 scoped_ptr<webkit_blob::FileStreamReader>
291 CrosMountPointProvider::CreateFileStreamReader(
292 const fileapi::FileSystemURL& url,
293 int64 offset,
294 const base::Time& expected_modification_time,
295 fileapi::FileSystemContext* context) const {
296 DCHECK(url.is_valid());
297
298 if (url.type() == fileapi::kFileSystemTypeDrive) {
299 fileapi::RemoteFileSystemProxyInterface* remote_proxy =
300 GetRemoteProxy(url.filesystem_id());
301 if (!remote_proxy)
302 return scoped_ptr<webkit_blob::FileStreamReader>();
303 return remote_proxy->CreateFileStreamReader(
304 context->task_runners()->file_task_runner(),
305 url, offset, expected_modification_time);
306 }
307
308 return scoped_ptr<webkit_blob::FileStreamReader>(
309 new fileapi::FileSystemFileStreamReader(
310 context, url, offset, expected_modification_time));
311 }
312
313 scoped_ptr<fileapi::FileStreamWriter>
314 CrosMountPointProvider::CreateFileStreamWriter(
315 const fileapi::FileSystemURL& url,
316 int64 offset,
317 fileapi::FileSystemContext* context) const {
318 DCHECK(url.is_valid());
319
320 if (url.type() == fileapi::kFileSystemTypeDrive) {
321 fileapi::RemoteFileSystemProxyInterface* remote_proxy =
322 GetRemoteProxy(url.filesystem_id());
323 if (!remote_proxy)
324 return scoped_ptr<fileapi::FileStreamWriter>();
325 return scoped_ptr<fileapi::FileStreamWriter>(
326 new fileapi::RemoteFileStreamWriter(
327 remote_proxy, url, offset,
328 context->task_runners()->file_task_runner()));
329 }
330
331 if (url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal)
332 return scoped_ptr<fileapi::FileStreamWriter>();
333
334 DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal);
335 return scoped_ptr<fileapi::FileStreamWriter>(
336 new fileapi::LocalFileStreamWriter(
337 context->task_runners()->file_task_runner(), url.path(), offset));
338 }
339
340 bool CrosMountPointProvider::GetVirtualPath(
341 const base::FilePath& filesystem_path,
342 base::FilePath* virtual_path) {
343 return mount_points_->GetVirtualPath(filesystem_path, virtual_path) ||
344 system_mount_points_->GetVirtualPath(filesystem_path, virtual_path);
345 }
346
347 fileapi::RemoteFileSystemProxyInterface* CrosMountPointProvider::GetRemoteProxy(
348 const std::string& mount_name) const {
349 fileapi::RemoteFileSystemProxyInterface* proxy =
350 mount_points_->GetRemoteFileSystemProxy(mount_name);
351 if (proxy)
352 return proxy;
353 return system_mount_points_->GetRemoteFileSystemProxy(mount_name);
354 }
355
356 base::FilePath CrosMountPointProvider::GetFileSystemRootPath(
357 const fileapi::FileSystemURL& url) const {
358 DCHECK(fileapi::IsolatedContext::IsIsolatedType(url.mount_type()));
359 if (!url.is_valid())
360 return base::FilePath();
361
362 base::FilePath root_path;
363 std::string mount_name = url.filesystem_id();
364 if (!mount_points_->GetRegisteredPath(mount_name, &root_path) &&
365 !system_mount_points_->GetRegisteredPath(mount_name, &root_path)) {
366 return base::FilePath();
367 }
368
369 return root_path.DirName();
370 }
371
372 } // namespace chromeos
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698