FileAPI: Move FileSystemQuotaUtil related functions into SandboxContext

webkit/browser/fileapi/sandbox_context.h

Index: webkit/browser/fileapi/sandbox_context.h
diff --git a/webkit/browser/fileapi/sandbox_context.h b/webkit/browser/fileapi/sandbox_context.h
index 67bd0f8a6a84580fb0f90745503af2b7b2bebaca..4ff764814c98a92589aadb372f79c22869378a45 100644
--- a/webkit/browser/fileapi/sandbox_context.h
+++ b/webkit/browser/fileapi/sandbox_context.h
@@ -5,10 +5,16 @@
 #ifndef WEBKIT_BROWSER_FILEAPI_SANDBOX_CONTEXT_H_
 #define WEBKIT_BROWSER_FILEAPI_SANDBOX_CONTEXT_H_
 
+#include <set>
+#include <string>
+#include <utility>
+
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "webkit/browser/fileapi/file_system_backend.h"
+#include "webkit/browser/fileapi/file_system_options.h"
 #include "webkit/browser/fileapi/file_system_quota_util.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
 
@@ -24,6 +30,7 @@ class SpecialStoragePolicy;
 namespace fileapi {
 
 class AsyncFileUtilAdapter;
+class FileSystemURL;
 class FileSystemUsageCache;
 class ObfuscatedFileUtil;
 class SandboxFileSystemBackend;
@@ -37,14 +44,75 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxContext {
   // The FileSystem directory name.
   static const base::FilePath::CharType kFileSystemDirectory[];
 
+  // Origin enumerator interface.
+  // An instance of this interface is assumed to be called on the file thread.
+  class OriginEnumerator {
+   public:
+    virtual ~OriginEnumerator() {}
+
+    // Returns the next origin.  Returns empty if there are no more origins.
+    virtual GURL Next() = 0;
+
+    // Returns the current origin's information.
+    virtual bool HasFileSystemType(FileSystemType type) const = 0;
+  };
+
   SandboxContext(
       quota::QuotaManagerProxy* quota_manager_proxy,
       base::SequencedTaskRunner* file_task_runner,
       const base::FilePath& profile_path,
-      quota::SpecialStoragePolicy* special_storage_policy);
+      quota::SpecialStoragePolicy* special_storage_policy,
+      const FileSystemOptions& file_system_options);
 
   ~SandboxContext();
 
+  // Performs API-specific validity checks on the given path |url|.
+  // Returns true if access to |url| is valid in this filesystem.
+  bool IsAccessValid(const FileSystemURL& url) const;
+
+  // Returns true if the given |url|'s scheme is allowed to access
+  // filesystem.
+  bool IsAllowedScheme(const GURL& url) const;
+
+  // Returns an origin enumerator of sandbox filesystem.
+  // This method can only be called on the file thread.
+  OriginEnumerator* CreateOriginEnumerator();
+
+  // Gets a base directory path of the sandboxed filesystem that is
+  // specified by |origin_url| and |type|.
+  // (The path is similar to the origin's root path but doesn't contain
+  // the 'unique' part.)
+  // Returns an empty path if the given type is invalid.
+  // This method can only be called on the file thread.
+  base::FilePath GetBaseDirectoryForOriginAndType(
+      const GURL& origin_url,
+      FileSystemType type,
+      bool create);
+
+  // FileSystemQuotaUtil implementations.

[kinuko, 2013/07/30 08:22:20]

nit: this sounds like it's implementing QuotaUtil methods. 'FileSystemQuotaUtil
helpers' ?

[nhiroki, 2013/07/30 11:56:44]

Done.

+  base::PlatformFileError DeleteOriginDataOnFileThreadImpl(
+      FileSystemContext* context,
+      quota::QuotaManagerProxy* proxy,
+      const GURL& origin_url,
+      FileSystemType type);
+  void GetOriginsForTypeOnFileThreadImpl(
+      FileSystemType type,
+      std::set<GURL>* origins);
+  void GetOriginsForHostOnFileThreadImpl(
+      FileSystemType type,
+      const std::string& host,
+      std::set<GURL>* origins);
+  int64 GetOriginUsageOnFileThreadImpl(
+      FileSystemContext* context,
+      const GURL& origin_url,
+      FileSystemType type);
+  void InvalidateUsageCacheImpl(
+      const GURL& origin_url,
+      FileSystemType type);
+  void StickyInvalidateUsageCacheImpl(
+      const GURL& origin_url,
+      FileSystemType type);
+
   base::SequencedTaskRunner* file_task_runner() {
     return file_task_runner_.get();
   }
@@ -57,11 +125,35 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxContext {
     return special_storage_policy_.get();
   }
 
+  void set_file_system_options(const FileSystemOptions& file_system_options) {
+    file_system_options_ = file_system_options;
+  }
+  FileSystemOptions file_system_options() { return file_system_options_; }
+
   ObfuscatedFileUtil* sync_file_util();

[kinuko, 2013/07/30 08:22:20]

nit: do we need both file_util() and sync_file_util() separately?

[nhiroki, 2013/07/30 11:56:44]

Well... if we remove...

a) sync_file_util(), we probably would like another helper function like
sync_file_util() in both SandboxContext and SandboxFSBackend to avoid annoying
static_cast<ObfuscatedFileUtil*>().

b) file_util(), the backend has no way to get a pointer of AsyncFileUtil in
SandboxFSBackend::GetAsyncFileUtil(). 

So, I'd prefer to leave both functions. WDYT?

[kinuko, 2013/07/31 06:12:34]

Ok, let's keep them.

 
   bool is_usage_tracking_enabled() { return is_usage_tracking_enabled_; }
 
  private:
+  friend class SandboxQuotaObserver;
+  friend class SandboxFileSystemTestHelper;
+
+  // Returns a path to the usage cache file.
+  base::FilePath GetUsageCachePathForOriginAndType(
+      const GURL& origin_url,
+      FileSystemType type);
+
+  // Returns a path to the usage cache file (static version).
+  static base::FilePath GetUsageCachePathForOriginAndType(
+      ObfuscatedFileUtil* sandbox_file_util,
+      const GURL& origin_url,
+      FileSystemType type,
+      base::PlatformFileError* error_out);
+
+  int64 RecalculateUsage(FileSystemContext* context,
+                         const GURL& origin,
+                         FileSystemType type);
+
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
 
   scoped_ptr<AsyncFileUtilAdapter> sandbox_file_util_;
@@ -70,11 +162,18 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxContext {
 
   scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
 
+  FileSystemOptions file_system_options_;
+
   // Indicates if the usage tracking for FileSystem is enabled or not.
   // The usage tracking is enabled by default and can be disabled by
   // a command-line switch (--disable-file-system-usage-tracking).
   bool is_usage_tracking_enabled_;
 
+  // Acccessed only on the file thread.
+  std::set<GURL> visited_origins_;
+
+  std::set<std::pair<GURL, FileSystemType> > sticky_dirty_origins_;
+
   DISALLOW_COPY_AND_ASSIGN(SandboxContext);
 };