SyncFS: Introduce SyncFileSystemBackend

webkit/browser/fileapi/syncable/local_file_sync_context.cc

 // 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/local_file_sync_context.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/platform_file.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/file_system_task_runners.h"
 #include "webkit/browser/fileapi/syncable/file_change.h"
 #include "webkit/browser/fileapi/syncable/local_file_change_tracker.h"
 #include "webkit/browser/fileapi/syncable/local_origin_change_observer.h"
 #include "webkit/browser/fileapi/syncable/sync_file_metadata.h"
+#include "webkit/browser/fileapi/syncable/sync_file_system_backend.h"
 #include "webkit/browser/fileapi/syncable/syncable_file_operation_runner.h"
 #include "webkit/browser/fileapi/syncable/syncable_file_system_util.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using fileapi::FileSystemContext;
 using fileapi::FileSystemFileUtil;
 using fileapi::FileSystemOperation;
 using fileapi::FileSystemOperationContext;
 using fileapi::FileSystemURL;
 using fileapi::LocalFileSystemOperation;
@@ skipping 80 matching lines @@
   if (!file_system_context->task_runners()->file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     file_system_context->task_runners()->file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::ClearChangesForURL,
                    this, make_scoped_refptr(file_system_context),
                    url, done_callback));
     return;
   }
-  DCHECK(file_system_context->change_tracker());
-  file_system_context->change_tracker()->ClearChangesForURL(url);
+
+  SyncFileSystemBackend* backend =
+      SyncFileSystemBackend::GetBackend(file_system_context);
+  DCHECK(backend);
+  DCHECK(backend->change_tracker());
+  backend->change_tracker()->ClearChangesForURL(url);
 
   // Call the completion callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE, done_callback);
 }
 
 void LocalFileSyncContext::ClearSyncFlagForURL(const FileSystemURL& url) {
   // This is initially called on UI thread and to be relayed to IO thread.
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalFileSyncContext::EnableWritingOnIOThread,
@@ skipping 162 matching lines @@
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     file_system_context->task_runners()->file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::RecordFakeLocalChange,
                    this, make_scoped_refptr(file_system_context),
                    url, change, callback));
     return;
   }
 
-  DCHECK(file_system_context->change_tracker());
-  file_system_context->change_tracker()->MarkDirtyOnDatabase(url);
-  file_system_context->change_tracker()->RecordChange(url, change);
+  SyncFileSystemBackend* backend =
+      SyncFileSystemBackend::GetBackend(file_system_context);
+  DCHECK(backend);
+  DCHECK(backend->change_tracker());
+  backend->change_tracker()->MarkDirtyOnDatabase(url);
+  backend->change_tracker()->RecordChange(url, change);
 
   // Fire the callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(callback,
                                        SYNC_STATUS_OK));
 }
 
 void LocalFileSyncContext::GetFileMetadata(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
@@ skipping 26 matching lines @@
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     file_system_context->task_runners()->file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::HasPendingLocalChanges,
                    this, make_scoped_refptr(file_system_context),
                    url, callback));
     return;
   }
 
-  DCHECK(file_system_context->change_tracker());
+  SyncFileSystemBackend* backend =
+      SyncFileSystemBackend::GetBackend(file_system_context);
+  DCHECK(backend);
+  DCHECK(backend->change_tracker());
   FileChangeList changes;
-  file_system_context->change_tracker()->GetChangesForURL(url, &changes);
+  backend->change_tracker()->GetChangesForURL(url, &changes);
 
   // Fire the callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(callback,
                                        SYNC_STATUS_OK,
                                        !changes.empty()));
 }
 
 void LocalFileSyncContext::AddOriginChangeObserver(
     LocalOriginChangeObserver* observer) {
@@ skipping 71 matching lines @@
   operation_runner_.reset();
   sync_status_.reset();
   timer_on_io_.reset();
 }
 
 void LocalFileSyncContext::InitializeFileSystemContextOnIOThread(
     const GURL& source_url,
     FileSystemContext* file_system_context) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(file_system_context);
