Add oem mount point to cros_mount_provider.

webkit/chromeos/fileapi/cros_mount_point_provider.cc

 // 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.
 
 #include "webkit/chromeos/fileapi/cros_mount_point_provider.h"
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 24 matching lines @@
 
 }  // namespace
 
 namespace chromeos {
 
 // static
 bool CrosMountPointProvider::CanHandleURL(const fileapi::FileSystemURL& url) {
   if (!url.is_valid())
     return false;
   return url.type() == fileapi::kFileSystemTypeNativeLocal ||
+         url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal ||
          url.type() == fileapi::kFileSystemTypeDrive;
 }
 
 CrosMountPointProvider::CrosMountPointProvider(
     scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy)
     : special_storage_policy_(special_storage_policy),
       file_access_permissions_(new FileAccessPermissions()),
       local_file_util_(new fileapi::IsolatedFileUtil()) {
   FilePath home_path;
   if (PathService::Get(base::DIR_HOME, &home_path))
     AddLocalMountPoint(home_path.AppendASCII("Downloads"));
   AddLocalMountPoint(FilePath(FILE_PATH_LITERAL("/media/archive")));
   AddLocalMountPoint(FilePath(FILE_PATH_LITERAL("/media/removable")));
+  AddRestrictedLocalMountPoint(FilePath(FILE_PATH_LITERAL("/usr/share/oem")));
 }
 
 CrosMountPointProvider::~CrosMountPointProvider() {
 }
 
 void CrosMountPointProvider::ValidateFileSystemRoot(
     const GURL& origin_url,
     fileapi::FileSystemType type,
     bool create,
     const ValidateFileSystemCallback& callback) {
@@ skipping 72 matching lines @@
   std::string mount_name = mount_point.BaseName().AsUTF8Unsafe();
   isolated_context()->RevokeFileSystem(mount_name);
   isolated_context()->RegisterExternalFileSystem(
       mount_name,
       fileapi::kFileSystemTypeNativeLocal,
       mount_point);
   base::AutoLock locker(mount_point_map_lock_);
   local_to_virtual_map_[mount_point] = mount_point.BaseName();
 }
 
+void CrosMountPointProvider::AddRestrictedLocalMountPoint(
+    const FilePath& mount_point) {
+  std::string mount_name = mount_point.BaseName().AsUTF8Unsafe();
+  isolated_context()->RevokeFileSystem(mount_name);
+  isolated_context()->RegisterExternalFileSystem(
+      mount_name,
+      fileapi::kFileSystemTypeRestrictedNativeLocal,
+      mount_point);
+  base::AutoLock locker(mount_point_map_lock_);
+  local_to_virtual_map_[mount_point] = mount_point.BaseName();
+}
+
 void CrosMountPointProvider::AddRemoteMountPoint(
     const FilePath& mount_point,
     fileapi::RemoteFileSystemProxyInterface* remote_proxy) {
   DCHECK(remote_proxy);
   std::string mount_name = mount_point.BaseName().AsUTF8Unsafe();
   isolated_context()->RevokeFileSystem(mount_name);
   isolated_context()->RegisterExternalFileSystem(mount_name,
                                                  fileapi::kFileSystemTypeDrive,
                                                  mount_point);
   base::AutoLock locker(mount_point_map_lock_);
@@ skipping 10 matching lines @@
 }
 
 void CrosMountPointProvider::GrantFullAccessToExtension(
     const std::string& extension_id) {
   DCHECK(special_storage_policy_->IsFileHandler(extension_id));
   if (!special_storage_policy_->IsFileHandler(extension_id))
     return;
   std::vector<fileapi::IsolatedContext::FileInfo> files =
       isolated_context()->GetExternalMountPoints();
   for (size_t i = 0; i < files.size(); ++i) {
-    GrantFileAccessToExtension(extension_id,
-                               FilePath::FromUTF8Unsafe(files[i].name));
+    file_access_permissions_->GrantAccessPermission(

[kinuko, 2012/10/03 02:38:04]

Do we also need to avoid calling this for the mount points whose type is
RestrictedNativeLocal?

[tbarzic, 2012/10/03 02:47:32]

no, if we don't call this here we won't be able to access the mount point from
file browser extension (which we need).

And it makes sense to give access to restricted mount point here, since we are
giving full access to the extension (this is done only for file browser
extension). The non-read operations will still be disabled.

+        extension_id,
+        FilePath::FromUTF8Unsafe(files[i].name));
   }
 }
 
 void CrosMountPointProvider::GrantFileAccessToExtension(
     const std::string& extension_id, const FilePath& virtual_path) {
   // All we care about here is access from extensions for now.
   DCHECK(special_storage_policy_->IsFileHandler(extension_id));
   if (!special_storage_policy_->IsFileHandler(extension_id))
     return;
+
+  std::string id;
+  fileapi::FileSystemType type;
+  FilePath path;
+  isolated_context()->CrackIsolatedPath(virtual_path, &id, &type, &path);
+
+  if (type == fileapi::kFileSystemTypeRestrictedNativeLocal) {
+    LOG(ERROR) << "Can't grant access for restricted mount point";
+    return;
+  }
+
   file_access_permissions_->GrantAccessPermission(extension_id, virtual_path);
 }
 
 void CrosMountPointProvider::RevokeAccessForExtension(
       const std::string& extension_id) {
   file_access_permissions_->RevokePermissions(extension_id);
 }
 
 std::vector<FilePath> CrosMountPointProvider::GetRootDirectories() const {
   std::vector<fileapi::IsolatedContext::FileInfo> files =
       isolated_context()->GetExternalMountPoints();
   std::vector<FilePath> root_dirs;
   for (size_t i = 0; i < files.size(); ++i)
     root_dirs.push_back(files[i].path);
   return root_dirs;
 }
 
 fileapi::FileSystemFileUtil* CrosMountPointProvider::GetFileUtil(
     fileapi::FileSystemType type) {
-  DCHECK(type == fileapi::kFileSystemTypeNativeLocal);
+  DCHECK(type == fileapi::kFileSystemTypeNativeLocal ||
+         type == fileapi::kFileSystemTypeRestrictedNativeLocal);
   return local_file_util_.get();
 }
 
 FilePath CrosMountPointProvider::GetPathForPermissionsCheck(
     const FilePath& virtual_path) const {
   return virtual_path;
 }
 
 fileapi::FileSystemOperation* CrosMountPointProvider::CreateFileSystemOperation(
     const fileapi::FileSystemURL& url,
     fileapi::FileSystemContext* context,
     base::PlatformFileError* error_code) const {
   if (url.type() == fileapi::kFileSystemTypeDrive) {
     base::AutoLock locker(mount_point_map_lock_);
     RemoteProxyMap::const_iterator found = remote_proxy_map_.find(
         url.filesystem_id());
     if (found != remote_proxy_map_.end()) {
       return new chromeos::RemoteFileSystemOperation(found->second);
     } else {
       *error_code = base::PLATFORM_FILE_ERROR_NOT_FOUND;
       return NULL;
     }
   }
 
-  DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal);
+  DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal ||
+         url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal);
   scoped_ptr<fileapi::FileSystemOperationContext> operation_context(
       new fileapi::FileSystemOperationContext(context));
   return new fileapi::LocalFileSystemOperation(context,
                                                operation_context.Pass());
 }
 
 webkit_blob::FileStreamReader* CrosMountPointProvider::CreateFileStreamReader(
     const fileapi::FileSystemURL& url,
     int64 offset,
     fileapi::FileSystemContext* context) const {
@@ skipping 11 matching lines @@
     return NULL;
   if (url.type() == fileapi::kFileSystemTypeDrive) {
     base::AutoLock locker(mount_point_map_lock_);
     RemoteProxyMap::const_iterator found = remote_proxy_map_.find(
         url.filesystem_id());
     if (found == remote_proxy_map_.end())
       return NULL;
     return new fileapi::RemoteFileStreamWriter(found->second, url, offset);
   }
 
+  if (url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal)
+    return NULL;
+
   DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal);
   return new fileapi::LocalFileStreamWriter(url.path(), offset);
 }
 
 bool CrosMountPointProvider::GetVirtualPath(const FilePath& filesystem_path,
                                            FilePath* virtual_path) {
   base::AutoLock locker(mount_point_map_lock_);
   std::map<FilePath, FilePath>::reverse_iterator iter(
       local_to_virtual_map_.upper_bound(filesystem_path));
   if (iter == local_to_virtual_map_.rend())
     return false;
   if (iter->first == filesystem_path) {
     *virtual_path = iter->second;
     return true;
   }
   return iter->first.DirName().AppendRelativePath(
       filesystem_path, virtual_path);
 }
 
 fileapi::IsolatedContext* CrosMountPointProvider::isolated_context() const {
   return fileapi::IsolatedContext::GetInstance();
 }
 
 }  // namespace chromeos