Integrate external mount points to IsolatedContext

webkit/chromeos/fileapi/cros_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_CHROMEOS_FILEAPI_CROS_MOUNT_POINT_PROVIDER_H_
 #define WEBKIT_CHROMEOS_FILEAPI_CROS_MOUNT_POINT_PROVIDER_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
-#include "webkit/fileapi/local_file_util.h"
+#include "webkit/fileapi/fileapi_export.h"
 #include "webkit/quota/special_storage_policy.h"
 
 namespace fileapi {
 class FileSystemFileUtil;
+class IsolatedContext;
+class LocalFileUtil;
 }
 
 namespace chromeos {
 
 class FileAccessPermissions;
 
 // An interface to provide local filesystem paths.
-class CrosMountPointProvider
+class FILEAPI_EXPORT CrosMountPointProvider
     : public fileapi::ExternalFileSystemMountPointProvider {
  public:
   using fileapi::FileSystemMountPointProvider::ValidateFileSystemCallback;
   using fileapi::FileSystemMountPointProvider::DeleteFileSystemCallback;
 
-  // Mount point file system location enum.
-  enum FileSystemLocation {
-    // File system that is locally mounted by the underlying OS.
-    LOCAL,
-    // File system that is remotely hosted on the net.
-    REMOTE,
-  };
-
   CrosMountPointProvider(
       scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy);
   virtual ~CrosMountPointProvider();
 
+  // Returns true if CrosMountpointProvider can handle |url|, i.e. its
+  // file system type matches with what this provider supports.
+  // This could be called on any threads.
+  static bool CanHandleURL(const fileapi::FileSystemURL& url);
+
   // fileapi::FileSystemMountPointProvider overrides.
   virtual void ValidateFileSystemRoot(
       const GURL& origin_url,
       fileapi::FileSystemType type,
       bool create,
       const ValidateFileSystemCallback& callback) OVERRIDE;
   virtual FilePath GetFileSystemRootPathOnFileThread(
       const GURL& origin_url,
       fileapi::FileSystemType type,
       const FilePath& virtual_path,
@@ skipping 36 matching lines @@
   virtual bool HasMountPoint(const FilePath& mount_point) OVERRIDE;
   virtual void AddLocalMountPoint(const FilePath& mount_point) OVERRIDE;
   virtual void AddRemoteMountPoint(
       const FilePath& mount_point,
       fileapi::RemoteFileSystemProxyInterface* remote_proxy) OVERRIDE;
   virtual void RemoveMountPoint(const FilePath& mount_point) OVERRIDE;
   virtual bool GetVirtualPath(const FilePath& filesystem_path,
                               FilePath* virtual_path) OVERRIDE;
 
  private:
-  // Representation of a mount point exposed by this external mount point
-  // provider.
-  struct MountPoint {
-    MountPoint(const FilePath& web_path,
-               const FilePath& local_path,
-               FileSystemLocation loc,
-               fileapi::RemoteFileSystemProxyInterface* proxy);
-    virtual ~MountPoint();
-    // Virtual web path, relative to external root in filesystem URLs.
-    // For example, in "filesystem://.../external/foo/bar/" this path would
-    // map to "foo/bar/".
-    const FilePath web_root_path;
-    // Parent directory for the exposed file system path. For example,
-    // mount point that exposes "/media/removable" would have this
-    // root path as "/media".
-    const FilePath local_root_path;
-    // File system location.
-    const FileSystemLocation location;
-    // Remote file system proxy for remote mount points.
-    scoped_refptr<fileapi::RemoteFileSystemProxyInterface> remote_proxy;
-  };
+  typedef scoped_refptr<fileapi::RemoteFileSystemProxyInterface> RemoteProxy;
+  typedef std::map<FilePath::StringType, RemoteProxy> RemoteProxyMap;
 
-  typedef std::map<std::string, MountPoint> MountPointMap;
+  fileapi::IsolatedContext* isolated_context() const;
 
-  // Gives the real file system's |root_path| for given |virtual_path|. Returns
-  // false when |virtual_path| cannot be mapped to the real file system.
-  bool GetRootForVirtualPath(const FilePath& virtual_path, FilePath* root_path);
-  // Returns mount point info for a given |virtual_path|, NULL if the path is
-  // not part of the mounted file systems exposed through this provider.
-  const MountPoint* GetMountPoint(const FilePath& virtual_path) const;
+  // Represents a map from mount point name to a remote proxy.
+  RemoteProxyMap remote_proxy_map_;
 
-  base::Lock mount_point_map_lock_;
-  MountPointMap mount_point_map_;
+  // Reverse map for GetVirtualPath.
+  std::map<FilePath, FilePath> local_to_virtual_map_;
+
+  mutable base::Lock mount_point_map_lock_;
+
   scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
   scoped_ptr<FileAccessPermissions> file_access_permissions_;
   scoped_ptr<fileapi::LocalFileUtil> local_file_util_;
   DISALLOW_COPY_AND_ASSIGN(CrosMountPointProvider);
 };
 
 }  // namespace chromeos
 
 #endif  // WEBKIT_CHROMEOS_FILEAPI_CROS_MOUNT_POINT_PROVIDER_H_