Deprecate MountPointProvider::IsAccessAllowed in favor of GetPermissionPolicy

webkit/fileapi/file_system_mount_point_provider.h

 // 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 WEBKIT_FILEAPI_FILE_SYSTEM_MOUNT_POINT_PROVIDER_H_
 #define WEBKIT_FILEAPI_FILE_SYSTEM_MOUNT_POINT_PROVIDER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 42 matching lines @@
       const ValidateFileSystemCallback& callback) = 0;
 
   // Retrieves the root path of the filesystem specified by the given
   // file system url on the file thread.
   // If |create| is true this may also create the root directory for
   // the filesystem if it doesn't exist.
   virtual base::FilePath GetFileSystemRootPathOnFileThread(
       const FileSystemURL& url,
       bool create) = 0;
 
-  // Checks if access to |virtual_path| is allowed from |origin_url|.
-  virtual bool IsAccessAllowed(const FileSystemURL& url) = 0;
-
-  // Checks if a given |name| contains any restricted names/chars in it.
-  // Callable on any thread.
-  virtual bool IsRestrictedFileName(const base::FilePath& filename) const = 0;
-
   // Returns the specialized FileSystemFileUtil for this mount point.
   // It is ok to return NULL if the filesystem doesn't support synchronous
   // version of FileUtil.
   virtual FileSystemFileUtil* GetFileUtil(FileSystemType type) = 0;
 
   // Returns the specialized AsyncFileUtil for this mount point.
   virtual AsyncFileUtil* GetAsyncFileUtil(FileSystemType type) = 0;
 
   // Returns file permission policy we should apply for the given |url|.
   virtual FilePermissionPolicy GetPermissionPolicy(
@@ skipping 45 matching lines @@
       const GURL& origin_url,
       FileSystemType type,
       FileSystemContext* context,
       const DeleteFileSystemCallback& callback) = 0;
 };
 
 // An interface to control external file system access permissions.
 class ExternalFileSystemMountPointProvider
     : public FileSystemMountPointProvider {
  public:
+  // Returns true if |url| is allowed to be accessed.
+  virtual bool IsAccessAllowed(const fileapi::FileSystemURL& url) const = 0;

[ericu, 2013/02/13 01:45:56]

Given the other methods, please add a comment explaining how this one differs. 
"is allowed" by whom, and if this should override other checks or if it's an
additional requirement.

If this will only ever be used by implementers of this interface, we could also
make it protected to clarify that.

[kinuko, 2013/02/13 03:36:30]

Done.

   // Returns the list of top level directories that are exposed by this
   // provider. This list is used to set appropriate child process file access
   // permissions.
   virtual std::vector<base::FilePath> GetRootDirectories() const = 0;
   // Grants access to all external file system from extension identified with
   // |extension_id|.
   virtual void GrantFullAccessToExtension(const std::string& extension_id) = 0;
   // Grants access to |virtual_path| from |origin_url|.
   virtual void GrantFileAccessToExtension(
       const std::string& extension_id,
       const base::FilePath& virtual_path) = 0;
   // Revokes file access from extension identified with |extension_id|.
   virtual void RevokeAccessForExtension(
         const std::string& extension_id) = 0;
   // Gets virtual path by known filesystem path. Returns false when filesystem
   // path is not exposed by this provider.
   virtual bool GetVirtualPath(const base::FilePath& file_system_path,
                               base::FilePath* virtual_path) = 0;
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_FILE_SYSTEM_MOUNT_POINT_PROVIDER_H_