Stop returning the true root path of each filesystem from openFileSystem....

webkit/fileapi/file_system_path_manager.h

 // Copyright (c) 2010 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_PATH_MANAGER_H_
 #define WEBKIT_FILEAPI_FILE_SYSTEM_PATH_MANAGER_H_
 #pragma once
 
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "webkit/fileapi/file_system_types.h"
 
 class GURL;
 
 namespace base {
 class MessageLoopProxy;
 }
 
 namespace fileapi {
 
+class SandboxMountPointProvider;
+
 // TODO(kinuko): Probably this module must be called FileSystemPathUtil
 // or something similar.
 
 // An interface to construct or crack sandboxed filesystem paths.
 // Currently each sandboxed filesystem path looks like:
 //
 //   <profile_dir>/FileSystem/<origin_identifier>/<type>/chrome-<unique>/...
 //
 // <type> is either one of "Temporary" or "Persistent".
 class FileSystemPathManager {
@@ skipping 10 matching lines @@
   // If the request is accepted, |create| is specified for
   // GetFileSystemRootPath, and the root directory does not exist, it creates
   // a new one and calls back with success=true if the creation has succeeded.
   typedef Callback3<bool /* success */,
                     const FilePath& /* root_path */,
                     const std::string& /* name */>::Type GetRootPathCallback;
 
   // Retrieves the root path for the given |origin_url| and |type|, and
   // calls the given |callback| with the root path and name.
   // If |create| is true this also creates the directory if it doesn't exist.
-  void GetFileSystemRootPath(const GURL& origin_url,
-                             fileapi::FileSystemType type,
+  virtual void GetFileSystemRootPath(const GURL& origin_url,
+                             FileSystemType type,
                              bool create,
-                             GetRootPathCallback* callback);
+                             FileSystemPathManager::GetRootPathCallback*
+                                 callback);
 
+  // Like GetFileSystemRootPath, but synchronous, and can be called only while
+  // running on the file thread.
+  virtual FilePath GetFileSystemRootPathOnFileThread(const GURL& origin_url,
+                                                     FileSystemType type,
+                                                     bool create);
   // Cracks the given |path|, retrieves the information embedded in the path
   // and populates |origin_url|, |type| and |virtual_path|.  The |virtual_path|
   // is a sandboxed path in the file system, i.e. the relative path to the
   // filesystem root for the given domain and type.
   bool CrackFileSystemPath(const FilePath& path,
                            GURL* origin_url,
                            FileSystemType* type,
                            FilePath* virtual_path) const;
 
   // Returns true if the given |url|'s scheme is allowed to access
   // filesystem.
   bool IsAllowedScheme(const GURL& url) const;
 
-  // The FileSystem directory name.
-  static const FilePath::CharType kFileSystemDirectory[];
-
-  static const char kPersistentName[];
-  static const char kTemporaryName[];
-
-  const FilePath& base_path() const {
-    return base_path_;
-  }
-
-  // Checks if a given |name| contains any restricted names/chars in it.
-  static bool IsRestrictedFileName(const FilePath& filename);
-
   // Returns the string for the given |type|.
   // Returns an empty string if the |type| is invalid.
   static std::string GetFileSystemTypeString(fileapi::FileSystemType type);
 
-  // Returns the origin identifier string, which is used as a part of the
-  // sandboxed path component, for the given |url|.
-  static std::string GetOriginIdentifierFromURL(const GURL& url);
+  // Checks if a given |name| contains any restricted names/chars in it.
+  bool IsRestrictedFileName(FileSystemType type,
+                            const FilePath& filename);
 
-  // Gets a base directory path of the sandboxed filesystem that is
-  // specified by |origin_identifier| and |type|.
-  // |base_path| must be pointing the FileSystem's data directory
-  // under the profile directory, i.e. <profile_dir>/kFileSystemDirectory.
-  // Returns an empty path if any of the given parameters are invalid.
-  // Returned directory path does not contain 'unique' part, therefore
-  // it is not an actural root path for the filesystem.
-  static FilePath GetFileSystemBaseDirectoryForOriginAndType(
-      const FilePath& base_path,
-      const std::string& origin_identifier,
-      fileapi::FileSystemType type);
+  SandboxMountPointProvider* sandbox_provider() const {
+    return sandbox_provider_.get();
+  }
 
-  // Enumerates origins under the given |base_path|.
-  // This must be used on the FILE thread.
-  class OriginEnumerator {
-   public:
-    OriginEnumerator(const FilePath& base_path);
-
-    // Returns the next origin identifier.  Returns empty if there are no
-    // more origins.
-    std::string Next();
-
-    bool HasTemporary();
-    bool HasPersistent();
-    const FilePath& path() { return current_; }
-
-    private:
-    file_util::FileEnumerator enumerator_;
-    FilePath current_;
-  };
+  bool is_incognito() const {
+    return is_incognito_;
+  }
 
  private:
-  class GetFileSystemRootPathTask;
-
-  scoped_refptr<base::MessageLoopProxy> file_message_loop_;
-
-  const FilePath base_path_;
   const bool is_incognito_;
   const bool allow_file_access_from_files_;
+  scoped_ptr<SandboxMountPointProvider> sandbox_provider_;

[kinuko, 2011/03/14 11:03:57]

Is it supposed to be a pointer to FSMountPointProvider or SandBoxMountProvider? 
The path manager dispatches most of its methods to this instance, and all of
those methods called by the path manager are defined in FSMountPointProvider as
virtual.

[ericu, 2011/03/15 02:43:11]

Currently it's important that this be a SandboxMountPointProvider so that in
worker_process_host.cc we can grab its base_path to grant sandbox exceptions for
its access.  That's sandbox-only code.  I could push the base_path accessor up
to FSMPP, but I'm not sure whether or not it really belongs there, as it's sort
of a sandbox concept [the FileSystem directory, above temporary or persistent]. 
What do you think?

[kinuko, 2011/03/16 19:33:38]

It's a bit blur how we should separate the roles between the two, but for now
having sandbox_provider as SandboxMountProvider and base_path only in SandboxMPP
lgtm.

 
   DISALLOW_COPY_AND_ASSIGN(FileSystemPathManager);
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_FILE_SYSTEM_PATH_MANAGER_H_