FileAPI: Implement FileSystemQuotaUtil on SandboxFileSystemBackendDelegate

This makes SandboxFileSystemBackendDelegate to implement FileSystemQuotaUtil
instead of Sandbox/SyncFileSystemBackend so that it can remove a thin layer from
those backends.

And also moves common implementations of FileSystemBackend
(e.g. CreateFileStreamReader()) into the delegate.


BUG=272078
TEST=unit_tests, content_unittests

Review URL: https://chromiumcodereview.appspot.com/22821006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@218987 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 225 insertions, 191 deletions

diff --git a/webkit/browser/fileapi/file_system_quota_util.h b/webkit/browser/fileapi/file_system_quota_util.h
index 5655c99..5f3c7dd 100644
--- a/webkit/browser/fileapi/file_system_quota_util.h
+++ b/webkit/browser/fileapi/file_system_quota_util.h
@@ -68,6 +68,9 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemQuotaUtil {
       FileSystemType type,
       FileAccessObserver* observer,
       base::SequencedTaskRunner* task_runner) = 0;
+
+  // Returns the observer list for |type|, or returns NULL if any observers
+  // have not been registered on |type|.
   virtual const UpdateObserverList* GetUpdateObservers(
       FileSystemType type) const = 0;
   virtual const ChangeObserverList* GetChangeObservers(
diff --git a/webkit/browser/fileapi/sandbox_file_system_backend.cc b/webkit/browser/fileapi/sandbox_file_system_backend.cc
index 665c0f1..5cf2464 100644
--- a/webkit/browser/fileapi/sandbox_file_system_backend.cc
+++ b/webkit/browser/fileapi/sandbox_file_system_backend.cc
@@ -31,13 +31,6 @@ using quota::SpecialStoragePolicy;
 
 namespace fileapi {
 
-namespace {
-
-const char kTemporaryOriginsCountLabel[] = "FileSystem.TemporaryOriginsCount";
-const char kPersistentOriginsCountLabel[] = "FileSystem.PersistentOriginsCount";
-
-}  // anonymous namespace
-
 SandboxFileSystemBackend::SandboxFileSystemBackend(
     SandboxFileSystemBackendDelegate* delegate)
     : delegate_(delegate),
@@ -53,11 +46,23 @@ bool SandboxFileSystemBackend::CanHandleType(FileSystemType type) const {
 }
 
 void SandboxFileSystemBackend::Initialize(FileSystemContext* context) {
+  DCHECK(delegate_);
+
   // Set quota observers.
-  update_observers_ = update_observers_.AddObserver(
+  delegate_->AddFileUpdateObserver(
+      fileapi::kFileSystemTypeTemporary,
+      delegate_->quota_observer(),
+      delegate_->file_task_runner());
+  delegate_->AddFileAccessObserver(
+      fileapi::kFileSystemTypeTemporary,
+      delegate_->quota_observer(), NULL);
+
+  delegate_->AddFileUpdateObserver(
+      fileapi::kFileSystemTypePersistent,
       delegate_->quota_observer(),
       delegate_->file_task_runner());
-  access_observers_ = access_observers_.AddObserver(
+  delegate_->AddFileAccessObserver(
+      fileapi::kFileSystemTypePersistent,
       delegate_->quota_observer(), NULL);
 }
 
@@ -106,16 +111,13 @@ FileSystemOperation* SandboxFileSystemBackend::CreateFileSystemOperation(
     FileSystemContext* context,
     base::PlatformFileError* error_code) const {
   DCHECK(CanHandleType(url.type()));
+  DCHECK(error_code);
+
   DCHECK(delegate_);
-  if (!delegate_->IsAccessValid(url)) {
-    *error_code = base::PLATFORM_FILE_ERROR_SECURITY;
+  scoped_ptr<FileSystemOperationContext> operation_context =
+      delegate_->CreateFileSystemOperationContext(url, context, error_code);
+  if (!operation_context)
     return NULL;
-  }
-
-  scoped_ptr<FileSystemOperationContext> operation_context(
-      new FileSystemOperationContext(context));
-  operation_context->set_update_observers(update_observers_);
-  operation_context->set_change_observers(change_observers_);
 
   SpecialStoragePolicy* policy = delegate_->special_storage_policy();
   if (policy && policy->IsStorageUnlimited(url.origin()))
@@ -134,11 +136,8 @@ SandboxFileSystemBackend::CreateFileStreamReader(
     FileSystemContext* context) const {
   DCHECK(CanHandleType(url.type()));
   DCHECK(delegate_);
-  if (!delegate_->IsAccessValid(url))
-    return scoped_ptr<webkit_blob::FileStreamReader>();
-  return scoped_ptr<webkit_blob::FileStreamReader>(
-      new FileSystemFileStreamReader(
-          context, url, offset, expected_modification_time));
+  return delegate_->CreateFileStreamReader(
+      url, offset, expected_modification_time, context);
 }
 
 scoped_ptr<fileapi::FileStreamWriter>
@@ -148,14 +147,11 @@ SandboxFileSystemBackend::CreateFileStreamWriter(
     FileSystemContext* context) const {
   DCHECK(CanHandleType(url.type()));
   DCHECK(delegate_);
-  if (!delegate_->IsAccessValid(url))
-    return scoped_ptr<fileapi::FileStreamWriter>();
-  return scoped_ptr<fileapi::FileStreamWriter>(
-      new SandboxFileStreamWriter(context, url, offset, update_observers_));
+  return delegate_->CreateFileStreamWriter(url, offset, context, url.type());
 }
 
 FileSystemQuotaUtil* SandboxFileSystemBackend::GetQuotaUtil() {
-  return this;
+  return delegate_;
 }
 
 SandboxFileSystemBackendDelegate::OriginEnumerator*
@@ -164,95 +160,4 @@ SandboxFileSystemBackend::CreateOriginEnumerator() {
   return delegate_->CreateOriginEnumerator();
 }
 
-base::PlatformFileError
-SandboxFileSystemBackend::DeleteOriginDataOnFileThread(
-    FileSystemContext* file_system_context,
-    QuotaManagerProxy* proxy,
-    const GURL& origin_url,
-    fileapi::FileSystemType type) {
-  DCHECK(CanHandleType(type));
-  DCHECK(delegate_);
-  return delegate_->DeleteOriginDataOnFileThread(
-      file_system_context, proxy, origin_url, type);
-}
-
-void SandboxFileSystemBackend::GetOriginsForTypeOnFileThread(
-    fileapi::FileSystemType type, std::set<GURL>* origins) {
-  DCHECK(CanHandleType(type));
-  DCHECK(delegate_);
-  delegate_->GetOriginsForTypeOnFileThread(type, origins);
-  switch (type) {
-    case kFileSystemTypeTemporary:
-      UMA_HISTOGRAM_COUNTS(kTemporaryOriginsCountLabel, origins->size());
-      break;
-    case kFileSystemTypePersistent:
-      UMA_HISTOGRAM_COUNTS(kPersistentOriginsCountLabel, origins->size());
-      break;
-    default:
-      break;
-  }
-}
-
-void SandboxFileSystemBackend::GetOriginsForHostOnFileThread(
-    fileapi::FileSystemType type, const std::string& host,
-    std::set<GURL>* origins) {
-  DCHECK(CanHandleType(type));
-  DCHECK(delegate_);
-  delegate_->GetOriginsForHostOnFileThread(type, host, origins);
-}
-
-int64 SandboxFileSystemBackend::GetOriginUsageOnFileThread(
-    FileSystemContext* file_system_context,
-    const GURL& origin_url,
-    fileapi::FileSystemType type) {
-  DCHECK(CanHandleType(type));
-  DCHECK(delegate_);
-  return delegate_->GetOriginUsageOnFileThread(
-      file_system_context, origin_url, type);
-}
-
-void SandboxFileSystemBackend::AddFileUpdateObserver(
-    FileSystemType type,
-    FileUpdateObserver* observer,
-    base::SequencedTaskRunner* task_runner) {
-  DCHECK(CanHandleType(type));
-  UpdateObserverList* list = &update_observers_;
-  *list = list->AddObserver(observer, task_runner);
-}
-
-void SandboxFileSystemBackend::AddFileChangeObserver(
-    FileSystemType type,
-    FileChangeObserver* observer,
-    base::SequencedTaskRunner* task_runner) {
-  DCHECK(CanHandleType(type));
-  ChangeObserverList* list = &change_observers_;
-  *list = list->AddObserver(observer, task_runner);
-}
-
-void SandboxFileSystemBackend::AddFileAccessObserver(
-    FileSystemType type,
-    FileAccessObserver* observer,
-    base::SequencedTaskRunner* task_runner) {
-  DCHECK(CanHandleType(type));
-  access_observers_ = access_observers_.AddObserver(observer, task_runner);
-}
-
-const UpdateObserverList* SandboxFileSystemBackend::GetUpdateObservers(
-    FileSystemType type) const {
-  DCHECK(CanHandleType(type));
-  return &update_observers_;
-}
-
-const ChangeObserverList* SandboxFileSystemBackend::GetChangeObservers(
-    FileSystemType type) const {
-  DCHECK(CanHandleType(type));
-  return &change_observers_;
-}
-
-const AccessObserverList* SandboxFileSystemBackend::GetAccessObservers(
-    FileSystemType type) const {
-  DCHECK(CanHandleType(type));
-  return &access_observers_;
-}
-
 }  // namespace fileapi
diff --git a/webkit/browser/fileapi/sandbox_file_system_backend.h b/webkit/browser/fileapi/sandbox_file_system_backend.h
index a1a5686..207600ef 100644
--- a/webkit/browser/fileapi/sandbox_file_system_backend.h
+++ b/webkit/browser/fileapi/sandbox_file_system_backend.h
@@ -27,8 +27,7 @@ namespace fileapi {
 // This interface also lets one enumerate and remove storage for the origins
 // that use the filesystem.
 class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackend
-    : public FileSystemBackend,
-      public FileSystemQuotaUtil {
+    : public FileSystemBackend {
  public:
   explicit SandboxFileSystemBackend(SandboxFileSystemBackendDelegate* delegate);
   virtual ~SandboxFileSystemBackend();
@@ -65,42 +64,6 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackend
   // This method can only be called on the file thread.
   SandboxFileSystemBackendDelegate::OriginEnumerator* CreateOriginEnumerator();
 
-  // FileSystemQuotaUtil overrides.
-  virtual base::PlatformFileError DeleteOriginDataOnFileThread(
-      FileSystemContext* context,
-      quota::QuotaManagerProxy* proxy,
-      const GURL& origin_url,
-      FileSystemType type) OVERRIDE;
-  virtual void GetOriginsForTypeOnFileThread(
-      FileSystemType type,
-      std::set<GURL>* origins) OVERRIDE;
-  virtual void GetOriginsForHostOnFileThread(
-      FileSystemType type,
-      const std::string& host,
-      std::set<GURL>* origins) OVERRIDE;
-  virtual int64 GetOriginUsageOnFileThread(
-      FileSystemContext* context,
-      const GURL& origin_url,
-      FileSystemType type) OVERRIDE;
-  virtual void AddFileUpdateObserver(
-      FileSystemType type,
-      FileUpdateObserver* observer,
-      base::SequencedTaskRunner* task_runner) OVERRIDE;
-  virtual void AddFileChangeObserver(
-      FileSystemType type,
-      FileChangeObserver* observer,
-      base::SequencedTaskRunner* task_runner) OVERRIDE;
-  virtual void AddFileAccessObserver(
-      FileSystemType type,
-      FileAccessObserver* observer,
-      base::SequencedTaskRunner* task_runner) OVERRIDE;
-  virtual const UpdateObserverList* GetUpdateObservers(
-      FileSystemType type) const OVERRIDE;
-  virtual const ChangeObserverList* GetChangeObservers(
-      FileSystemType type) const OVERRIDE;
-  virtual const AccessObserverList* GetAccessObservers(
-      FileSystemType type) const OVERRIDE;
-
   void set_enable_temporary_file_system_in_incognito(bool enable) {
     enable_temporary_file_system_in_incognito_ = enable;
   }
@@ -110,11 +73,6 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackend
 
   bool enable_temporary_file_system_in_incognito_;
 
-  // Observers.
-  UpdateObserverList update_observers_;
-  ChangeObserverList change_observers_;
-  AccessObserverList access_observers_;
-
   DISALLOW_COPY_AND_ASSIGN(SandboxFileSystemBackend);
 };
 
diff --git a/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc b/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc
index bfd7fd8..c1c8c88 100644
--- a/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc
+++ b/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc
@@ -12,10 +12,12 @@
 #include "net/base/net_util.h"
 #include "webkit/browser/fileapi/async_file_util_adapter.h"
 #include "webkit/browser/fileapi/file_system_context.h"
+#include "webkit/browser/fileapi/file_system_file_stream_reader.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/file_system_usage_cache.h"
 #include "webkit/browser/fileapi/obfuscated_file_util.h"
+#include "webkit/browser/fileapi/sandbox_file_stream_writer.h"
 #include "webkit/browser/fileapi/sandbox_file_system_backend.h"
 #include "webkit/browser/fileapi/sandbox_quota_observer.h"
 #include "webkit/browser/quota/quota_manager.h"
@@ -25,6 +27,9 @@ namespace fileapi {
 
 namespace {
 
+const char kTemporaryOriginsCountLabel[] = "FileSystem.TemporaryOriginsCount";
+const char kPersistentOriginsCountLabel[] = "FileSystem.PersistentOriginsCount";
+
 const char kOpenFileSystemLabel[] = "FileSystem.OpenFileSystem";
 const char kOpenFileSystemDetailLabel[] = "FileSystem.OpenFileSystemDetail";
 const char kOpenFileSystemDetailNonThrottledLabel[] =
@@ -64,7 +69,7 @@ class ObfuscatedOriginEnumerator
     return enum_->Next();
   }
 
-  virtual bool HasFileSystemType(fileapi::FileSystemType type) const OVERRIDE {
+  virtual bool HasFileSystemType(FileSystemType type) const OVERRIDE {
     return enum_->HasFileSystemType(type);
   }
 
@@ -128,6 +133,7 @@ SandboxFileSystemBackendDelegate::SandboxFileSystemBackendDelegate(
           usage_cache())),
       special_storage_policy_(special_storage_policy),
       file_system_options_(file_system_options),
+      is_filesystem_opened_(false),
       weak_factory_(this) {
 }
 
@@ -204,7 +210,7 @@ SandboxFileSystemBackendDelegate::CreateOriginEnumerator() {
 base::FilePath
 SandboxFileSystemBackendDelegate::GetBaseDirectoryForOriginAndType(
     const GURL& origin_url,
-    fileapi::FileSystemType type,
+    FileSystemType type,
     bool create) {
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
   base::FilePath path = obfuscated_file_util()->GetDirectoryForOriginAndType(
@@ -216,7 +222,7 @@ SandboxFileSystemBackendDelegate::GetBaseDirectoryForOriginAndType(
 
 void SandboxFileSystemBackendDelegate::OpenFileSystem(
     const GURL& origin_url,
-    fileapi::FileSystemType type,
+    FileSystemType type,
     OpenFileSystemMode mode,
     const OpenFileSystemCallback& callback,
     const GURL& root_url) {
@@ -237,6 +243,58 @@ void SandboxFileSystemBackendDelegate::OpenFileSystem(
                  weak_factory_.GetWeakPtr(),
                  base::Bind(callback, root_url, name),
                  base::Owned(error_ptr)));
+
+  is_filesystem_opened_ = true;
+}
+
+scoped_ptr<FileSystemOperationContext>
+SandboxFileSystemBackendDelegate::CreateFileSystemOperationContext(
+    const FileSystemURL& url,
+    FileSystemContext* context,
+    base::PlatformFileError* error_code) const {
+  if (!IsAccessValid(url)) {
+    *error_code = base::PLATFORM_FILE_ERROR_SECURITY;
+    return scoped_ptr<FileSystemOperationContext>();
+  }
+
+  const UpdateObserverList* update_observers = GetUpdateObservers(url.type());
+  const ChangeObserverList* change_observers = GetChangeObservers(url.type());
+  DCHECK(update_observers);
+
+  scoped_ptr<FileSystemOperationContext> operation_context(
+      new FileSystemOperationContext(context));
+  operation_context->set_update_observers(*update_observers);
+  operation_context->set_change_observers(
+      change_observers ? *change_observers : ChangeObserverList());
+
+  return operation_context.Pass();
+}
+
+scoped_ptr<webkit_blob::FileStreamReader>
+SandboxFileSystemBackendDelegate::CreateFileStreamReader(
+    const FileSystemURL& url,
+    int64 offset,
+    const base::Time& expected_modification_time,
+    FileSystemContext* context) const {
+  if (!IsAccessValid(url))
+    return scoped_ptr<webkit_blob::FileStreamReader>();
+  return scoped_ptr<webkit_blob::FileStreamReader>(
+      new FileSystemFileStreamReader(
+          context, url, offset, expected_modification_time));
+}
+
+scoped_ptr<FileStreamWriter>
+SandboxFileSystemBackendDelegate::CreateFileStreamWriter(
+    const FileSystemURL& url,
+    int64 offset,
+    FileSystemContext* context,
+    FileSystemType type) const {
+  if (!IsAccessValid(url))
+    return scoped_ptr<FileStreamWriter>();
+  const UpdateObserverList* observers = GetUpdateObservers(type);
+  DCHECK(observers);
+  return scoped_ptr<FileStreamWriter>(
+      new SandboxFileStreamWriter(context, url, offset, *observers));
 }
 
 base::PlatformFileError
@@ -244,7 +302,7 @@ SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileThread(
     FileSystemContext* file_system_context,
     quota::QuotaManagerProxy* proxy,
     const GURL& origin_url,
-    fileapi::FileSystemType type) {
+    FileSystemType type) {
   int64 usage = GetOriginUsageOnFileThread(
       file_system_context, origin_url, type);
   usage_cache()->CloseCacheFiles();
@@ -264,7 +322,7 @@ SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileThread(
 }
 
 void SandboxFileSystemBackendDelegate::GetOriginsForTypeOnFileThread(
-    fileapi::FileSystemType type, std::set<GURL>* origins) {
+    FileSystemType type, std::set<GURL>* origins) {
   DCHECK(origins);
   scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
   GURL origin;
@@ -272,10 +330,20 @@ void SandboxFileSystemBackendDelegate::GetOriginsForTypeOnFileThread(
     if (enumerator->HasFileSystemType(type))
       origins->insert(origin);
   }
+  switch (type) {
+    case kFileSystemTypeTemporary:
+      UMA_HISTOGRAM_COUNTS(kTemporaryOriginsCountLabel, origins->size());
+      break;
+    case kFileSystemTypePersistent:
+      UMA_HISTOGRAM_COUNTS(kPersistentOriginsCountLabel, origins->size());
+      break;
+    default:
+      break;
+  }
 }
 
 void SandboxFileSystemBackendDelegate::GetOriginsForHostOnFileThread(
-    fileapi::FileSystemType type, const std::string& host,
+    FileSystemType type, const std::string& host,
     std::set<GURL>* origins) {
   DCHECK(origins);
   scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
@@ -290,7 +358,7 @@ void SandboxFileSystemBackendDelegate::GetOriginsForHostOnFileThread(
 int64 SandboxFileSystemBackendDelegate::GetOriginUsageOnFileThread(
     FileSystemContext* file_system_context,
     const GURL& origin_url,
-    fileapi::FileSystemType type) {
+    FileSystemType type) {
   // Don't use usage cache and return recalculated usage for sticky invalidated
   // origins.
   if (ContainsKey(sticky_dirty_origins_, std::make_pair(origin_url, type)))
@@ -325,9 +393,63 @@ int64 SandboxFileSystemBackendDelegate::GetOriginUsageOnFileThread(
   return usage;
 }
 
+void SandboxFileSystemBackendDelegate::AddFileUpdateObserver(
+    FileSystemType type,
+    FileUpdateObserver* observer,
+    base::SequencedTaskRunner* task_runner) {
+  DCHECK(!is_filesystem_opened_);
+  update_observers_[type] =
+      update_observers_[type].AddObserver(observer, task_runner);
+}
+
+void SandboxFileSystemBackendDelegate::AddFileChangeObserver(
+    FileSystemType type,
+    FileChangeObserver* observer,
+    base::SequencedTaskRunner* task_runner) {
+  DCHECK(!is_filesystem_opened_);
+  change_observers_[type] =
+      change_observers_[type].AddObserver(observer, task_runner);
+}
+
+void SandboxFileSystemBackendDelegate::AddFileAccessObserver(
+    FileSystemType type,
+    FileAccessObserver* observer,
+    base::SequencedTaskRunner* task_runner) {
+  DCHECK(!is_filesystem_opened_);
+  access_observers_[type] =
+      access_observers_[type].AddObserver(observer, task_runner);
+}
+
+const UpdateObserverList* SandboxFileSystemBackendDelegate::GetUpdateObservers(
+    FileSystemType type) const {
+  std::map<FileSystemType, UpdateObserverList>::const_iterator iter =
+      update_observers_.find(type);
+  if (iter == update_observers_.end())
+    return NULL;
+  return &iter->second;
+}
+
+const ChangeObserverList* SandboxFileSystemBackendDelegate::GetChangeObservers(
+    FileSystemType type) const {
+  std::map<FileSystemType, ChangeObserverList>::const_iterator iter =
+      change_observers_.find(type);
+  if (iter == change_observers_.end())
+    return NULL;
+  return &iter->second;
+}
+
+const AccessObserverList* SandboxFileSystemBackendDelegate::GetAccessObservers(
+    FileSystemType type) const {
+  std::map<FileSystemType, AccessObserverList>::const_iterator iter =
+      access_observers_.find(type);
+  if (iter == access_observers_.end())
+    return NULL;
+  return &iter->second;
+}
+
 void SandboxFileSystemBackendDelegate::InvalidateUsageCache(
     const GURL& origin,
-    fileapi::FileSystemType type) {
+    FileSystemType type) {
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
   base::FilePath usage_file_path = GetUsageCachePathForOriginAndType(
       obfuscated_file_util(), origin, type, &error);
@@ -338,7 +460,7 @@ void SandboxFileSystemBackendDelegate::InvalidateUsageCache(
 
 void SandboxFileSystemBackendDelegate::StickyInvalidateUsageCache(
     const GURL& origin,
-    fileapi::FileSystemType type) {
+    FileSystemType type) {
   sticky_dirty_origins_.insert(std::make_pair(origin, type));
   quota_observer()->SetUsageCacheEnabled(origin, type, false);
   InvalidateUsageCache(origin, type);
@@ -365,7 +487,7 @@ base::FilePath
 SandboxFileSystemBackendDelegate::GetUsageCachePathForOriginAndType(
     ObfuscatedFileUtil* sandbox_file_util,
     const GURL& origin_url,
-    fileapi::FileSystemType type,
+    FileSystemType type,
     base::PlatformFileError* error_out) {
   DCHECK(error_out);
   *error_out = base::PLATFORM_FILE_OK;
diff --git a/webkit/browser/fileapi/sandbox_file_system_backend_delegate.h b/webkit/browser/fileapi/sandbox_file_system_backend_delegate.h
index 5fb83f0..61fe700 100644
--- a/webkit/browser/fileapi/sandbox_file_system_backend_delegate.h
+++ b/webkit/browser/fileapi/sandbox_file_system_backend_delegate.h
@@ -5,6 +5,7 @@
 #ifndef WEBKIT_BROWSER_FILEAPI_SANDBOX_FILE_SYSTEM_BACKEND_DELEGATE_H_
 #define WEBKIT_BROWSER_FILEAPI_SANDBOX_FILE_SYSTEM_BACKEND_DELEGATE_H_
 
+#include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ -13,6 +14,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "webkit/browser/fileapi/file_system_backend.h"
 #include "webkit/browser/fileapi/file_system_options.h"
@@ -28,10 +30,16 @@ class QuotaManagerProxy;
 class SpecialStoragePolicy;
 }
 
+namespace webkit_blob {
+class FileStreamReader;
+}
+
 namespace fileapi {
 
 class AsyncFileUtil;
+class FileStreamWriter;
 class FileSystemFileUtil;
+class FileSystemOperationContext;
 class FileSystemURL;
 class FileSystemUsageCache;
 class ObfuscatedFileUtil;
@@ -41,7 +49,8 @@ class SandboxQuotaObserver;
 
 // Delegate implementation of the some methods in Sandbox/SyncFileSystemBackend.
 // An instance of this class is created and owned by FileSystemContext.
-class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackendDelegate {
+class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackendDelegate
+    : public FileSystemQuotaUtil {
  public:
   typedef FileSystemBackend::OpenFileSystemCallback OpenFileSystemCallback;
 
@@ -68,7 +77,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackendDelegate {
       quota::SpecialStoragePolicy* special_storage_policy,
       const FileSystemOptions& file_system_options);
 
-  ~SandboxFileSystemBackendDelegate();
+  virtual ~SandboxFileSystemBackendDelegate();
 
   // Performs API-specific validity checks on the given path |url|.
   // Returns true if access to |url| is valid in this filesystem.
@@ -100,30 +109,61 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackendDelegate {
       OpenFileSystemMode mode,
       const OpenFileSystemCallback& callback,
       const GURL& root_url);
+  scoped_ptr<FileSystemOperationContext> CreateFileSystemOperationContext(
+      const FileSystemURL& url,
+      FileSystemContext* context,
+      base::PlatformFileError* error_code) const;
+  scoped_ptr<webkit_blob::FileStreamReader> CreateFileStreamReader(
+      const FileSystemURL& url,
+      int64 offset,
+      const base::Time& expected_modification_time,
+      FileSystemContext* context) const;
+  scoped_ptr<FileStreamWriter> CreateFileStreamWriter(
+      const FileSystemURL& url,
+      int64 offset,
+      FileSystemContext* context,
+      FileSystemType type) const;
 
-  // FileSystemQuotaUtil helpers.
-  base::PlatformFileError DeleteOriginDataOnFileThread(
+  // FileSystemQuotaUtil overrides.
+  virtual base::PlatformFileError DeleteOriginDataOnFileThread(
       FileSystemContext* context,
       quota::QuotaManagerProxy* proxy,
       const GURL& origin_url,
-      FileSystemType type);
-  void GetOriginsForTypeOnFileThread(
+      FileSystemType type) OVERRIDE;
+  virtual void GetOriginsForTypeOnFileThread(
       FileSystemType type,
-      std::set<GURL>* origins);
-  void GetOriginsForHostOnFileThread(
+      std::set<GURL>* origins) OVERRIDE;
+  virtual void GetOriginsForHostOnFileThread(
       FileSystemType type,
       const std::string& host,
-      std::set<GURL>* origins);
-  int64 GetOriginUsageOnFileThread(
+      std::set<GURL>* origins) OVERRIDE;
+  virtual int64 GetOriginUsageOnFileThread(
       FileSystemContext* context,
       const GURL& origin_url,
-      FileSystemType type);
-  void InvalidateUsageCache(
-      const GURL& origin_url,
-      FileSystemType type);
-  void StickyInvalidateUsageCache(
-      const GURL& origin_url,
-      FileSystemType type);
+      FileSystemType type) OVERRIDE;
+  virtual void AddFileUpdateObserver(
+      FileSystemType type,
+      FileUpdateObserver* observer,
+      base::SequencedTaskRunner* task_runner) OVERRIDE;
+  virtual void AddFileChangeObserver(
+      FileSystemType type,
+      FileChangeObserver* observer,
+      base::SequencedTaskRunner* task_runner) OVERRIDE;
+  virtual void AddFileAccessObserver(
+      FileSystemType type,
+      FileAccessObserver* observer,
+      base::SequencedTaskRunner* task_runner) OVERRIDE;
+  virtual const UpdateObserverList* GetUpdateObservers(
+      FileSystemType type) const OVERRIDE;
+  virtual const ChangeObserverList* GetChangeObservers(
+      FileSystemType type) const OVERRIDE;
+  virtual const AccessObserverList* GetAccessObservers(
+      FileSystemType type) const OVERRIDE;
+
+  void InvalidateUsageCache(const GURL& origin_url,
+                            FileSystemType type);
+  void StickyInvalidateUsageCache(const GURL& origin_url,
+                                  FileSystemType type);
 
   void CollectOpenFileSystemMetrics(base::PlatformFileError error_code);
 
@@ -133,7 +173,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackendDelegate {
 
   AsyncFileUtil* file_util() { return sandbox_file_util_.get(); }
   FileSystemUsageCache* usage_cache() { return file_system_usage_cache_.get(); }
-  SandboxQuotaObserver* quota_observer() { return quota_observer_.get(); };
+  SandboxQuotaObserver* quota_observer() { return quota_observer_.get(); }
 
   quota::SpecialStoragePolicy* special_storage_policy() {
     return special_storage_policy_.get();
@@ -177,11 +217,17 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackendDelegate {
 
   FileSystemOptions file_system_options_;
 
-  // Acccessed only on the file thread.
+  bool is_filesystem_opened_;
+
+  // Accessed only on the file thread.
   std::set<GURL> visited_origins_;
 
   std::set<std::pair<GURL, FileSystemType> > sticky_dirty_origins_;
 
+  std::map<FileSystemType, UpdateObserverList> update_observers_;
+  std::map<FileSystemType, ChangeObserverList> change_observers_;
+  std::map<FileSystemType, AccessObserverList> access_observers_;
+
   base::Time next_release_time_for_open_filesystem_stat_;
 
   base::WeakPtrFactory<SandboxFileSystemBackendDelegate> weak_factory_;
diff --git a/webkit/browser/fileapi/sandbox_file_system_test_helper.cc b/webkit/browser/fileapi/sandbox_file_system_test_helper.cc
index 97d7a5f..75c29e2 100644
--- a/webkit/browser/fileapi/sandbox_file_system_test_helper.cc
+++ b/webkit/browser/fileapi/sandbox_file_system_test_helper.cc
@@ -124,7 +124,7 @@ SandboxFileSystemTestHelper::NewOperationContext() {
 
 void SandboxFileSystemTestHelper::AddFileChangeObserver(
     FileChangeObserver* observer) {
-  file_system_context_->sandbox_backend()->
+  file_system_context_->sandbox_backend()->GetQuotaUtil()->
       AddFileChangeObserver(type_, observer, NULL);
 }