Home | History | Annotate | Download | only in fileapi 
      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 STORAGE_BROWSER_FILEAPI_SANDBOX_FILE_SYSTEM_BACKEND_DELEGATE_H_
      6 #define STORAGE_BROWSER_FILEAPI_SANDBOX_FILE_SYSTEM_BACKEND_DELEGATE_H_
      7 
      8 #include <map>
      9 #include <set>
     10 #include <string>
     11 #include <utility>
     12 
     13 #include "base/files/file_path.h"
     14 #include "base/gtest_prod_util.h"
     15 #include "base/memory/ref_counted.h"
     16 #include "base/memory/scoped_ptr.h"
     17 #include "base/memory/weak_ptr.h"
     18 #include "base/threading/thread_checker.h"
     19 #include "base/time/time.h"
     20 #include "storage/browser/fileapi/file_system_backend.h"
     21 #include "storage/browser/fileapi/file_system_options.h"
     22 #include "storage/browser/fileapi/file_system_quota_util.h"
     23 #include "storage/browser/fileapi/task_runner_bound_observer_list.h"
     24 #include "storage/browser/storage_browser_export.h"
     25 
     26 namespace base {
     27 class SequencedTaskRunner;
     28 }
     29 
     30 namespace content {
     31 class SandboxFileSystemBackendDelegateTest;
     32 class SandboxFileSystemTestHelper;
     33 }
     34 
     35 namespace storage {
     36 class QuotaManagerProxy;
     37 class SpecialStoragePolicy;
     38 }
     39 
     40 namespace storage {
     41 class FileStreamReader;
     42 }
     43 
     44 namespace storage {
     45 
     46 class AsyncFileUtil;
     47 class FileStreamWriter;
     48 class FileSystemFileUtil;
     49 class FileSystemOperationContext;
     50 class FileSystemURL;
     51 class FileSystemUsageCache;
     52 class ObfuscatedFileUtil;
     53 class QuotaReservationManager;
     54 class SandboxFileSystemBackend;
     55 class SandboxQuotaObserver;
     56 
     57 // Delegate implementation of the some methods in Sandbox/SyncFileSystemBackend.
     58 // An instance of this class is created and owned by FileSystemContext.
     59 class STORAGE_EXPORT SandboxFileSystemBackendDelegate
     60     : public FileSystemQuotaUtil {
     61  public:
     62   typedef FileSystemBackend::OpenFileSystemCallback OpenFileSystemCallback;
     63 
     64   // The FileSystem directory name.
     65   static const base::FilePath::CharType kFileSystemDirectory[];
     66 
     67   // Origin enumerator interface.
     68   // An instance of this interface is assumed to be called on the file thread.
     69   class OriginEnumerator {
     70    public:
     71     virtual ~OriginEnumerator() {}
     72 
     73     // Returns the next origin.  Returns empty if there are no more origins.
     74     virtual GURL Next() = 0;
     75 
     76     // Returns the current origin's information.
     77     virtual bool HasFileSystemType(FileSystemType type) const = 0;
     78   };
     79 
     80   // Returns the type directory name in sandbox directory for given |type|.
     81   static std::string GetTypeString(FileSystemType type);
     82 
     83   SandboxFileSystemBackendDelegate(
     84       storage::QuotaManagerProxy* quota_manager_proxy,
     85       base::SequencedTaskRunner* file_task_runner,
     86       const base::FilePath& profile_path,
     87       storage::SpecialStoragePolicy* special_storage_policy,
     88       const FileSystemOptions& file_system_options);
     89 
     90   virtual ~SandboxFileSystemBackendDelegate();
     91 
     92   // Returns an origin enumerator of sandbox filesystem.
     93   // This method can only be called on the file thread.
     94   OriginEnumerator* CreateOriginEnumerator();
     95 
     96   // Gets a base directory path of the sandboxed filesystem that is
     97   // specified by |origin_url| and |type|.
     98   // (The path is similar to the origin's root path but doesn't contain
     99   // the 'unique' part.)
    100   // Returns an empty path if the given type is invalid.
    101   // This method can only be called on the file thread.
    102   base::FilePath GetBaseDirectoryForOriginAndType(
    103       const GURL& origin_url,
    104       FileSystemType type,
    105       bool create);
    106 
    107   // FileSystemBackend helpers.
    108   void OpenFileSystem(
    109       const GURL& origin_url,
    110       FileSystemType type,
    111       OpenFileSystemMode mode,
    112       const OpenFileSystemCallback& callback,
    113       const GURL& root_url);
    114   scoped_ptr<FileSystemOperationContext> CreateFileSystemOperationContext(
    115       const FileSystemURL& url,
    116       FileSystemContext* context,
    117       base::File::Error* error_code) const;
    118   scoped_ptr<storage::FileStreamReader> CreateFileStreamReader(
    119       const FileSystemURL& url,
    120       int64 offset,
    121       const base::Time& expected_modification_time,
    122       FileSystemContext* context) const;
    123   scoped_ptr<FileStreamWriter> CreateFileStreamWriter(
    124       const FileSystemURL& url,
    125       int64 offset,
    126       FileSystemContext* context,
    127       FileSystemType type) const;
    128 
    129   // FileSystemQuotaUtil overrides.
    130   virtual base::File::Error DeleteOriginDataOnFileTaskRunner(
    131       FileSystemContext* context,
    132       storage::QuotaManagerProxy* proxy,
    133       const GURL& origin_url,
    134       FileSystemType type) OVERRIDE;
    135   virtual void GetOriginsForTypeOnFileTaskRunner(
    136       FileSystemType type,
    137       std::set<GURL>* origins) OVERRIDE;
    138   virtual void GetOriginsForHostOnFileTaskRunner(
    139       FileSystemType type,
    140       const std::string& host,
    141       std::set<GURL>* origins) OVERRIDE;
    142   virtual int64 GetOriginUsageOnFileTaskRunner(
    143       FileSystemContext* context,
    144       const GURL& origin_url,
    145       FileSystemType type) OVERRIDE;
    146   virtual scoped_refptr<QuotaReservation>
    147       CreateQuotaReservationOnFileTaskRunner(
    148           const GURL& origin_url,
    149           FileSystemType type) OVERRIDE;
    150 
    151   // Adds an observer for the secified |type| of a file system, bound to
    152   // |task_runner|.
    153   virtual void AddFileUpdateObserver(FileSystemType type,
    154                                      FileUpdateObserver* observer,
    155                                      base::SequencedTaskRunner* task_runner);
    156   virtual void AddFileChangeObserver(FileSystemType type,
    157                                      FileChangeObserver* observer,
    158                                      base::SequencedTaskRunner* task_runner);
    159   virtual void AddFileAccessObserver(FileSystemType type,
    160                                      FileAccessObserver* observer,
    161                                      base::SequencedTaskRunner* task_runner);
    162 
    163   // Returns observer lists for the specified |type| of a file system.
    164   virtual const UpdateObserverList* GetUpdateObservers(
    165       FileSystemType type) const;
    166   virtual const ChangeObserverList* GetChangeObservers(
    167       FileSystemType type) const;
    168   virtual const AccessObserverList* GetAccessObservers(
    169       FileSystemType type) const;
    170 
    171   // Registers quota observer for file updates on filesystem of |type|.
    172   void RegisterQuotaUpdateObserver(FileSystemType type);
    173 
    174   void InvalidateUsageCache(const GURL& origin_url,
    175                             FileSystemType type);
    176   void StickyInvalidateUsageCache(const GURL& origin_url,
    177                                   FileSystemType type);
    178 
    179   void CollectOpenFileSystemMetrics(base::File::Error error_code);
    180 
    181   base::SequencedTaskRunner* file_task_runner() {
    182     return file_task_runner_.get();
    183   }
    184 
    185   AsyncFileUtil* file_util() { return sandbox_file_util_.get(); }
    186   FileSystemUsageCache* usage_cache() { return file_system_usage_cache_.get(); }
    187   SandboxQuotaObserver* quota_observer() { return quota_observer_.get(); }
    188 
    189   storage::SpecialStoragePolicy* special_storage_policy() {
    190     return special_storage_policy_.get();
    191   }
    192 
    193   const FileSystemOptions& file_system_options() const {
    194     return file_system_options_;
    195   }
    196 
    197   FileSystemFileUtil* sync_file_util();
    198 
    199  private:
    200   friend class QuotaBackendImpl;
    201   friend class SandboxQuotaObserver;
    202   friend class content::SandboxFileSystemBackendDelegateTest;
    203   friend class content::SandboxFileSystemTestHelper;
    204 
    205   // Performs API-specific validity checks on the given path |url|.
    206   // Returns true if access to |url| is valid in this filesystem.
    207   bool IsAccessValid(const FileSystemURL& url) const;
    208 
    209   // Returns true if the given |url|'s scheme is allowed to access
    210   // filesystem.
    211   bool IsAllowedScheme(const GURL& url) const;
    212 
    213   // Returns a path to the usage cache file.
    214   base::FilePath GetUsageCachePathForOriginAndType(
    215       const GURL& origin_url,
    216       FileSystemType type);
    217 
    218   // Returns a path to the usage cache file (static version).
    219   static base::FilePath GetUsageCachePathForOriginAndType(
    220       ObfuscatedFileUtil* sandbox_file_util,
    221       const GURL& origin_url,
    222       FileSystemType type,
    223       base::File::Error* error_out);
    224 
    225   int64 RecalculateUsage(FileSystemContext* context,
    226                          const GURL& origin,
    227                          FileSystemType type);
    228 
    229   ObfuscatedFileUtil* obfuscated_file_util();
    230 
    231   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
    232 
    233   scoped_ptr<AsyncFileUtil> sandbox_file_util_;
    234   scoped_ptr<FileSystemUsageCache> file_system_usage_cache_;
    235   scoped_ptr<SandboxQuotaObserver> quota_observer_;
    236   scoped_ptr<QuotaReservationManager> quota_reservation_manager_;
    237 
    238   scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy_;
    239 
    240   FileSystemOptions file_system_options_;
    241 
    242   bool is_filesystem_opened_;
    243   base::ThreadChecker io_thread_checker_;
    244 
    245   // Accessed only on the file thread.
    246   std::set<GURL> visited_origins_;
    247 
    248   std::set<std::pair<GURL, FileSystemType> > sticky_dirty_origins_;
    249 
    250   std::map<FileSystemType, UpdateObserverList> update_observers_;
    251   std::map<FileSystemType, ChangeObserverList> change_observers_;
    252   std::map<FileSystemType, AccessObserverList> access_observers_;
    253 
    254   base::Time next_release_time_for_open_filesystem_stat_;
    255 
    256   base::WeakPtrFactory<SandboxFileSystemBackendDelegate> weak_factory_;
    257 
    258   DISALLOW_COPY_AND_ASSIGN(SandboxFileSystemBackendDelegate);
    259 };
    260 
    261 }  // namespace storage
    262 
    263 #endif  // STORAGE_BROWSER_FILEAPI_SANDBOX_FILE_SYSTEM_BACKEND_DELEGATE_H_
    264