sync_engine.cc revision 58537e28ecd584eab876aee8be7156509866d23a 
1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/sync_file_system/drive_backend/sync_engine.h"
6
7#include "base/bind.h"
8#include "base/values.h"
9#include "chrome/browser/drive/drive_api_service.h"
10#include "chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.h"
11#include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
12#include "chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.h"
13#include "chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.h"
14#include "chrome/browser/sync_file_system/sync_task.h"
15
16namespace sync_file_system {
17namespace drive_backend {
18
19namespace {
20// TODO(tzik): Move this to separate file and consolidate with
21// DriveMetadataStore::kDatabaseName.
22base::FilePath::CharType kDatabaseName[] = FILE_PATH_LITERAL("DriveMetadata");
23}  // namespace
24
25SyncEngine::SyncEngine(
26    const base::FilePath& base_dir,
27    base::SequencedTaskRunner* task_runner,
28    scoped_ptr<drive::DriveAPIService> drive_api,
29    drive::DriveNotificationManager* notification_manager,
30    ExtensionService* extension_service)
31    : base_dir_(base_dir),
32      task_runner_(task_runner),
33      drive_api_(drive_api.Pass()),
34      notification_manager_(notification_manager),
35      extension_service_(extension_service),
36      weak_ptr_factory_(this),
37      task_manager_(weak_ptr_factory_.GetWeakPtr()) {
38}
39
40SyncEngine::~SyncEngine() {
41  NOTIMPLEMENTED();
42}
43
44void SyncEngine::Initialize() {
45  task_manager_.Initialize(SYNC_STATUS_OK);
46
47  SyncEngineInitializer* initializer =
48      new SyncEngineInitializer(task_runner_.get(),
49                                drive_api_.get(),
50                                base_dir_.Append(kDatabaseName));
51  task_manager_.ScheduleSyncTask(
52      scoped_ptr<SyncTask>(initializer),
53      base::Bind(&SyncEngine::DidInitialize, weak_ptr_factory_.GetWeakPtr(),
54                 initializer));
55}
56
57void SyncEngine::AddServiceObserver(SyncServiceObserver* observer) {
58  service_observers_.AddObserver(observer);
59}
60
61void SyncEngine::AddFileStatusObserver(FileStatusObserver* observer) {
62  file_status_observers_.AddObserver(observer);
63}
64
65void SyncEngine::RegisterOrigin(
66    const GURL& origin,
67    const SyncStatusCallback& callback) {
68  task_manager_.ScheduleTask(
69      base::Bind(&SyncEngine::DoRegisterApp,
70                 weak_ptr_factory_.GetWeakPtr(),
71                 origin.host()),
72      callback);
73}
74
75void SyncEngine::EnableOrigin(
76    const GURL& origin,
77    const SyncStatusCallback& callback) {
78  task_manager_.ScheduleTask(
79      base::Bind(&SyncEngine::DoEnableApp,
80                 weak_ptr_factory_.GetWeakPtr(),
81                 origin.host()),
82      callback);
83}
84
85void SyncEngine::DisableOrigin(
86    const GURL& origin,
87    const SyncStatusCallback& callback) {
88  task_manager_.ScheduleTask(
89      base::Bind(&SyncEngine::DoDisableApp,
90                 weak_ptr_factory_.GetWeakPtr(),
91                 origin.host()),
92      callback);
93}
94
95void SyncEngine::UninstallOrigin(
96    const GURL& origin,
97    const SyncStatusCallback& callback) {
98  task_manager_.ScheduleTask(
99      base::Bind(&SyncEngine::DoUninstallApp,
100                 weak_ptr_factory_.GetWeakPtr(),
101                 origin.host()),
102      callback);
103}
104
105void SyncEngine::ProcessRemoteChange(
106    const SyncFileCallback& callback) {
107  RemoteToLocalSyncer* syncer = new RemoteToLocalSyncer;
108  task_manager_.ScheduleSyncTask(
109      scoped_ptr<SyncTask>(syncer),
110      base::Bind(&SyncEngine::DidProcessRemoteChange,
111                 weak_ptr_factory_.GetWeakPtr(),
112                 syncer, callback));
113}
114
115void SyncEngine::SetRemoteChangeProcessor(
116    RemoteChangeProcessor* processor) {
117  remote_change_processor_ = processor;
118}
119
120LocalChangeProcessor* SyncEngine::GetLocalChangeProcessor() {
121  return this;
122}
123
124bool SyncEngine::IsConflicting(const fileapi::FileSystemURL& url) {
125  NOTIMPLEMENTED();
126  return false;
127}
128
129RemoteServiceState SyncEngine::GetCurrentState() const {
130  NOTIMPLEMENTED();
131  return REMOTE_SERVICE_OK;
132}
133
134void SyncEngine::GetOriginStatusMap(OriginStatusMap* status_map) {
135  DCHECK(status_map);
136  status_map->clear();
137  NOTIMPLEMENTED();
138}
139
140scoped_ptr<base::ListValue> SyncEngine::DumpFiles(const GURL& origin) {
141  NOTIMPLEMENTED();
142  return make_scoped_ptr(new base::ListValue());
143}
144
145void SyncEngine::SetSyncEnabled(bool enabled) {
146  NOTIMPLEMENTED();
147}
148
149SyncStatusCode SyncEngine::SetConflictResolutionPolicy(
150    ConflictResolutionPolicy policy) {
151  NOTIMPLEMENTED();
152  return SYNC_STATUS_OK;
153}
154
155ConflictResolutionPolicy
156SyncEngine::GetConflictResolutionPolicy() const {
157  NOTIMPLEMENTED();
158  return CONFLICT_RESOLUTION_POLICY_LAST_WRITE_WIN;
159}
160
161void SyncEngine::GetRemoteVersions(
162    const fileapi::FileSystemURL& url,
163    const RemoteVersionsCallback& callback) {
164  NOTIMPLEMENTED();
165}
166
167void SyncEngine::DownloadRemoteVersion(
168    const fileapi::FileSystemURL& url,
169    const std::string& version_id,
170    const DownloadVersionCallback& callback) {
171  NOTIMPLEMENTED();
172}
173
174void SyncEngine::ApplyLocalChange(
175    const FileChange& local_file_change,
176    const base::FilePath& local_file_path,
177    const SyncFileMetadata& local_file_metadata,
178    const fileapi::FileSystemURL& url,
179    const SyncStatusCallback& callback) {
180  LocalToRemoteSyncer* syncer = new LocalToRemoteSyncer;
181  task_manager_.ScheduleSyncTask(
182      scoped_ptr<SyncTask>(syncer),
183      base::Bind(&SyncEngine::DidApplyLocalChange,
184                 weak_ptr_factory_.GetWeakPtr(),
185                 syncer, callback));
186}
187
188void SyncEngine::MaybeScheduleNextTask() {
189  NOTIMPLEMENTED();
190}
191
192void SyncEngine::NotifyLastOperationStatus(SyncStatusCode sync_status) {
193  NOTIMPLEMENTED();
194}
195
196void SyncEngine::OnNotificationReceived() {
197  NOTIMPLEMENTED();
198}
199
200void SyncEngine::OnPushNotificationEnabled(bool enabled) {
201  NOTIMPLEMENTED();
202}
203
204void SyncEngine::DoRegisterApp(const std::string& app_id,
205                               const SyncStatusCallback& callback) {
206  NOTIMPLEMENTED();
207}
208
209void SyncEngine::DoDisableApp(const std::string& app_id,
210                              const SyncStatusCallback& callback) {
211  NOTIMPLEMENTED();
212}
213
214void SyncEngine::DoEnableApp(const std::string& app_id,
215                             const SyncStatusCallback& callback) {
216  NOTIMPLEMENTED();
217}
218
219void SyncEngine::DoUninstallApp(const std::string& app_id,
220                                const SyncStatusCallback& callback) {
221  NOTIMPLEMENTED();
222}
223
224
225void SyncEngine::DidInitialize(SyncEngineInitializer* initializer,
226                               SyncStatusCode status) {
227  NOTIMPLEMENTED();
228}
229
230void SyncEngine::DidProcessRemoteChange(RemoteToLocalSyncer* syncer,
231                                        const SyncFileCallback& callback,
232                                        SyncStatusCode status) {
233  NOTIMPLEMENTED();
234}
235
236void SyncEngine::DidApplyLocalChange(LocalToRemoteSyncer* syncer,
237                                     const SyncStatusCallback& callback,
238                                     SyncStatusCode status) {
239  NOTIMPLEMENTED();
240}
241
242}  // namespace drive_backend
243}  // namespace sync_file_system
244