[SyncFS] Create FakeSyncWorker class

chrome/browser/sync_file_system/drive_backend/fake_sync_worker.h

 // Copyright 2014 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 CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_SYNC_WORKER_H_
-#define CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_SYNC_WORKER_H_
+#ifndef CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_FAKE_SYNC_WORKER_H_
+#define CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_FAKE_SYNC_WORKER_H_
 
+#include <map>
 #include <string>
 
-#include "base/files/file_path.h"
+#include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
-#include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
+#include "base/sequence_checker.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_worker_interface.h"
 #include "chrome/browser/sync_file_system/remote_file_sync_service.h"
 #include "chrome/browser/sync_file_system/sync_callbacks.h"
-#include "chrome/browser/sync_file_system/task_logger.h"
 #include "net/base/network_change_notifier.h"
 
 class ExtensionServiceInterface;
 class GURL;
 
 namespace base {
+class FilePath;
 class ListValue;
 }
 
 namespace drive {
 class DriveServiceInterface;
 class DriveUploaderInterface;
 }
 
 namespace fileapi {
 class FileSystemURL;
 }
 
 namespace leveldb {
 class Env;
 }
 
 namespace sync_file_system {
 
 class FileChange;
 class SyncFileMetadata;
 
 namespace drive_backend {
 
-class LocalToRemoteSyncer;
 class MetadataDatabase;
 class RemoteChangeProcessorOnWorker;
-class RemoteToLocalSyncer;
 class SyncEngineContext;
 class SyncEngineInitializer;
+class SyncTaskManager;
 
-class SyncWorker : public SyncWorkerInterface,
-                   public SyncTaskManager::Client {
+class FakeSyncWorker : public SyncWorkerInterface {
  public:
-  SyncWorker(const base::FilePath& base_dir,
-             const base::WeakPtr<ExtensionServiceInterface>& extension_service,
-             scoped_ptr<SyncEngineContext> sync_engine_context,
-             leveldb::Env* env_override);
+  FakeSyncWorker(
+      const base::FilePath& base_dir,
+      scoped_ptr<SyncEngineContext> sync_engine_context,
+      leveldb::Env* env_override);
+  virtual ~FakeSyncWorker();
 
-  virtual ~SyncWorker();
-
+  // Initializes SyncWorkerInterface after constructions of some member classes.
   virtual void Initialize() OVERRIDE;
 
-  // SyncTaskManager::Client overrides
-  virtual void MaybeScheduleNextTask() OVERRIDE;
-  virtual void NotifyLastOperationStatus(
-      SyncStatusCode sync_status, bool used_network) OVERRIDE;
-  virtual void RecordTaskLog(scoped_ptr<TaskLogger::TaskLog> task_log) OVERRIDE;
-
-  // SyncWorkerInterface overrides
+  // See RemoteFileSyncService for the details.

[nhiroki, 2014/06/12 08:00:08]

I think you don't have to repeat these comments written in SyncWorkerInterface.
How about putting "// SyncWorkerInterface overrides." instead?

[peria, 2014/06/12 10:49:30]

Done.

   virtual void RegisterOrigin(const GURL& origin,
                               const SyncStatusCallback& callback) OVERRIDE;
   virtual void EnableOrigin(const GURL& origin,
                             const SyncStatusCallback& callback) OVERRIDE;
   virtual void DisableOrigin(const GURL& origin,
                              const SyncStatusCallback& callback) OVERRIDE;
-  virtual void UninstallOrigin(const GURL& origin,
-                               RemoteFileSyncService::UninstallFlag flag,
-                               const SyncStatusCallback& callback) OVERRIDE;
+  virtual void UninstallOrigin(
+      const GURL& origin,
+      RemoteFileSyncService::UninstallFlag flag,
+      const SyncStatusCallback& callback) OVERRIDE;
   virtual void ProcessRemoteChange(const SyncFileCallback& callback) OVERRIDE;
   virtual void SetRemoteChangeProcessor(
       RemoteChangeProcessorOnWorker* remote_change_processor_on_worker)
       OVERRIDE;
   virtual RemoteServiceState GetCurrentState() const OVERRIDE;
   virtual void GetOriginStatusMap(
       const RemoteFileSyncService::StatusMapCallback& callback) OVERRIDE;
   virtual scoped_ptr<base::ListValue> DumpFiles(const GURL& origin) OVERRIDE;
   virtual scoped_ptr<base::ListValue> DumpDatabase() OVERRIDE;
   virtual void SetSyncEnabled(bool enabled) OVERRIDE;
   virtual void PromoteDemotedChanges() OVERRIDE;
 
+  // See LocalChangeProcessor for the details.
   virtual void ApplyLocalChange(
       const FileChange& local_change,
       const base::FilePath& local_path,
       const SyncFileMetadata& local_metadata,
       const fileapi::FileSystemURL& url,
       const SyncStatusCallback& callback) OVERRIDE;
 
+  // See drive::DriveNotificationObserver for the details.
   virtual void OnNotificationReceived() OVERRIDE;
 
+  // See drive::DriveServiceObserver for the details.
   virtual void OnReadyToSendRequests(const std::string& account_id) OVERRIDE;
   virtual void OnRefreshTokenInvalid() OVERRIDE;
 
+  // See net::NetworkChangeNotifier::NetworkChangeObserver for the details.
   virtual void OnNetworkChanged(
       net::NetworkChangeNotifier::ConnectionType type) OVERRIDE;
 
   virtual drive::DriveServiceInterface* GetDriveService() OVERRIDE;
   virtual drive::DriveUploaderInterface* GetDriveUploader() OVERRIDE;
   virtual MetadataDatabase* GetMetadataDatabase() OVERRIDE;
   virtual SyncTaskManager* GetSyncTaskManager() OVERRIDE;
 
   virtual void DetachFromSequence() OVERRIDE;
 
   virtual void AddObserver(Observer* observer) OVERRIDE;
 
+  void UpdateServiceStateForTesting(RemoteServiceState state,
+                                    const std::string& description,
+                                    const base::Closure& closure);
+
  private:
-  friend class DriveBackendSyncTest;
-  friend class SyncWorkerTest;
+  typedef std::map<GURL, bool> StatusMap;
 
-  enum AppStatus {
-    APP_STATUS_ENABLED,
-    APP_STATUS_DISABLED,
-    APP_STATUS_UNINSTALLED,
-  };
-
-  typedef base::hash_map<std::string, AppStatus> AppStatusMap;
-
-  // SyncWorkerInterface overrides.
   // TODO(peria): Remove this interface after making FakeSyncWorker class.
   virtual void SetHasRefreshToken(bool has_refresh_token) OVERRIDE;
 
-  void DoDisableApp(const std::string& app_id,
-                    const SyncStatusCallback& callback);
-  void DoEnableApp(const std::string& app_id,
-                   const SyncStatusCallback& callback);
-
-  void PostInitializeTask();
-  void DidInitialize(SyncEngineInitializer* initializer,
-                     SyncStatusCode status);
-  void UpdateRegisteredApps();
-  static void QueryAppStatusOnUIThread(
-      const base::WeakPtr<ExtensionServiceInterface>& extension_service_ptr,
-      const std::vector<std::string>* app_ids,
-      AppStatusMap* status,
-      const base::Closure& callback);
-  void DidQueryAppStatus(const AppStatusMap* app_status);
-  void DidProcessRemoteChange(RemoteToLocalSyncer* syncer,
-                              const SyncFileCallback& callback,
-                              SyncStatusCode status);
-  void DidApplyLocalChange(LocalToRemoteSyncer* syncer,
-                           const SyncStatusCallback& callback,
-                           SyncStatusCode status);
-
-  void MaybeStartFetchChanges();
-  void DidResolveConflict(SyncStatusCode status);
-  void DidFetchChanges(SyncStatusCode status);
-
-  void UpdateServiceStateFromSyncStatusCode(SyncStatusCode state,
-                                            bool used_network);
   void UpdateServiceState(RemoteServiceState state,
                           const std::string& description);
+  void DidCreateMetadataDatabase(
+      SyncStatusCode status,
+      scoped_ptr<MetadataDatabase> metadata_database);
 
-  base::FilePath base_dir_;
-
+  const base::FilePath base_dir_;
+  scoped_ptr<SyncEngineContext> sync_engine_context_;
   leveldb::Env* env_override_;
 
-  // Sync with SyncEngine.
-  RemoteServiceState service_state_;
-
-  bool should_check_conflict_;
-  bool should_check_remote_change_;
-  bool listing_remote_changes_;
-  base::TimeTicks time_to_check_changes_;
-
   bool sync_enabled_;
-  ConflictResolutionPolicy default_conflict_resolution_policy_;
+  StatusMap status_map_;
+  bool has_refresh_token_;
   bool network_available_;
 
-  scoped_ptr<SyncTaskManager> task_manager_;
-
-  base::WeakPtr<ExtensionServiceInterface> extension_service_;
-
-  scoped_ptr<SyncEngineContext> context_;
   ObserverList<Observer> observers_;
-
-  bool has_refresh_token_;
-
   base::SequenceChecker sequence_checker_;
 
-  base::WeakPtrFactory<SyncWorker> weak_ptr_factory_;
-  DISALLOW_COPY_AND_ASSIGN(SyncWorker);
+  base::WeakPtrFactory<FakeSyncWorker> weak_ptr_factory_;
+  DISALLOW_COPY_AND_ASSIGN(FakeSyncWorker);
 };
 
 }  // namespace drive_backend
 }  // namespace sync_file_system
 
-#endif  // CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_SYNC_WORKER_H_
+#endif  // CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_FAKE_SYNC_WORKER_H_