sync_worker.h revision f8ee788a64d60abd8f2d742a5fdedde054ecd910 
1// Copyright 2014 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#ifndef CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_SYNC_WORKER_H_
6#define CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_SYNC_WORKER_H_
7
8#include <string>
9
10#include "base/files/file_path.h"
11#include "base/memory/scoped_ptr.h"
12#include "base/memory/weak_ptr.h"
13#include "base/observer_list.h"
14#include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
15#include "chrome/browser/sync_file_system/drive_backend/sync_worker_interface.h"
16#include "chrome/browser/sync_file_system/remote_file_sync_service.h"
17#include "chrome/browser/sync_file_system/sync_callbacks.h"
18#include "chrome/browser/sync_file_system/task_logger.h"
19#include "net/base/network_change_notifier.h"
20
21class ExtensionServiceInterface;
22class GURL;
23
24namespace base {
25class ListValue;
26}
27
28namespace drive {
29class DriveServiceInterface;
30class DriveUploaderInterface;
31}
32
33namespace fileapi {
34class FileSystemURL;
35}
36
37namespace leveldb {
38class Env;
39}
40
41namespace sync_file_system {
42
43class FileChange;
44class SyncFileMetadata;
45
46namespace drive_backend {
47
48class LocalToRemoteSyncer;
49class MetadataDatabase;
50class RemoteChangeProcessorOnWorker;
51class RemoteToLocalSyncer;
52class SyncEngineContext;
53class SyncEngineInitializer;
54
55class SyncWorker : public SyncWorkerInterface,
56                   public SyncTaskManager::Client {
57 public:
58  SyncWorker(const base::FilePath& base_dir,
59             const base::WeakPtr<ExtensionServiceInterface>& extension_service,
60             leveldb::Env* env_override);
61
62  virtual ~SyncWorker();
63
64  virtual void Initialize(scoped_ptr<SyncEngineContext> context) OVERRIDE;
65
66  // SyncTaskManager::Client overrides
67  virtual void MaybeScheduleNextTask() OVERRIDE;
68  virtual void NotifyLastOperationStatus(
69      SyncStatusCode sync_status, bool used_network) OVERRIDE;
70  virtual void RecordTaskLog(scoped_ptr<TaskLogger::TaskLog> task_log) OVERRIDE;
71
72  // SyncWorkerInterface overrides
73  virtual void RegisterOrigin(const GURL& origin,
74                              const SyncStatusCallback& callback) OVERRIDE;
75  virtual void EnableOrigin(const GURL& origin,
76                            const SyncStatusCallback& callback) OVERRIDE;
77  virtual void DisableOrigin(const GURL& origin,
78                             const SyncStatusCallback& callback) OVERRIDE;
79  virtual void UninstallOrigin(const GURL& origin,
80                               RemoteFileSyncService::UninstallFlag flag,
81                               const SyncStatusCallback& callback) OVERRIDE;
82  virtual void ProcessRemoteChange(const SyncFileCallback& callback) OVERRIDE;
83  virtual void SetRemoteChangeProcessor(
84      RemoteChangeProcessorOnWorker* remote_change_processor_on_worker)
85      OVERRIDE;
86  virtual RemoteServiceState GetCurrentState() const OVERRIDE;
87  virtual void GetOriginStatusMap(
88      const RemoteFileSyncService::StatusMapCallback& callback) OVERRIDE;
89  virtual scoped_ptr<base::ListValue> DumpFiles(const GURL& origin) OVERRIDE;
90  virtual scoped_ptr<base::ListValue> DumpDatabase() OVERRIDE;
91  virtual void SetSyncEnabled(bool enabled) OVERRIDE;
92  virtual void PromoteDemotedChanges() OVERRIDE;
93
94  virtual void ApplyLocalChange(
95      const FileChange& local_change,
96      const base::FilePath& local_path,
97      const SyncFileMetadata& local_metadata,
98      const fileapi::FileSystemURL& url,
99      const SyncStatusCallback& callback) OVERRIDE;
100
101  virtual void OnNotificationReceived() OVERRIDE;
102
103  virtual void OnReadyToSendRequests() OVERRIDE;
104  virtual void OnRefreshTokenInvalid() OVERRIDE;
105
106  virtual void OnNetworkChanged(
107      net::NetworkChangeNotifier::ConnectionType type) OVERRIDE;
108
109  virtual drive::DriveServiceInterface* GetDriveService() OVERRIDE;
110  virtual drive::DriveUploaderInterface* GetDriveUploader() OVERRIDE;
111  virtual MetadataDatabase* GetMetadataDatabase() OVERRIDE;
112  virtual SyncTaskManager* GetSyncTaskManager() OVERRIDE;
113
114  virtual void DetachFromSequence() OVERRIDE;
115
116  virtual void AddObserver(Observer* observer) OVERRIDE;
117
118 private:
119  friend class DriveBackendSyncTest;
120  friend class SyncWorkerTest;
121
122  enum AppStatus {
123    APP_STATUS_ENABLED,
124    APP_STATUS_DISABLED,
125    APP_STATUS_UNINSTALLED,
126  };
127
128  typedef base::hash_map<std::string, AppStatus> AppStatusMap;
129
130  // SyncWorkerInterface overrides.
131  // TODO(peria): Remove this interface after making FakeSyncWorker class.
132  virtual void SetHasRefreshToken(bool has_refresh_token) OVERRIDE;
133
134  void DoDisableApp(const std::string& app_id,
135                    const SyncStatusCallback& callback);
136  void DoEnableApp(const std::string& app_id,
137                   const SyncStatusCallback& callback);
138
139  void PostInitializeTask();
140  void DidInitialize(SyncEngineInitializer* initializer,
141                     SyncStatusCode status);
142  void UpdateRegisteredApps();
143  static void QueryAppStatusOnUIThread(
144      const base::WeakPtr<ExtensionServiceInterface>& extension_service_ptr,
145      const std::vector<std::string>* app_ids,
146      AppStatusMap* status,
147      const base::Closure& callback);
148  void DidQueryAppStatus(const AppStatusMap* app_status);
149  void DidProcessRemoteChange(RemoteToLocalSyncer* syncer,
150                              const SyncFileCallback& callback,
151                              SyncStatusCode status);
152  void DidApplyLocalChange(LocalToRemoteSyncer* syncer,
153                           const SyncStatusCallback& callback,
154                           SyncStatusCode status);
155
156  void MaybeStartFetchChanges();
157  void DidResolveConflict(SyncStatusCode status);
158  void DidFetchChanges(SyncStatusCode status);
159
160  void UpdateServiceStateFromSyncStatusCode(SyncStatusCode state,
161                                            bool used_network);
162  void UpdateServiceState(RemoteServiceState state,
163                          const std::string& description);
164
165  base::FilePath base_dir_;
166
167  leveldb::Env* env_override_;
168
169  // Sync with SyncEngine.
170  RemoteServiceState service_state_;
171
172  bool should_check_conflict_;
173  bool should_check_remote_change_;
174  bool listing_remote_changes_;
175  base::TimeTicks time_to_check_changes_;
176
177  bool sync_enabled_;
178  ConflictResolutionPolicy default_conflict_resolution_policy_;
179  bool network_available_;
180
181  scoped_ptr<SyncTaskManager> task_manager_;
182
183  base::WeakPtr<ExtensionServiceInterface> extension_service_;
184
185  scoped_ptr<SyncEngineContext> context_;
186  ObserverList<Observer> observers_;
187
188  bool has_refresh_token_;
189
190  base::SequenceChecker sequence_checker_;
191
192  base::WeakPtrFactory<SyncWorker> weak_ptr_factory_;
193  DISALLOW_COPY_AND_ASSIGN(SyncWorker);
194};
195
196}  // namespace drive_backend
197}  // namespace sync_file_system
198
199#endif  // CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_SYNC_WORKER_H_
200