Home | History | Annotate | Download | only in fileapi 
      1 // Copyright (c) 2013 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 #ifndef STORAGE_BROWSER_FILEAPI_MOUNT_POINTS_H_
      6 #define STORAGE_BROWSER_FILEAPI_MOUNT_POINTS_H_
      7 
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/basictypes.h"
     12 #include "base/files/file_path.h"
     13 #include "storage/browser/storage_browser_export.h"
     14 #include "storage/common/fileapi/file_system_util.h"
     15 
     16 class GURL;
     17 
     18 namespace storage {
     19 class FileSystemMountOption;
     20 class FileSystemURL;
     21 }
     22 
     23 namespace storage {
     24 
     25 // Represents a set of mount points for File API.
     26 class STORAGE_EXPORT MountPoints {
     27  public:
     28   struct STORAGE_EXPORT MountPointInfo {
     29     MountPointInfo();
     30     MountPointInfo(const std::string& name, const base::FilePath& path);
     31 
     32     // The name to be used to register the path. The registered file can
     33     // be referred by a virtual path /<filesystem_id>/<name>.
     34     // The name should NOT contain a path separator '/'.
     35     std::string name;
     36 
     37     // The path of the file.
     38     base::FilePath path;
     39 
     40     // For STL operation.
     41     bool operator<(const MountPointInfo& that) const {
     42       return name < that.name;
     43     }
     44   };
     45 
     46   MountPoints() {}
     47   virtual ~MountPoints() {}
     48 
     49   // Revokes a mount point identified by |mount_name|.
     50   // Returns false if the |mount_name| is not (no longer) registered.
     51   // TODO(kinuko): Probably this should be rather named RevokeMountPoint.
     52   virtual bool RevokeFileSystem(const std::string& mount_name) = 0;
     53 
     54   // Returns true if the MountPoints implementation handles filesystems with
     55   // the given mount type.
     56   virtual bool HandlesFileSystemMountType(FileSystemType type) const = 0;
     57 
     58   // Same as CreateCrackedFileSystemURL, but cracks FileSystemURL created
     59   // from |url|.
     60   virtual FileSystemURL CrackURL(const GURL& url) const = 0;
     61 
     62   // Creates a FileSystemURL with the given origin, type and path and tries to
     63   // crack it as a part of one of the registered mount points.
     64   // If the the URL is not valid or does not belong to any of the mount points
     65   // registered in this context, returns empty, invalid FileSystemURL.
     66   virtual FileSystemURL CreateCrackedFileSystemURL(
     67       const GURL& origin,
     68       storage::FileSystemType type,
     69       const base::FilePath& path) const = 0;
     70 
     71   // Returns the mount point root path registered for a given |mount_name|.
     72   // Returns false if the given |mount_name| is not valid.
     73   virtual bool GetRegisteredPath(const std::string& mount_name,
     74                                  base::FilePath* path) const = 0;
     75 
     76   // Cracks the given |virtual_path| (which is the path part of a filesystem URL
     77   // without '/external' or '/isolated' prefix part) and populates the
     78   // |mount_name|, |type|, and |path| if the <mount_name> part embedded in
     79   // the |virtual_path| (i.e. the first component of the |virtual_path|) is a
     80   // valid registered filesystem ID or mount name for an existing mount point.
     81   //
     82   // Returns false if the given virtual_path cannot be cracked.
     83   //
     84   // Note that |path| is set to empty paths if the filesystem type is isolated
     85   // and |virtual_path| has no <relative_path> part (i.e. pointing to the
     86   // virtual root).
     87   virtual bool CrackVirtualPath(const base::FilePath& virtual_path,
     88                                 std::string* mount_name,
     89                                 FileSystemType* type,
     90                                 std::string* cracked_id,
     91                                 base::FilePath* path,
     92                                 FileSystemMountOption* mount_option) const = 0;
     93 
     94  protected:
     95   friend class FileSystemContext;
     96 
     97   // Same as CrackURL and CreateCrackedFileSystemURL, but cracks the url already
     98   // instantiated as the FileSystemURL class. This is internally used for nested
     99   // URL cracking in FileSystemContext.
    100   virtual FileSystemURL CrackFileSystemURL(const FileSystemURL& url) const = 0;
    101 
    102  private:
    103   DISALLOW_COPY_AND_ASSIGN(MountPoints);
    104 };
    105 
    106 }  // namespace storage
    107 
    108 #endif  // STORAGE_BROWSER_FILEAPI_MOUNT_POINTS_H_
    109