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_EXTERNAL_MOUNT_POINTS_H_
      6 #define STORAGE_BROWSER_FILEAPI_EXTERNAL_MOUNT_POINTS_H_
      7 
      8 #include <map>
      9 #include <string>
     10 #include <vector>
     11 
     12 #include "base/memory/ref_counted.h"
     13 #include "base/synchronization/lock.h"
     14 #include "storage/browser/fileapi/mount_points.h"
     15 #include "storage/browser/storage_browser_export.h"
     16 #include "storage/common/fileapi/file_system_mount_option.h"
     17 #include "storage/common/fileapi/file_system_types.h"
     18 
     19 namespace base {
     20 class FilePath;
     21 }
     22 
     23 namespace storage {
     24 
     25 class FileSystemURL;
     26 
     27 // Manages external filesystem namespaces that are identified by 'mount name'
     28 // and are persisted until RevokeFileSystem is called.
     29 // Files in an external filesystem are identified by a filesystem URL like:
     30 //
     31 //   filesystem:<origin>/external/<mount_name>/relative/path
     32 //
     33 class STORAGE_EXPORT ExternalMountPoints
     34     : public base::RefCountedThreadSafe<ExternalMountPoints>,
     35       public MountPoints {
     36  public:
     37   static ExternalMountPoints* GetSystemInstance();
     38   static scoped_refptr<ExternalMountPoints> CreateRefCounted();
     39 
     40   // Registers a new named external filesystem.
     41   // The |path| is registered as the root path of the mount point which
     42   // is identified by a URL "filesystem:.../external/mount_name".
     43   //
     44   // For example, if the path "/media/removable" is registered with
     45   // the mount_name "removable", a filesystem URL like
     46   // "filesystem:.../external/removable/a/b" will be resolved as
     47   // "/media/removable/a/b".
     48   //
     49   // The |mount_name| should NOT contain a path separator '/'.
     50   // Returns false if the given name is already registered.
     51   //
     52   // Overlapping mount points in a single MountPoints instance are not allowed.
     53   // Adding mount point whose path overlaps with an existing mount point will
     54   // fail except for media galleries, which do not count toward registered
     55   // paths for overlap calculation.
     56   //
     57   // If not empty, |path| must be absolute. It is allowed for the path to be
     58   // empty, but |GetVirtualPath| will not work for those mount points.
     59   //
     60   // An external file system registered by this method can be revoked
     61   // by calling RevokeFileSystem with |mount_name|.
     62   bool RegisterFileSystem(const std::string& mount_name,
     63                           FileSystemType type,
     64                           const FileSystemMountOption& mount_option,
     65                           const base::FilePath& path);
     66 
     67   // MountPoints overrides.
     68   virtual bool HandlesFileSystemMountType(FileSystemType type) const OVERRIDE;
     69   virtual bool RevokeFileSystem(const std::string& mount_name) OVERRIDE;
     70   virtual bool GetRegisteredPath(const std::string& mount_name,
     71                                  base::FilePath* path) const OVERRIDE;
     72   virtual bool CrackVirtualPath(
     73       const base::FilePath& virtual_path,
     74       std::string* mount_name,
     75       FileSystemType* type,
     76       std::string* cracked_id,
     77       base::FilePath* path,
     78       FileSystemMountOption* mount_option) const OVERRIDE;
     79   virtual FileSystemURL CrackURL(const GURL& url) const OVERRIDE;
     80   virtual FileSystemURL CreateCrackedFileSystemURL(
     81       const GURL& origin,
     82       FileSystemType type,
     83       const base::FilePath& path) const OVERRIDE;
     84 
     85   // Returns a list of registered MountPointInfos (of <mount_name, path>).
     86   void AddMountPointInfosTo(std::vector<MountPointInfo>* mount_points) const;
     87 
     88   // Converts a path on a registered file system to virtual path relative to the
     89   // file system root. E.g. if 'Downloads' file system is mapped to
     90   // '/usr/local/home/Downloads', and |absolute| path is set to
     91   // '/usr/local/home/Downloads/foo', the method will set |virtual_path| to
     92   // 'Downloads/foo'.
     93   // Returns false if the path cannot be resolved (e.g. if the path is not
     94   // part of any registered filesystem).
     95   //
     96   // Media gallery type file systems do not count for this calculation. i.e.
     97   // if only a media gallery is registered for the path, false will be returned.
     98   // If a media gallery and another file system are registered for related
     99   // paths, only the other registration is taken into account.
    100   //
    101   // Returned virtual_path will have normalized path separators.
    102   bool GetVirtualPath(const base::FilePath& absolute_path,
    103                       base::FilePath* virtual_path) const;
    104 
    105   // Returns the virtual root path that looks like /<mount_name>.
    106   base::FilePath CreateVirtualRootPath(const std::string& mount_name) const;
    107 
    108   FileSystemURL CreateExternalFileSystemURL(
    109       const GURL& origin,
    110       const std::string& mount_name,
    111       const base::FilePath& path) const;
    112 
    113   // Revoke all registered filesystems. Used only by testing (for clean-ups).
    114   void RevokeAllFileSystems();
    115 
    116  private:
    117   friend class base::RefCountedThreadSafe<ExternalMountPoints>;
    118 
    119   // Represents each file system instance (defined in the .cc).
    120   class Instance;
    121 
    122   typedef std::map<std::string, Instance*> NameToInstance;
    123 
    124   // Reverse map from registered path to its corresponding mount name.
    125   typedef std::map<base::FilePath, std::string> PathToName;
    126 
    127   // Use |GetSystemInstance| of |CreateRefCounted| to get an instance.
    128   ExternalMountPoints();
    129   virtual ~ExternalMountPoints();
    130 
    131   // MountPoint overrides.
    132   virtual FileSystemURL CrackFileSystemURL(
    133       const FileSystemURL& url) const OVERRIDE;
    134 
    135   // Performs sanity checks on the new mount point.
    136   // Checks the following:
    137   //  - there is no registered mount point with mount_name
    138   //  - path does not contain a reference to a parent
    139   //  - path is absolute
    140   //  - path does not overlap with an existing mount point path unless it is a
    141   //    media gallery type.
    142   //
    143   // |lock_| should be taken before calling this method.
    144   bool ValidateNewMountPoint(const std::string& mount_name,
    145                              FileSystemType type,
    146                              const base::FilePath& path);
    147 
    148   // This lock needs to be obtained when accessing the instance_map_.
    149   mutable base::Lock lock_;
    150 
    151   NameToInstance instance_map_;
    152   PathToName path_to_name_map_;
    153 
    154   DISALLOW_COPY_AND_ASSIGN(ExternalMountPoints);
    155 };
    156 
    157 }  // namespace storage
    158 
    159 #endif  // STORAGE_BROWSER_FILEAPI_EXTERNAL_MOUNT_POINTS_H_
    160