Add OnSyncEnabled/OnWriteEnabled notification handling to operation runner

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/local_file_change_tracker.h"
 #include "webkit/fileapi/syncable/syncable_file_operation_runner.h"
 
 namespace fileapi {
 
+namespace {
+const int kMaxConcurrentSyncableOperation = 3;
+}  // namespace
+
 LocalFileSyncContext::LocalFileSyncContext(
     base::SingleThreadTaskRunner* ui_task_runner,
     base::SingleThreadTaskRunner* io_task_runner)
     : ui_task_runner_(ui_task_runner),
       io_task_runner_(io_task_runner) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 }
 
 void LocalFileSyncContext::MaybeInitializeFileSystemContext(
     const GURL& source_url,
@@ skipping 31 matching lines @@
 }
 
 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();
+}
+
 LocalFileSyncContext::~LocalFileSyncContext() {
 }
 
 void LocalFileSyncContext::ShutdownOnIOThread() {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   operation_runner_.reset();
+  sync_status_.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()) {
     // Create and initialize LocalFileChangeTracker and call back this method
     // later again.
     scoped_ptr<LocalFileChangeTracker>* tracker_ptr(
         new scoped_ptr<LocalFileChangeTracker>);
     base::PostTaskAndReplyWithResult(
         file_system_context->task_runners()->file_task_runner(),
         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()));
+  }
   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 41 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);
 }
 
 }  // namespace fileapi