[SyncFS] Split SyncEngine and SyncEngineContext

chrome/browser/sync_file_system/drive_backend/conflict_resolver_unittest.cc

 // Copyright 2013 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.
 
 #include "chrome/browser/sync_file_system/drive_backend/conflict_resolver.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 26 matching lines @@
 namespace {
 
 fileapi::FileSystemURL URL(const GURL& origin,
                            const std::string& path) {
   return CreateSyncableFileSystemURL(
       origin, base::FilePath::FromUTF8Unsafe(path));
 }
 
 }  // namespace
 
-class ConflictResolverTest : public testing::Test,
-                             public SyncEngineContext {
+class ConflictResolverTest : public testing::Test {
  public:
   typedef FakeRemoteChangeProcessor::URLToFileChangesMap URLToFileChangesMap;
 
   ConflictResolverTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
   virtual ~ConflictResolverTest() {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
 
-    fake_drive_service_.reset(new FakeDriveServiceWrapper);
-    ASSERT_TRUE(fake_drive_service_->LoadAccountMetadataForWapi(
+    scoped_ptr<FakeDriveServiceWrapper>
+        fake_drive_service(new FakeDriveServiceWrapper);
+    ASSERT_TRUE(fake_drive_service->LoadAccountMetadataForWapi(
         "sync_file_system/account_metadata.json"));
-    ASSERT_TRUE(fake_drive_service_->LoadResourceListForWapi(
+    ASSERT_TRUE(fake_drive_service->LoadResourceListForWapi(
         "gdata/empty_feed.json"));
 
-    drive_uploader_.reset(new FakeDriveUploader(fake_drive_service_.get()));
+    scoped_ptr<drive::DriveUploaderInterface>
+        drive_uploader(new FakeDriveUploader(fake_drive_service.get()));
     fake_drive_helper_.reset(new FakeDriveServiceHelper(
-        fake_drive_service_.get(), drive_uploader_.get(),
-        kSyncRootFolderTitle));
+        fake_drive_service.get(), drive_uploader.get(), kSyncRootFolderTitle));
     fake_remote_change_processor_.reset(new FakeRemoteChangeProcessor);
 
+    context_.reset(new SyncEngineContext(
+        fake_drive_service.PassAs<drive::DriveServiceInterface>(),
+        drive_uploader.Pass(), base::MessageLoopProxy::current()));
+    context_->SetRemoteChangeProcessor(fake_remote_change_processor_.get());
+
     RegisterSyncableFileSystem();
 
     sync_task_manager_.reset(new SyncTaskManager(
         base::WeakPtr<SyncTaskManager::Client>(),
         10 /* maximum_background_task */));
     sync_task_manager_->Initialize(SYNC_STATUS_OK);
   }
 
   virtual void TearDown() OVERRIDE {
     sync_task_manager_.reset();
 
     RevokeSyncableFileSystem();
 
     fake_remote_change_processor_.reset();
-    metadata_database_.reset();
     fake_drive_helper_.reset();
-    drive_uploader_.reset();
-    fake_drive_service_.reset();
+    context_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   void InitializeMetadataDatabase() {
-    SyncEngineInitializer initializer(this,
+    SyncEngineInitializer initializer(context_.get(),
                                       base::MessageLoopProxy::current(),
-                                      fake_drive_service_.get(),
+                                      context_->GetDriveService(),
                                       database_dir_.path(),
                                       in_memory_env_.get());
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     initializer.RunSequential(CreateResultReceiver(&status));
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(SYNC_STATUS_OK, status);
-    metadata_database_ = initializer.PassMetadataDatabase();
+    context_->SetMetadataDatabase(initializer.PassMetadataDatabase());
   }
 
   void RegisterApp(const std::string& app_id,
                    const std::string& app_root_folder_id) {
     SyncStatusCode status = SYNC_STATUS_FAILED;
-    metadata_database_->RegisterApp(app_id, app_root_folder_id,
-                                    CreateResultReceiver(&status));
+    context_->GetMetadataDatabase()->RegisterApp(app_id, app_root_folder_id,
+                                                 CreateResultReceiver(&status));
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(SYNC_STATUS_OK, status);
   }
 
-  virtual drive::DriveServiceInterface* GetDriveService() OVERRIDE {
-    return fake_drive_service_.get();
-  }
-
-  virtual drive::DriveUploaderInterface* GetDriveUploader() OVERRIDE {
-    return drive_uploader_.get();
-  }
-
-  virtual MetadataDatabase* GetMetadataDatabase() OVERRIDE {
-    return metadata_database_.get();
-  }
-
-  virtual RemoteChangeProcessor* GetRemoteChangeProcessor() OVERRIDE {
-    return fake_remote_change_processor_.get();
-  }
-
-  virtual base::SequencedTaskRunner* GetBlockingTaskRunner() OVERRIDE {
-    return base::MessageLoopProxy::current().get();
-  }
-
  protected:
   std::string CreateSyncRoot() {
     std::string sync_root_folder_id;
     EXPECT_EQ(google_apis::HTTP_CREATED,
               fake_drive_helper_->AddOrphanedFolder(
                   kSyncRootFolderTitle, &sync_root_folder_id));
     return sync_root_folder_id;
   }
 
   std::string CreateRemoteFolder(const std::string& parent_folder_id,
@@ skipping 18 matching lines @@
   void CreateLocalFile(const fileapi::FileSystemURL& url) {
     fake_remote_change_processor_->UpdateLocalFileMetadata(
         url, FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                         SYNC_FILE_TYPE_FILE));
   }
 
   google_apis::GDataErrorCode AddFileToFolder(
       const std::string& parent_folder_id,
       const std::string& file_id) {
     google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
-    fake_drive_service_->AddResourceToDirectory(
+    context_->GetDriveService()->AddResourceToDirectory(
         parent_folder_id, file_id,
         CreateResultReceiver(&error));
     base::RunLoop().RunUntilIdle();
     return error;
   }
 
   int CountParents(const std::string& file_id) {
     scoped_ptr<google_apis::ResourceEntry> entry;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_helper_->GetResourceEntry(file_id, &entry));
     int count = 0;
     const ScopedVector<google_apis::Link>& links = entry->links();
     for (ScopedVector<google_apis::Link>::const_iterator itr = links.begin();
         itr != links.end(); ++itr) {
       if ((*itr)->type() == google_apis::Link::LINK_PARENT)
         ++count;
     }
     return count;
   }
 
   SyncStatusCode RunRemoteToLocalSyncer() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    scoped_ptr<RemoteToLocalSyncer> syncer(new RemoteToLocalSyncer(this));
+    scoped_ptr<RemoteToLocalSyncer> syncer(
+        new RemoteToLocalSyncer(context_.get()));
     syncer->RunSequential(CreateResultReceiver(&status));
     base::RunLoop().RunUntilIdle();
     return status;
   }
 
   SyncStatusCode RunLocalToRemoteSyncer(
       const fileapi::FileSystemURL& url,
       const FileChange& file_change) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     base::FilePath local_path = base::FilePath(FILE_PATH_LITERAL("dummy"));
     if (file_change.IsAddOrUpdate())
       CreateTemporaryFileInDir(database_dir_.path(), &local_path);
     scoped_ptr<LocalToRemoteSyncer> syncer(new LocalToRemoteSyncer(
-        this, SyncFileMetadata(file_change.file_type(), 0, base::Time()),
+        context_.get(),
+        SyncFileMetadata(file_change.file_type(), 0, base::Time()),
         file_change, local_path, url));
     syncer->RunSequential(CreateResultReceiver(&status));
     base::RunLoop().RunUntilIdle();
     if (status == SYNC_STATUS_OK)
       fake_remote_change_processor_->ClearLocalChanges(url);
     return status;
   }
 
   void RunRemoteToLocalSyncerUntilIdle() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     while (status != SYNC_STATUS_NO_CHANGE_TO_SYNC)
       status = RunRemoteToLocalSyncer();
   }
 
   SyncStatusCode RunConflictResolver() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    ConflictResolver resolver(this);
+    ConflictResolver resolver(context_.get());
     resolver.RunSequential(CreateResultReceiver(&status));
     base::RunLoop().RunUntilIdle();
     return status;
   }
 
   SyncStatusCode ListChanges() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     sync_task_manager_->ScheduleSyncTask(
         FROM_HERE,
-        scoped_ptr<SyncTask>(new ListChangesTask(this)),
+        scoped_ptr<SyncTask>(new ListChangesTask(context_.get())),
         SyncTaskManager::PRIORITY_MED,
         CreateResultReceiver(&status));
     base::RunLoop().RunUntilIdle();
     return status;
   }
 
   ScopedVector<google_apis::ResourceEntry>
   GetResourceEntriesForParentAndTitle(const std::string& parent_folder_id,
                                       const std::string& title) {
     ScopedVector<google_apis::ResourceEntry> entries;
@@ skipping 19 matching lines @@
   void VerifyLocalChangeConsistency(
       const URLToFileChangesMap& expected_changes) {
     fake_remote_change_processor_->VerifyConsistency(expected_changes);
   }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir database_dir_;
   scoped_ptr<leveldb::Env> in_memory_env_;
 
-  scoped_ptr<FakeDriveServiceWrapper> fake_drive_service_;
-  scoped_ptr<FakeDriveUploader> drive_uploader_;
+  scoped_ptr<SyncEngineContext> context_;
   scoped_ptr<FakeDriveServiceHelper> fake_drive_helper_;
-  scoped_ptr<MetadataDatabase> metadata_database_;
   scoped_ptr<FakeRemoteChangeProcessor> fake_remote_change_processor_;
 
   scoped_ptr<SyncTaskManager> sync_task_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ConflictResolverTest);
 };
 
 TEST_F(ConflictResolverTest, NoFileToBeResolved) {
   const GURL kOrigin("chrome-extension://example");
   const std::string sync_root = CreateSyncRoot();
@@ skipping 230 matching lines @@
 
   EXPECT_EQ(4, CountParents(file));
 
   EXPECT_EQ(SYNC_STATUS_OK, RunConflictResolver());
 
   EXPECT_EQ(1, CountParents(file));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system