src/chrome/browser/sync_file_system/drive_backend/sync_worker.h

   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
  20 class ExtensionServiceInterface;
  21 class GURL;
  22
  23 namespace base {
  24 class ListValue;
  25 }
  26
  27 namespace drive {
  28 class DriveServiceInterface;
  29 class DriveUploaderInterface;
  30 }
  31
  32 namespace fileapi {
  33 class FileSystemURL;
  34 }
  35
  36 namespace leveldb {
  37 class Env;
  38 }
  39
  40 namespace sync_file_system {
  41
  42 class FileChange;
  43 class SyncFileMetadata;
  44
  45 namespace drive_backend {
  46
  47 class LocalToRemoteSyncer;
  48 class MetadataDatabase;
  49 class RemoteChangeProcessorOnWorker;
  50 class RemoteToLocalSyncer;
  51 class SyncEngineContext;
  52 class SyncEngineInitializer;
  53
  54 class SyncWorker : public SyncWorkerInterface,
  55                    public SyncTaskManager::Client {
  56  public:
  57   SyncWorker(const base::FilePath& base_dir,
  58              const base::WeakPtr<ExtensionServiceInterface>& extension_service,
  59              leveldb::Env* env_override);
  60
  61   virtual ~SyncWorker();
  62
  63   virtual void Initialize(scoped_ptr<SyncEngineContext> context) OVERRIDE;
  64
  65   // SyncTaskManager::Client overrides
  66   virtual void MaybeScheduleNextTask() OVERRIDE;
  67   virtual void NotifyLastOperationStatus(
  68       SyncStatusCode sync_status, bool used_network) OVERRIDE;
  69   virtual void RecordTaskLog(scoped_ptr<TaskLogger::TaskLog> task_log) OVERRIDE;
  70
  71   // SyncWorkerInterface overrides
  72   virtual void RegisterOrigin(const GURL& origin,
  73                               const SyncStatusCallback& callback) OVERRIDE;
  74   virtual void EnableOrigin(const GURL& origin,
  75                             const SyncStatusCallback& callback) OVERRIDE;
  76   virtual void DisableOrigin(const GURL& origin,
  77                              const SyncStatusCallback& callback) OVERRIDE;
  78   virtual void UninstallOrigin(const GURL& origin,
  79                                RemoteFileSyncService::UninstallFlag flag,
  80                                const SyncStatusCallback& callback) OVERRIDE;
  81   virtual void ProcessRemoteChange(const SyncFileCallback& callback) OVERRIDE;
  82   virtual void SetRemoteChangeProcessor(
  83       RemoteChangeProcessorOnWorker* remote_change_processor_on_worker)
  84       OVERRIDE;
  85   virtual RemoteServiceState GetCurrentState() const OVERRIDE;
  86   virtual void GetOriginStatusMap(
  87       const RemoteFileSyncService::StatusMapCallback& callback) OVERRIDE;
  88   virtual scoped_ptr<base::ListValue> DumpFiles(const GURL& origin) OVERRIDE;
  89   virtual scoped_ptr<base::ListValue> DumpDatabase() OVERRIDE;
  90   virtual void SetSyncEnabled(bool enabled) OVERRIDE;
  91   virtual void PromoteDemotedChanges(const base::Closure& callback) OVERRIDE;
  92   virtual void ApplyLocalChange(
  93       const FileChange& local_change,
  94       const base::FilePath& local_path,
  95       const SyncFileMetadata& local_metadata,
  96       const fileapi::FileSystemURL& url,
  97       const SyncStatusCallback& callback) OVERRIDE;
  98   virtual void ActivateService(RemoteServiceState service_state,
  99                                const std::string& description) OVERRIDE;
 100   virtual void DeactivateService(const std::string& description) OVERRIDE;
 101   virtual void DetachFromSequence() OVERRIDE;
 102   virtual void AddObserver(Observer* observer) OVERRIDE;
 103
 104  private:
 105   friend class DriveBackendSyncTest;
 106   friend class SyncWorkerTest;
 107
 108   enum AppStatus {
 109     APP_STATUS_ENABLED,
 110     APP_STATUS_DISABLED,
 111     APP_STATUS_UNINSTALLED,
 112   };
 113
 114   typedef base::hash_map<std::string, AppStatus> AppStatusMap;
 115
 116   void DoDisableApp(const std::string& app_id,
 117                     const SyncStatusCallback& callback);
 118   void DoEnableApp(const std::string& app_id,
 119                    const SyncStatusCallback& callback);
 120
 121   void PostInitializeTask();
 122   void DidInitialize(SyncEngineInitializer* initializer,
 123                      SyncStatusCode status);
 124   void UpdateRegisteredApps();
 125   static void QueryAppStatusOnUIThread(
 126       const base::WeakPtr<ExtensionServiceInterface>& extension_service_ptr,
 127       const std::vector<std::string>* app_ids,
 128       AppStatusMap* status,
 129       const base::Closure& callback);
 130   void DidQueryAppStatus(const AppStatusMap* app_status);
 131   void DidProcessRemoteChange(RemoteToLocalSyncer* syncer,
 132                               const SyncFileCallback& callback,
 133                               SyncStatusCode status);
 134   void DidApplyLocalChange(LocalToRemoteSyncer* syncer,
 135                            const SyncStatusCallback& callback,
 136                            SyncStatusCode status);
 137
 138   // Returns true if a FetchChanges task is scheduled.
 139   bool MaybeStartFetchChanges();
 140   void DidResolveConflict(SyncStatusCode status);
 141   void DidFetchChanges(SyncStatusCode status);
 142
 143   void UpdateServiceStateFromSyncStatusCode(SyncStatusCode state,
 144                                             bool used_network);
 145   void UpdateServiceState(RemoteServiceState state,
 146                           const std::string& description);
 147
 148   void CallOnIdleForTesting(const base::Closure& callback);
 149
 150   drive::DriveServiceInterface* GetDriveService();
 151   drive::DriveUploaderInterface* GetDriveUploader();
 152   MetadataDatabase* GetMetadataDatabase();
 153
 154   base::FilePath base_dir_;
 155
 156   leveldb::Env* env_override_;
 157
 158   // Sync with SyncEngine.
 159   RemoteServiceState service_state_;
 160
 161   bool should_check_conflict_;
 162   bool should_check_remote_change_;
 163   bool listing_remote_changes_;
 164   base::TimeTicks time_to_check_changes_;
 165
 166   bool sync_enabled_;
 167   base::Closure call_on_idle_callback_;
 168
 169   scoped_ptr<SyncTaskManager> task_manager_;
 170
 171   base::WeakPtr<ExtensionServiceInterface> extension_service_;
 172
 173   scoped_ptr<SyncEngineContext> context_;
 174   ObserverList<Observer> observers_;
 175
 176   base::SequenceChecker sequence_checker_;
 177
 178   base::WeakPtrFactory<SyncWorker> weak_ptr_factory_;
 179   DISALLOW_COPY_AND_ASSIGN(SyncWorker);
 180 };
 181
 182 }  // namespace drive_backend
 183 }  // namespace sync_file_system
 184
 185 #endif  // CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_SYNC_WORKER_H_