[SyncFS] Split SyncEngine and SyncEngineContext

chrome/browser/sync_file_system/drive_backend/register_app_task_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/register_app_task.h"
 
 #include <vector>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
@@ skipping 17 matching lines @@
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 const int64 kSyncRootTrackerID = 100;
 }  // namespace
 
-class RegisterAppTaskTest : public testing::Test,
-                            public SyncEngineContext {
+class RegisterAppTaskTest : public testing::Test {
  public:
   RegisterAppTaskTest()
       : next_file_id_(1000),
         next_tracker_id_(10000) {}
   virtual ~RegisterAppTaskTest() {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
 
-    fake_drive_service_.reset(new drive::FakeDriveService);
-    ASSERT_TRUE(fake_drive_service_->LoadAccountMetadataForWapi(
+    scoped_ptr<drive::FakeDriveService> fake_drive_service;
+    fake_drive_service.reset(new drive::FakeDriveService);
+    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 drive::DriveUploader(
-        fake_drive_service_.get(), base::MessageLoopProxy::current()));
+    scoped_ptr<drive::DriveUploader> drive_uploader;
+    drive_uploader.reset(new drive::DriveUploader(
+        fake_drive_service.get(), base::MessageLoopProxy::current()));
 
     fake_drive_service_helper_.reset(new FakeDriveServiceHelper(
-        fake_drive_service_.get(), drive_uploader_.get(),
+        fake_drive_service.get(), drive_uploader.get(),
         kSyncRootFolderTitle));
 
+    context_.reset(new SyncEngineContext(
+        fake_drive_service.PassAs<drive::DriveServiceInterface>(),
+        drive_uploader.PassAs<drive::DriveUploaderInterface>(),
+        base::MessageLoopProxy::current()));
+
     ASSERT_EQ(google_apis::HTTP_CREATED,
               fake_drive_service_helper_->AddOrphanedFolder(
                   kSyncRootFolderTitle, &sync_root_folder_id_));
   }
 
   virtual void TearDown() OVERRIDE {
-    metadata_database_.reset();
+    context_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
-  virtual drive::DriveServiceInterface* GetDriveService() OVERRIDE {
-    return fake_drive_service_.get();
-  }
-
-  virtual drive::DriveUploaderInterface* GetDriveUploader() OVERRIDE {
-    return NULL;
-  }
-
-  virtual MetadataDatabase* GetMetadataDatabase() OVERRIDE {
-    return metadata_database_.get();
-  }
-
-  virtual RemoteChangeProcessor* GetRemoteChangeProcessor() OVERRIDE {
-    return NULL;
-  }
-
-  virtual base::SequencedTaskRunner* GetBlockingTaskRunner() OVERRIDE {
-    return base::MessageLoopProxy::current();
-  }
-
  protected:
   scoped_ptr<leveldb::DB> OpenLevelDB() {
     leveldb::DB* db = NULL;
     leveldb::Options options;
     options.create_if_missing = true;
     options.env = in_memory_env_.get();
     leveldb::Status status =
         leveldb::DB::Open(options, database_dir_.path().AsUTF8Unsafe(), &db);
     EXPECT_TRUE(status.ok());
     return make_scoped_ptr<leveldb::DB>(db);
@@ skipping 26 matching lines @@
     batch.Put(kDatabaseVersionKey,
               base::Int64ToString(kCurrentDatabaseVersion));
     PutServiceMetadataToBatch(service_metadata, &batch);
     PutFileMetadataToBatch(sync_root_metadata, &batch);
     PutFileTrackerToBatch(sync_root_tracker, &batch);
     EXPECT_TRUE(db->Write(leveldb::WriteOptions(), &batch).ok());
   }
 
   void CreateMetadataDatabase(scoped_ptr<leveldb::DB> db) {
     ASSERT_TRUE(db);
-    ASSERT_FALSE(metadata_database_);
+    ASSERT_FALSE(context_->GetMetadataDatabase());
+    scoped_ptr<MetadataDatabase> metadata_db;
     ASSERT_EQ(SYNC_STATUS_OK,
               MetadataDatabase::CreateForTesting(
-                  db.Pass(), &metadata_database_));
+                  db.Pass(), &metadata_db));
+    context_->SetMetadataDatabase(metadata_db.Pass());
   }
 
   SyncStatusCode RunRegisterAppTask(const std::string& app_id) {
-    RegisterAppTask task(this, app_id);
+    RegisterAppTask task(context_.get(), app_id);
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     task.RunSequential(CreateResultReceiver(&status));
     base::RunLoop().RunUntilIdle();
     return status;
   }
 
   void SetUpRegisteredAppRoot(
       const std::string& app_id,
       leveldb::DB* db) {
     FileDetails details;
@@ skipping 40 matching lines @@
     tracker.set_active(false);
 
     leveldb::WriteBatch batch;
     PutFileMetadataToBatch(metadata, &batch);
     PutFileTrackerToBatch(tracker, &batch);
     EXPECT_TRUE(db->Write(leveldb::WriteOptions(), &batch).ok());
   }
 
   size_t CountRegisteredAppRoot() {
     std::vector<std::string> app_ids;
-    metadata_database_->GetRegisteredAppIDs(&app_ids);
+    context_->GetMetadataDatabase()->GetRegisteredAppIDs(&app_ids);
     return app_ids.size();
   }
 
   bool IsAppRegistered(const std::string& app_id) {
     TrackerIDSet trackers;
-    if (!metadata_database_->FindTrackersByParentAndTitle(
+    if (!context_->GetMetadataDatabase()->FindTrackersByParentAndTitle(
             kSyncRootTrackerID, app_id, &trackers))
       return false;
     return trackers.has_active();
   }
 
   size_t CountRemoteFileInSyncRoot() {
     ScopedVector<google_apis::ResourceEntry> files;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_service_helper_->ListFilesInFolder(
                   sync_root_folder_id_, &files));
     return files.size();
   }
 
   bool HasRemoteAppRoot(const std::string& app_id) {
     TrackerIDSet files;
-    if (!metadata_database_->FindTrackersByParentAndTitle(
+    if (!context_->GetMetadataDatabase()->FindTrackersByParentAndTitle(
             kSyncRootTrackerID, app_id, &files) ||
         !files.has_active())
       return false;
 
     FileTracker app_root_tracker;
-    EXPECT_TRUE(metadata_database_->FindTrackerByTrackerID(
+    EXPECT_TRUE(context_->GetMetadataDatabase()->FindTrackerByTrackerID(
         files.active_tracker(), &app_root_tracker));
     std::string app_root_folder_id = app_root_tracker.file_id();
     scoped_ptr<google_apis::ResourceEntry> entry;
     if (google_apis::HTTP_SUCCESS !=
         fake_drive_service_helper_->GetResourceEntry(
             app_root_folder_id, &entry))
       return false;
 
     return !entry->deleted();
   }
 
  private:
   std::string GenerateFileID() {
     return base::StringPrintf("file_id_%" PRId64, next_file_id_++);
   }
 
   scoped_ptr<leveldb::Env> in_memory_env_;
 
   std::string sync_root_folder_id_;
 
   int64 next_file_id_;
   int64 next_tracker_id_;
 
   content::TestBrowserThreadBundle browser_threads_;
   base::ScopedTempDir database_dir_;
 
-  scoped_ptr<drive::FakeDriveService> fake_drive_service_;
-  scoped_ptr<drive::DriveUploader> drive_uploader_;
+  scoped_ptr<SyncEngineContext> context_;
   scoped_ptr<FakeDriveServiceHelper> fake_drive_service_helper_;
 
-  scoped_ptr<MetadataDatabase> metadata_database_;
-
   DISALLOW_COPY_AND_ASSIGN(RegisterAppTaskTest);
 };
 
 TEST_F(RegisterAppTaskTest, AlreadyRegistered) {
   scoped_ptr<leveldb::DB> db(OpenLevelDB());
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());
 
   const std::string kAppID = "app_id";
   SetUpRegisteredAppRoot(kAppID, db.get());
@@ skipping 47 matching lines @@
 
   CreateMetadataDatabase(db.Pass());
   RunRegisterAppTask(kAppID);
 
   EXPECT_EQ(1u, CountRegisteredAppRoot());
   EXPECT_TRUE(IsAppRegistered(kAppID));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system