SyncFS: Introduce SyncFileSystemBackend

webkit/browser/fileapi/syncable/syncable_sandbox_mount_point_provider.cc

Index: webkit/browser/fileapi/syncable/syncable_sandbox_mount_point_provider.cc
diff --git a/webkit/browser/fileapi/syncable/syncable_sandbox_mount_point_provider.cc b/webkit/browser/fileapi/syncable/syncable_sandbox_mount_point_provider.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2637a9a3b060ff2eb26b03ade5e116f7a3a7bd42
--- /dev/null
+++ b/webkit/browser/fileapi/syncable/syncable_sandbox_mount_point_provider.cc
@@ -0,0 +1,176 @@
+// Copyright 2013 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.
+
+#include "webkit/browser/fileapi/syncable/syncable_sandbox_mount_point_provider.h"
+
+#include "base/logging.h"
+#include "base/metrics/histogram.h"
+#include "webkit/browser/fileapi/file_system_context.h"
+#include "webkit/browser/fileapi/sandbox_quota_observer.h"
+#include "webkit/browser/fileapi/syncable/syncable_file_system_operation.h"
+#include "webkit/browser/fileapi/syncable/syncable_file_system_util.h"
+#include "webkit/common/fileapi/file_system_util.h"
+
+namespace sync_file_system {
+
+namespace {
+const char kSyncableOriginsCountLabel[] = "FileSystem.SyncableOriginsCount";
+}  // namespace
+
+SyncableSandboxMountPointProvider::SyncableSandboxMountPointProvider(
+    quota::QuotaManagerProxy* quota_manager_proxy,
+    base::SequencedTaskRunner* file_task_runner,
+    const base::FilePath& profile_path,
+    const fileapi::FileSystemOptions& file_system_options,
+    quota::SpecialStoragePolicy* special_storage_policy)
+    : SandboxMountPointProvider(quota_manager_proxy,
+                                file_task_runner,
+                                profile_path,
+                                file_system_options,
+                                special_storage_policy) {

[kinuko, 2013/07/08 12:31:20]

Hmm... I realized this needs a bit more design discussion.

We cannot create two ObfuscatedFileUtil (sandbox_file_util_) instance for the
same directory, but needs to use the same instance.
So actually naive inheritance doesn't work very well here.

I can't think of a clean design without bigger refactoring, but I think we can
probably start with something like following (not very clean though):

- Move sandbox_file_util_, file_system_usage_cache_ and
  quota_observer_ out of SandboxMountPointProvider into a
  separate class, like 'SandboxContext', and initialize it
  in FileSystemContext().  SandboxMountPointProvider's ctor
  must be given the context and hold it as not-owned member
  variable instead of creating them in its ctors.  Note that
  the context is shared by multiple MountPointProviders/Backends.
  (This change can be done in a separate patch.)

- Change OpenFileSystem's signature to take FileSystemContext.
  Also maybe rename the method to Initialize or InitializeFileSystem.
  (This change can be done in a separate patch.)

- In this class's OpenFileSystem/Initialize implementation,
  set the SandboxContext held by FileSystemContext to its
  member variable (as not-owned pointer), and use the
  SandboxContext for serving the succeeding method calls.
  (not very clean, but would work)

(If you again hit some other problems feel free to talk to me)

[nhiroki, 2013/07/22 04:34:14]

Done in http://crrev.com/210790/
Done in http://crrev.com/211888/
Done in this change.

+  fileapi::UpdateObserverList::Source update_observers_src;
+
+  if (enable_usage_tracking_) {
+    update_observers_src.AddObserver(quota_observer_.get(),
+                                     file_task_runner_.get());
+  }
+
+  syncable_update_observers_ =
+      fileapi::UpdateObserverList(update_observers_src);
+}
+
+SyncableSandboxMountPointProvider::~SyncableSandboxMountPointProvider() {
+  file_task_runner_->DeleteSoon(FROM_HERE, change_tracker_.release());
+}
+
+bool SyncableSandboxMountPointProvider::CanHandleType(
+    fileapi::FileSystemType type) const {
+  return type == fileapi::kFileSystemTypeSyncable ||
+         type == fileapi::kFileSystemTypeSyncableForInternalSync;
+}
+
+GURL SyncableSandboxMountPointProvider::GetRootURI(
+    const GURL& origin_url,
+    fileapi::FileSystemType type) const {
+  if (!CanHandleType(type))
+    return GURL();
+  if (type == fileapi::kFileSystemTypeSyncableForInternalSync)
+    return GetFileSystemRootURI(origin_url, type);
+  return sync_file_system::GetSyncableFileSystemRootURI(origin_url);
+}
+
+fileapi::FileSystemOperation*
+SyncableSandboxMountPointProvider::CreateFileSystemOperation(
+    const fileapi::FileSystemURL& url,
+    fileapi::FileSystemContext* context,
+    base::PlatformFileError* error_code) const {
+  if (!IsAccessValid(url)) {
+    *error_code = base::PLATFORM_FILE_ERROR_SECURITY;
+    return NULL;
+  }
+
+  if (url.type() == fileapi::kFileSystemTypeSyncableForInternalSync) {
+    return fileapi::SandboxMountPointProvider::CreateFileSystemOperation(
+        url, context, error_code);
+  }
+
+  scoped_ptr<fileapi::FileSystemOperationContext> operation_context(
+      new fileapi::FileSystemOperationContext(context));
+  operation_context->set_update_observers(syncable_update_observers_);
+  operation_context->set_change_observers(syncable_change_observers_);
+
+  return new SyncableFileSystemOperation(
+      url, context, operation_context.Pass());
+}
+
+const fileapi::UpdateObserverList*
+SyncableSandboxMountPointProvider::GetUpdateObservers(
+    fileapi::FileSystemType type) const {
+  if (type == fileapi::kFileSystemTypeSyncableForInternalSync)
+    return &update_observers_;
+  return &syncable_update_observers_;
+}
+
+void SyncableSandboxMountPointProvider::GetOriginsForTypeOnFileThread(
+    fileapi::FileSystemType type,
+    std::set<GURL>* origins) {
+  DCHECK(CanHandleType(type));
+  DCHECK(origins);
+  scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
+  GURL origin;
+  while (!(origin = enumerator->Next()).is_empty()) {
+    if (enumerator->HasFileSystemType(type))
+      origins->insert(origin);
+  }
+  switch (type) {
+    case fileapi::kFileSystemTypeSyncable:
+      UMA_HISTOGRAM_COUNTS(kSyncableOriginsCountLabel, origins->size());
+      break;
+    default:
+      break;
+  }
+}
+
+void SyncableSandboxMountPointProvider::AddFileUpdateObserver(
+    fileapi::FileSystemType type,
+    fileapi::FileUpdateObserver* observer,
+    base::SequencedTaskRunner* task_runner) {
+  DCHECK(CanHandleType(type));
+  if (type == fileapi::kFileSystemTypeSyncableForInternalSync) {
+    fileapi::SandboxMountPointProvider::AddFileUpdateObserver(
+        type, observer, task_runner);
+    return;
+  }
+
+  fileapi::UpdateObserverList* list = &syncable_update_observers_;
+  fileapi::UpdateObserverList::Source observer_source = list->source();
+  observer_source.AddObserver(observer, task_runner);
+  *list = fileapi::UpdateObserverList(observer_source);
+}
+
+void SyncableSandboxMountPointProvider::AddFileChangeObserver(
+    fileapi::FileSystemType type,
+    fileapi::FileChangeObserver* observer,
+    base::SequencedTaskRunner* task_runner) {
+  DCHECK(CanHandleType(type));
+  if (type == fileapi::kFileSystemTypeSyncableForInternalSync) {
+    fileapi::SandboxMountPointProvider::AddFileChangeObserver(
+        type, observer, task_runner);
+    return;
+  }
+
+  fileapi::ChangeObserverList* list = &syncable_change_observers_;
+  fileapi::ChangeObserverList::Source observer_source = list->source();
+  observer_source.AddObserver(observer, task_runner);
+  *list = fileapi::ChangeObserverList(observer_source);
+}
+
+// static
+SyncableSandboxMountPointProvider*
+SyncableSandboxMountPointProvider::GetProvider(
+    const fileapi::FileSystemContext* file_system_context) {
+  return static_cast<SyncableSandboxMountPointProvider*>(
+      file_system_context->GetMountPointProvider(
+          fileapi::kFileSystemTypeSyncable));
+}
+
+void SyncableSandboxMountPointProvider::set_change_tracker(
+    scoped_ptr<LocalFileChangeTracker> tracker) {
+  DCHECK(!change_tracker_.get());
+  DCHECK(tracker.get());
+  change_tracker_ = tracker.Pass();
+  AddFileUpdateObserver(fileapi::kFileSystemTypeSyncable,
+                        change_tracker_.get(),
+                        file_task_runner_);
+  AddFileChangeObserver(fileapi::kFileSystemTypeSyncable,
+                        change_tracker_.get(),
+                        file_task_runner_);
+}
+
+void SyncableSandboxMountPointProvider::set_sync_context(
+    sync_file_system::LocalFileSyncContext* sync_context) {
+  sync_context_ = sync_context;
+}
+
+}  // namespace sync_file_system