-  if (!file_system_context->change_tracker()) {
+  SyncFileSystemBackend* backend =
+      SyncFileSystemBackend::GetBackend(file_system_context);
+  DCHECK(backend);
+  if (!backend->change_tracker()) {
     // First registers the service name.
     RegisterSyncableFileSystem();
     // Create and initialize LocalFileChangeTracker and call back this method
     // later again.
     std::set<GURL>* origins_with_changes = new std::set<GURL>;
     scoped_ptr<LocalFileChangeTracker>* tracker_ptr(
         new scoped_ptr<LocalFileChangeTracker>);
     base::PostTaskAndReplyWithResult(
         file_system_context->task_runners()->file_task_runner(),
         FROM_HERE,
@@ skipping 11 matching lines @@
   if (!operation_runner_) {
     DCHECK(!sync_status_);
     DCHECK(!timer_on_io_);
     sync_status_.reset(new LocalFileSyncStatus);
     timer_on_io_.reset(new base::OneShotTimer<LocalFileSyncContext>);
     operation_runner_.reset(new SyncableFileOperationRunner(
             kMaxConcurrentSyncableOperation,
             sync_status_.get()));
     sync_status_->AddObserver(this);
   }
-  file_system_context->set_sync_context(this);
+  backend->set_sync_context(this);
   DidInitialize(source_url, file_system_context,
                 SYNC_STATUS_OK);
 }
 
 SyncStatusCode LocalFileSyncContext::InitializeChangeTrackerOnFileThread(
     scoped_ptr<LocalFileChangeTracker>* tracker_ptr,
     FileSystemContext* file_system_context,
     std::set<GURL>* origins_with_changes) {
   DCHECK(file_system_context);
   DCHECK(tracker_ptr);
@@ skipping 21 matching lines @@
     FileSystemContext* file_system_context,
     std::set<GURL>* origins_with_changes,
     SyncStatusCode status) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(file_system_context);
   DCHECK(origins_with_changes);
   if (status != SYNC_STATUS_OK) {
     DidInitialize(source_url, file_system_context, status);
     return;
   }
-  file_system_context->SetLocalFileChangeTracker(tracker_ptr->Pass());
+
+  SyncFileSystemBackend* backend =
+      SyncFileSystemBackend::GetBackend(file_system_context);
+  DCHECK(backend);
+  backend->set_change_tracker(tracker_ptr->Pass());
 
   origins_with_pending_changes_.insert(origins_with_changes->begin(),
                                        origins_with_changes->end());
   ScheduleNotifyChangesUpdatedOnIOThread();
 
   InitializeFileSystemContextOnIOThread(source_url, file_system_context);
 }
 
 void LocalFileSyncContext::DidInitialize(
     const GURL& source_url,
     FileSystemContext* file_system_context,
     SyncStatusCode status) {
   if (!ui_task_runner_->RunsTasksOnCurrentThread()) {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::DidInitialize,
                    this, source_url,
                    make_scoped_refptr(file_system_context), status));
     return;
   }
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!ContainsKey(file_system_contexts_, file_system_context));
   DCHECK(ContainsKey(pending_initialize_callbacks_, file_system_context));
-  DCHECK(file_system_context->change_tracker());
+
+
+  SyncFileSystemBackend* backend =
+      SyncFileSystemBackend::GetBackend(file_system_context);
+  DCHECK(backend);
+  DCHECK(backend->change_tracker());
 
   file_system_contexts_.insert(file_system_context);
 
   StatusCallbackQueue& callback_queue =
       pending_initialize_callbacks_[file_system_context];
   for (StatusCallbackQueue::iterator iter = callback_queue.begin();
        iter != callback_queue.end(); ++iter) {
     ui_task_runner_->PostTask(FROM_HERE, base::Bind(*iter, status));
   }
   pending_initialize_callbacks_.erase(file_system_context);
 }
 
 void LocalFileSyncContext::GetNextURLsForSyncOnFileThread(
     FileSystemContext* file_system_context,
     std::deque<FileSystemURL>* urls) {
   DCHECK(file_system_context);
   DCHECK(file_system_context->task_runners()->file_task_runner()->
              RunsTasksOnCurrentThread());
-  DCHECK(file_system_context->change_tracker());
-  file_system_context->change_tracker()->GetNextChangedURLs(
+
+  SyncFileSystemBackend* backend =
+      SyncFileSystemBackend::GetBackend(file_system_context);
+  DCHECK(backend);
+  DCHECK(backend->change_tracker());
+  backend->change_tracker()->GetNextChangedURLs(
       urls, kMaxURLsToFetchForLocalSync);
 }
 
 void LocalFileSyncContext::TryPrepareForLocalSync(
     FileSystemContext* file_system_context,
     std::deque<FileSystemURL>* urls,
     const LocalFileSyncInfoCallback& callback) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(urls);
 
@@ skipping 50 matching lines @@
       return;
     }
     file_system_context->task_runners()->file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::DidGetWritingStatusForSync,
                    this, make_scoped_refptr(file_system_context),
                    status, url, callback));
     return;
   }
 
-  DCHECK(file_system_context->change_tracker());
+  SyncFileSystemBackend* backend =
+      SyncFileSystemBackend::GetBackend(file_system_context);
+  DCHECK(backend);
+  DCHECK(backend->change_tracker());
   FileChangeList changes;
-  file_system_context->change_tracker()->GetChangesForURL(url, &changes);
+  backend->change_tracker()->GetChangesForURL(url, &changes);
 
   base::FilePath platform_path;
   base::PlatformFileInfo file_info;
   FileSystemFileUtil* file_util = file_system_context->GetFileUtil(url.type());
   DCHECK(file_util);
   base::PlatformFileError file_error = file_util->GetFileInfo(
       make_scoped_ptr(
           new FileSystemOperationContext(file_system_context)).get(),
       url,
       &file_info,
@@ skipping 84 matching lines @@
     return;
   }
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, dest_url);
   file_system_context->operation_runner()->CopyInForeignFile(
       local_path, url_for_sync, callback);
 }
 
 }  // namespace sync_file_system