1 // Copyright 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 WEBKIT_BROWSER_FILEAPI_SANDBOX_CONTEXT_H_ 6 #define WEBKIT_BROWSER_FILEAPI_SANDBOX_CONTEXT_H_ 7 8 #include <set> 9 #include <string> 10 #include <utility> 11 12 #include "base/files/file_path.h" 13 #include "base/memory/ref_counted.h" 14 #include "base/memory/scoped_ptr.h" 15 #include "base/memory/weak_ptr.h" 16 #include "base/time/time.h" 17 #include "webkit/browser/fileapi/file_system_backend.h" 18 #include "webkit/browser/fileapi/file_system_options.h" 19 #include "webkit/browser/fileapi/file_system_quota_util.h" 20 #include "webkit/browser/webkit_storage_browser_export.h" 21 22 namespace base { 23 class SequencedTaskRunner; 24 } 25 26 namespace quota { 27 class QuotaManagerProxy; 28 class SpecialStoragePolicy; 29 } 30 31 namespace fileapi { 32 33 class AsyncFileUtilAdapter; 34 class FileSystemURL; 35 class FileSystemUsageCache; 36 class ObfuscatedFileUtil; 37 class SandboxFileSystemBackend; 38 class SandboxFileSystemTestHelper; 39 class SandboxQuotaObserver; 40 41 // This class keeps and provides a sandbox file system context. 42 // An instance of this class is created and owned by FileSystemContext. 43 class WEBKIT_STORAGE_BROWSER_EXPORT SandboxContext { 44 public: 45 typedef FileSystemBackend::OpenFileSystemCallback OpenFileSystemCallback; 46 47 // The FileSystem directory name. 48 static const base::FilePath::CharType kFileSystemDirectory[]; 49 50 // Origin enumerator interface. 51 // An instance of this interface is assumed to be called on the file thread. 52 class OriginEnumerator { 53 public: 54 virtual ~OriginEnumerator() {} 55 56 // Returns the next origin. Returns empty if there are no more origins. 57 virtual GURL Next() = 0; 58 59 // Returns the current origin's information. 60 virtual bool HasFileSystemType(FileSystemType type) const = 0; 61 }; 62 63 SandboxContext( 64 quota::QuotaManagerProxy* quota_manager_proxy, 65 base::SequencedTaskRunner* file_task_runner, 66 const base::FilePath& profile_path, 67 quota::SpecialStoragePolicy* special_storage_policy, 68 const FileSystemOptions& file_system_options); 69 70 ~SandboxContext(); 71 72 // Performs API-specific validity checks on the given path |url|. 73 // Returns true if access to |url| is valid in this filesystem. 74 bool IsAccessValid(const FileSystemURL& url) const; 75 76 // Returns true if the given |url|'s scheme is allowed to access 77 // filesystem. 78 bool IsAllowedScheme(const GURL& url) const; 79 80 // Returns an origin enumerator of sandbox filesystem. 81 // This method can only be called on the file thread. 82 OriginEnumerator* CreateOriginEnumerator(); 83 84 // Gets a base directory path of the sandboxed filesystem that is 85 // specified by |origin_url| and |type|. 86 // (The path is similar to the origin's root path but doesn't contain 87 // the 'unique' part.) 88 // Returns an empty path if the given type is invalid. 89 // This method can only be called on the file thread. 90 base::FilePath GetBaseDirectoryForOriginAndType( 91 const GURL& origin_url, 92 FileSystemType type, 93 bool create); 94 95 // FileSystemBackend helpers. 96 void OpenFileSystem( 97 const GURL& origin_url, 98 FileSystemType type, 99 OpenFileSystemMode mode, 100 const OpenFileSystemCallback& callback, 101 const GURL& root_url); 102 103 // FileSystemQuotaUtil helpers. 104 base::PlatformFileError DeleteOriginDataOnFileThread( 105 FileSystemContext* context, 106 quota::QuotaManagerProxy* proxy, 107 const GURL& origin_url, 108 FileSystemType type); 109 void GetOriginsForTypeOnFileThread( 110 FileSystemType type, 111 std::set<GURL>* origins); 112 void GetOriginsForHostOnFileThread( 113 FileSystemType type, 114 const std::string& host, 115 std::set<GURL>* origins); 116 int64 GetOriginUsageOnFileThread( 117 FileSystemContext* context, 118 const GURL& origin_url, 119 FileSystemType type); 120 void InvalidateUsageCache( 121 const GURL& origin_url, 122 FileSystemType type); 123 void StickyInvalidateUsageCache( 124 const GURL& origin_url, 125 FileSystemType type); 126 127 void CollectOpenFileSystemMetrics(base::PlatformFileError error_code); 128 129 base::SequencedTaskRunner* file_task_runner() { 130 return file_task_runner_.get(); 131 } 132 133 AsyncFileUtilAdapter* file_util() { return sandbox_file_util_.get(); } 134 FileSystemUsageCache* usage_cache() { return file_system_usage_cache_.get(); } 135 SandboxQuotaObserver* quota_observer() { return quota_observer_.get(); }; 136 137 quota::SpecialStoragePolicy* special_storage_policy() { 138 return special_storage_policy_.get(); 139 } 140 141 FileSystemOptions file_system_options() { return file_system_options_; } 142 143 ObfuscatedFileUtil* sync_file_util(); 144 145 private: 146 friend class SandboxQuotaObserver; 147 friend class SandboxFileSystemTestHelper; 148 149 // Returns a path to the usage cache file. 150 base::FilePath GetUsageCachePathForOriginAndType( 151 const GURL& origin_url, 152 FileSystemType type); 153 154 // Returns a path to the usage cache file (static version). 155 static base::FilePath GetUsageCachePathForOriginAndType( 156 ObfuscatedFileUtil* sandbox_file_util, 157 const GURL& origin_url, 158 FileSystemType type, 159 base::PlatformFileError* error_out); 160 161 int64 RecalculateUsage(FileSystemContext* context, 162 const GURL& origin, 163 FileSystemType type); 164 165 scoped_refptr<base::SequencedTaskRunner> file_task_runner_; 166 167 scoped_ptr<AsyncFileUtilAdapter> sandbox_file_util_; 168 scoped_ptr<FileSystemUsageCache> file_system_usage_cache_; 169 scoped_ptr<SandboxQuotaObserver> quota_observer_; 170 171 scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_; 172 173 FileSystemOptions file_system_options_; 174 175 // Acccessed only on the file thread. 176 std::set<GURL> visited_origins_; 177 178 std::set<std::pair<GURL, FileSystemType> > sticky_dirty_origins_; 179 180 base::Time next_release_time_for_open_filesystem_stat_; 181 182 base::WeakPtrFactory<SandboxContext> weak_factory_; 183 184 DISALLOW_COPY_AND_ASSIGN(SandboxContext); 185 }; 186 187 } // namespace fileapi 188 189 #endif // WEBKIT_BROWSER_FILEAPI_SANDBOX_CONTEXT_H_ 190