Wire up Syncable operation runner to the local file sync context

webkit/fileapi/syncable/local_file_sync_context.cc

 // Copyright (c) 2012 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/fileapi/syncable/local_file_sync_context.h"
 
 #include "base/bind.h"
-#include "base/callback.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_task_runners.h"
+#include "webkit/fileapi/syncable/file_change.h"
 #include "webkit/fileapi/syncable/local_file_change_tracker.h"
 #include "webkit/fileapi/syncable/syncable_file_operation_runner.h"
 
 namespace fileapi {
 
 LocalFileSyncContext::LocalFileSyncContext(
     base::SingleThreadTaskRunner* ui_task_runner,
     base::SingleThreadTaskRunner* io_task_runner)
     : ui_task_runner_(ui_task_runner),
-      io_task_runner_(io_task_runner) {
+      io_task_runner_(io_task_runner),
+      shutdown_on_ui_(false) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 }
 
 void LocalFileSyncContext::MaybeInitializeFileSystemContext(
     const GURL& source_url,
     FileSystemContext* file_system_context,
     const StatusCallback& callback) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   if (ContainsKey(file_system_contexts_, file_system_context)) {
     DCHECK(!ContainsKey(origin_to_contexts_, source_url) ||
@@ skipping 12 matching lines @@
     return;
 
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalFileSyncContext::InitializeFileSystemContextOnIOThread,
                  this, source_url, make_scoped_refptr(file_system_context)));
 }
 
 void LocalFileSyncContext::ShutdownOnUIThread() {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  shutdown_on_ui_ = true;
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalFileSyncContext::ShutdownOnIOThread,
                  this));
 }
 
+void LocalFileSyncContext::PrepareForSync(
+    const FileSystemURL& url,
+    const ChangeListCallback& callback) {
+  // This is initially called on UI thread and to be relayed to IO thread.
+  if (!io_task_runner_->RunsTasksOnCurrentThread()) {
+    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+    io_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&LocalFileSyncContext::PrepareForSync, this, url, callback));
+    return;
+  }
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  if (sync_status()->IsWriting(url)) {
+    ui_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(callback, SYNC_STATUS_FILE_BUSY, FileChangeList()));
+    return;
+  }
+  sync_status()->StartSyncing(url);
+  ui_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&LocalFileSyncContext::DidDisabledWritesForPrepareForSync,
+                 this, url, callback));
+}
+
+void LocalFileSyncContext::RegisterURLForWaitingSync(
+    const FileSystemURL& url,
+    const URLCallback& on_syncable_callback) {
+  // This is initially called on UI thread and to be relayed to IO thread.
+  if (!io_task_runner_->RunsTasksOnCurrentThread()) {
+    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+    io_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&LocalFileSyncContext::RegisterURLForWaitingSync,
+                   this, url, on_syncable_callback));
+    return;
+  }
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  if (sync_status()->IsWritable(url)) {
+    // No need to register; fire the callback now.
+    ui_task_runner_->PostTask(FROM_HERE, base::Bind(on_syncable_callback, url));
+    return;
+  }
+  DCHECK(url_syncable_callback_.is_null());
+  url_waiting_sync_on_io_ = url;
+  url_syncable_callback_ = on_syncable_callback;

[tzik, 2012/10/24 03:45:13]

Could you support multiple URL to wait?
Remote side might change its URL for next sync if new change arrived for the
URL. In that case, it calls RegisterURLForWaitingSync with another URL.

[kinuko, 2012/10/24 09:39:56]

Does it work if we simply replace the URL to wait for or will we really want to
wait on multiple URLs?  (I don't want to allow having too many URLs to wait on,
so if we make it std::set or so probably I'd want to have some upper limit...
and making it work like LRU?)

[kinuko, 2012/10/24 14:07:05]

For now I changed the code to simply replace the URL.  Let me hear your
comments.

[tzik, 2012/10/25 08:14:42]

Sorry for delayed comment, the replacement seems to works.

+}
+
 base::WeakPtr<SyncableFileOperationRunner>
 LocalFileSyncContext::operation_runner() const {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (operation_runner_.get())
     return operation_runner_->AsWeakPtr();
   return base::WeakPtr<SyncableFileOperationRunner>();
 }
 
+LocalFileSyncStatus* LocalFileSyncContext::sync_status() const {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  return sync_status_.get();
+}
+
+void LocalFileSyncContext::OnSyncEnabled(const FileSystemURL& url) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  if (url_syncable_callback_.is_null() ||
+      sync_status()->IsWriting(url_waiting_sync_on_io_))
+    return;
+  // TODO(kinuko): may want to check how many pending tasks we have.
+  sync_status()->StartSyncing(url_waiting_sync_on_io_);
+  ui_task_runner_->PostTask(FROM_HERE,
+                            base::Bind(url_syncable_callback_,
+                                       url_waiting_sync_on_io_));
+  url_syncable_callback_.Reset();
+}
+
+void LocalFileSyncContext::OnWriteEnabled(const FileSystemURL& url) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+}
+
 LocalFileSyncContext::~LocalFileSyncContext() {
 }
 
 void LocalFileSyncContext::ShutdownOnIOThread() {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   operation_runner_.reset();
 }
 
 void LocalFileSyncContext::InitializeFileSystemContextOnIOThread(
     const GURL& source_url,
@@ skipping 10 matching lines @@
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::InitializeChangeTrackerOnFileThread,
                    this, tracker_ptr,
                    make_scoped_refptr(file_system_context)),
         base::Bind(&LocalFileSyncContext::DidInitializeChangeTracker, this,
                    base::Owned(tracker_ptr),
                    source_url,
                    make_scoped_refptr(file_system_context)));
     return;
   }
-  if (!operation_runner_.get())
-    operation_runner_.reset(new SyncableFileOperationRunner);
+  if (!operation_runner_.get()) {
+    DCHECK(!sync_status_.get());
+    sync_status_.reset(new LocalFileSyncStatus);
+    operation_runner_.reset(new SyncableFileOperationRunner(
+            kMaxConcurrentSyncableOperation,
+            sync_status_.get()));
+    sync_status_->AddObserver(this);
+  }
   file_system_context->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) {
   DCHECK(file_system_context);
   DCHECK(tracker_ptr);
   tracker_ptr->reset(new LocalFileChangeTracker(
@@ skipping 40 matching lines @@
 
   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::DidDisabledWritesForPrepareForSync(
+    const FileSystemURL& url,
+    const ChangeListCallback& callback) {
+  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  if (shutdown_on_ui_) {
+    callback.Run(SYNC_STATUS_ABORT, FileChangeList());
+    return;
+  }
+  DCHECK(ContainsKey(origin_to_contexts_, url.origin()));
+  FileSystemContext* context = origin_to_contexts_[url.origin()];
+  DCHECK(context);
+  DCHECK(context->change_tracker());
+
+  FileChangeList changes;
+  context->change_tracker()->GetChangesForURL(url, &changes);
+  callback.Run(SYNC_STATUS_OK, changes);
+}
+
 }  // namespace fileapi