Add LocalFileSyncContext class which wires up profile-owned service and FileSystemContext(s)

webkit/fileapi/file_system_context.h

 // 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.
 
 #ifndef WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 #define WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 
 #include <map>
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/fileapi_export.h"
 #include "webkit/fileapi/task_runner_bound_observer_list.h"
+#include "webkit/fileapi/syncable/syncable_context.h"
 #include "webkit/quota/special_storage_policy.h"
 
 class FilePath;
 
 namespace quota {
 class QuotaManagerProxy;
 }
 
 namespace webkit_blob {
 class FileStreamReader;
 }
 
 namespace fileapi {
 
 class ExternalFileSystemMountPointProvider;
 class FileSystemFileUtil;
 class FileSystemMountPointProvider;
 class FileSystemOperation;
 class FileSystemOptions;
 class FileSystemQuotaUtil;
 class FileSystemTaskRunners;
 class FileSystemURL;
 class IsolatedMountPointProvider;
 class LocalFileChangeTracker;
 class SandboxMountPointProvider;
+class SyncableContext;

[tzik, 2012/10/11 09:42:53]

looks not needed.

[kinuko, 2012/10/11 10:13:02]

Removed the include on line 19

 
 struct DefaultContextDeleter;
 
 // This class keeps and provides a file system context for FileSystem API.
 // An instance of this class is created and owned by profile.
 class FILEAPI_EXPORT FileSystemContext
     : public base::RefCountedThreadSafe<FileSystemContext,
                                         DefaultContextDeleter> {
  public:
   // task_runners->file_task_runner() is used as default TaskRunner.
@@ skipping 104 matching lines @@
   // Register a filesystem provider. The ownership of |provider| is
   // transferred to this instance.
   void RegisterMountPointProvider(FileSystemType type,
                                   FileSystemMountPointProvider* provider);
 
   FileSystemTaskRunners* task_runners() { return task_runners_.get(); }
 
   LocalFileChangeTracker* change_tracker() { return change_tracker_.get(); }
   void SetLocalFileChangeTracker(scoped_ptr<LocalFileChangeTracker> tracker);
 
+  SyncableContext* syncable_context() { return syncable_context_.get(); }
+  void set_syncable_context(SyncableContext* syncable_context) {
+    syncable_context_ = syncable_context;
+  }
+
   const FilePath& partition_path() const { return partition_path_; }
 
  private:
   friend struct DefaultContextDeleter;
   friend class base::DeleteHelper<FileSystemContext>;
   friend class base::RefCountedThreadSafe<FileSystemContext,
                                           DefaultContextDeleter>;
   ~FileSystemContext();
 
   void DeleteOnCorrectThread() const;
 
   scoped_ptr<FileSystemTaskRunners> task_runners_;
 
   scoped_refptr<quota::QuotaManagerProxy> quota_manager_proxy_;
 
   // Regular mount point providers.
   scoped_ptr<SandboxMountPointProvider> sandbox_provider_;
   scoped_ptr<IsolatedMountPointProvider> isolated_provider_;
   scoped_ptr<ExternalFileSystemMountPointProvider> external_provider_;
 
   // Registered mount point providers.
   std::map<FileSystemType, FileSystemMountPointProvider*> provider_map_;
 
   // The base path of the storage partition for this context.
   const FilePath& partition_path_;
 
   // For syncable file systems.
   scoped_ptr<LocalFileChangeTracker> change_tracker_;
+  scoped_refptr<SyncableContext> syncable_context_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FileSystemContext);
 };
 
 struct DefaultContextDeleter {
   static void Destruct(const FileSystemContext* context) {
     context->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_