[SyncFS] Make SyncEngineTest multi-threaded test

chrome/browser/sync_file_system/drive_backend/sync_engine_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/sync_engine.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
-#include "base/strings/stringprintf.h"
 #include "chrome/browser/drive/drive_uploader.h"
 #include "chrome/browser/drive/fake_drive_service.h"
-#include "chrome/browser/extensions/test_extension_service.h"
-#include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
-#include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
-#include "chrome/browser/sync_file_system/drive_backend/sync_task.h"
-#include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
-#include "chrome/browser/sync_file_system/drive_backend/sync_worker.h"
+#include "chrome/browser/sync_file_system/drive_backend/fake_sync_worker.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_file_system_test_util.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
-#include "extensions/common/extension.h"
-#include "extensions/common/extension_builder.h"
-#include "extensions/common/extension_set.h"
-#include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
-#include "third_party/leveldatabase/src/include/leveldb/env.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 
-const char kAppID[] = "app_id";
-
-void EmptyTask(SyncStatusCode status, const SyncStatusCallback& callback) {
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(callback, status));
+template <typename T>
+void SetValueAndCallClosure(const base::Closure& closure,
+                            T* arg_out,
+                            T arg) {
+  *arg_out = base::internal::CallbackForward(arg);
+  closure.Run();
 }
 
+void SyncStatusFileURL(const base::Closure& closure,
+                       SyncStatusCode,
+                       const fileapi::FileSystemURL&) {
+  closure.Run();
+}
+
 }  // namespace
 
-class MockSyncTask : public ExclusiveTask {
+class SyncEngineTest : public testing::Test,
+                       public RemoteFileSyncService::Observer,

[nhiroki, 2014/06/18 06:58:10]

Although you ignore the result in OnRemoteXXX(), do you need to observe the sync
engine? If not, can you remove this and WaitAsyncCall()?

[nhiroki, 2014/06/18 07:11:30]

Ah, I just got what you mean. You check the status update in the test (i.e.
UpdateServiceState). Let me recall this comment.

[peria, 2014/06/18 08:05:01]

Due to a discussion with Tsuiki-san, yes, we can remove this inheritance.

However, Observing SyncEngine is required to check all communications.
So I'd like to add it again in future CLs.

+                       public base::SupportsWeakPtr<SyncEngineTest> {
  public:
-  explicit MockSyncTask(bool used_network) {
-    set_used_network(used_network);
-  }
-  virtual ~MockSyncTask() {}
-
-  virtual void RunExclusive(const SyncStatusCallback& callback) OVERRIDE {
-    callback.Run(SYNC_STATUS_OK);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockSyncTask);
-};
-
-class MockExtensionService : public TestExtensionService {
- public:
-  MockExtensionService() {}
-  virtual ~MockExtensionService() {}
-
-  virtual const extensions::ExtensionSet* extensions() const OVERRIDE {
-    return &extensions_;
-  }
-
-  virtual void AddExtension(const extensions::Extension* extension) OVERRIDE {
-    extensions_.Insert(make_scoped_refptr(extension));
-  }
-
-  virtual const extensions::Extension* GetInstalledExtension(
-      const std::string& extension_id) const OVERRIDE {
-    return extensions_.GetByID(extension_id);
-  }
-
-  virtual bool IsExtensionEnabled(
-      const std::string& extension_id) const OVERRIDE {
-    return extensions_.Contains(extension_id) &&
-        !disabled_extensions_.Contains(extension_id);
-  }
-
-  void UninstallExtension(const std::string& extension_id) {
-    extensions_.Remove(extension_id);
-    disabled_extensions_.Remove(extension_id);
-  }
-
-  void DisableExtension(const std::string& extension_id) {
-    if (!IsExtensionEnabled(extension_id))
-      return;
-    const extensions::Extension* extension = extensions_.GetByID(extension_id);
-    disabled_extensions_.Insert(make_scoped_refptr(extension));
-  }
-
- private:
-  extensions::ExtensionSet extensions_;
-  extensions::ExtensionSet disabled_extensions_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockExtensionService);
-};
-
-class SyncEngineTest
-    : public testing::Test,
-      public base::SupportsWeakPtr<SyncEngineTest> {
- public:
+  typedef RemoteFileSyncService::OriginStatusMap RemoteOriginStatusMap;
+
   SyncEngineTest() {}
   virtual ~SyncEngineTest() {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
-    in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
-
-    extension_service_.reset(new MockExtensionService);
+
     scoped_ptr<drive::DriveServiceInterface>
         fake_drive_service(new drive::FakeDriveService);
 
+    scoped_refptr<base::SequencedWorkerPool> worker_pool =
+        content::BrowserThread::GetBlockingPool();
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner =
+        base::MessageLoopProxy::current();
+    scoped_refptr<base::SequencedTaskRunner> worker_task_runner =
+        worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
+            worker_pool->GetSequenceToken(),
+            base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+    scoped_refptr<base::SequencedTaskRunner> file_task_runner =
+        worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
+            worker_pool->GetSequenceToken(),
+            base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+    scoped_refptr<base::SequencedTaskRunner> drive_task_runner =
+        worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
+            worker_pool->GetSequenceToken(),
+            base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);

[tzik, 2014/06/18 07:39:55]

I think we can pass NULL to file_task_runner and drive_task_runner.

[peria, 2014/06/18 08:05:01]

Done.

+
+    run_loop_.reset();
+
     sync_engine_.reset(new drive_backend::SyncEngine(
-        base::MessageLoopProxy::current(),  // ui_task_runner
-        base::MessageLoopProxy::current(),  // worker_task_runner
-        base::MessageLoopProxy::current(),  // file_task_runner
-        base::MessageLoopProxy::current(),  // drive_task_runner
+        ui_task_runner,
+        worker_task_runner,
+        file_task_runner,
+        drive_task_runner,
         profile_dir_.path(),
-        NULL,  // task_logger
-        NULL,  // notification_manager
-        extension_service_.get(),
-        NULL,  // signin_manager
-        NULL,  // token_service
-        NULL,  // request_context
-        in_memory_env_.get()));
+        NULL /* task_logger */,
+        NULL /* notification_manager */,
+        NULL /* extension_service */,
+        NULL /* signin_manager */,
+        NULL /* token_service */,
+        NULL /* request_context */,
+        NULL /* in_memory_env */));
+
+    sync_engine_->AddServiceObserver(this);
 
     sync_engine_->InitializeForTesting(
         fake_drive_service.Pass(),
         scoped_ptr<drive::DriveUploaderInterface>(),
-        scoped_ptr<SyncWorkerInterface>());
+        scoped_ptr<SyncWorkerInterface>(new FakeSyncWorker));
+    WaitAsyncCall();
+
     sync_engine_->SetSyncEnabled(true);
+    WaitAsyncCall();
+
     base::RunLoop().RunUntilIdle();
   }
 
   virtual void TearDown() OVERRIDE {
     sync_engine_.reset();
-    extension_service_.reset();
+
+    run_loop_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
-  MockExtensionService* extension_service() { return extension_service_.get(); }
+  // RemoteFileSyncService::Observer overrides
+  virtual void OnRemoteChangeQueueUpdated(int64) OVERRIDE {
+    if (run_loop_)
+      run_loop_->Quit();
+  }
+
+  virtual void OnRemoteServiceStateUpdated(
+      RemoteServiceState state, const std::string& description) OVERRIDE {
+    if (run_loop_)
+      run_loop_->Quit();
+  }
+
+  bool FindOriginStatus(const GURL& origin, std::string* status) {
+    scoped_ptr<RemoteOriginStatusMap> status_map;
+
+    base::RunLoop run_loop;
+    sync_engine()->GetOriginStatusMap(
+        base::Bind(&SetValueAndCallClosure<scoped_ptr<RemoteOriginStatusMap> >,
+                   run_loop.QuitClosure(),
+                   &status_map));
+    run_loop.Run();
+    RemoteOriginStatusMap::const_iterator itr = status_map->find(origin);
+    if (itr == status_map->end())
+      return false;
+
+    *status = itr->second;
+    // If an origin is uninstalled, it should not be found actually.
+    if (*status == "Uninstalled")
+      return false;
+    return true;
+  }
+
+  void PostUpdateServiceState(RemoteServiceState state,
+                              const std::string& description) {
+    worker_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&FakeSyncWorker::UpdateServiceState,
+                   base::Unretained(fake_sync_worker()),
+                   state,
+                   description));
+    // Call tree from FakeSyncWorker will call OnRemoteServiceStateUpdated().
+    WaitAsyncCall();
+  }
+
+  void WaitAsyncCall() {
+    run_loop_.reset(new base::RunLoop);
+    run_loop_->Run();
+    run_loop_.reset();
+  }
+
+  // Accessors
   SyncEngine* sync_engine() { return sync_engine_.get(); }
-
-  SyncTaskManager* GetSyncTaskManager() {
-    return sync_engine_->sync_worker_->GetSyncTaskManager();
-  }
-
-  void CheckServiceState(SyncStatusCode expected_sync_status,
-                         RemoteServiceState expected_service_status,
-                         SyncStatusCode sync_status) {
-    EXPECT_EQ(expected_sync_status, sync_status);
-    EXPECT_EQ(expected_service_status, sync_engine_->GetCurrentState());
-  }
-
-  MetadataDatabase* metadata_database() {
-    return sync_engine_->sync_worker_->GetMetadataDatabase();
-  }
-
-  void SetHasRefreshToken(bool has_refresh_token) {
-    sync_engine_->sync_worker_->SetHasRefreshToken(has_refresh_token);
+  FakeSyncWorker* fake_sync_worker() {
+    return static_cast<FakeSyncWorker*>(sync_engine_->sync_worker_.get());
+  }
+  base::SequencedTaskRunner* worker_task_runner() {
+    return sync_engine_->worker_task_runner_.get();
   }
 
  private:
   content::TestBrowserThreadBundle browser_threads_;
   base::ScopedTempDir profile_dir_;
-  scoped_ptr<leveldb::Env> in_memory_env_;
-
-  scoped_ptr<MockExtensionService> extension_service_;
   scoped_ptr<drive_backend::SyncEngine> sync_engine_;
+  scoped_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncEngineTest);
 };
 
-TEST_F(SyncEngineTest, EnableOrigin) {
-  FileTracker tracker;
+TEST_F(SyncEngineTest, OriginTest) {
+  GURL origin("chrome-extension://app_0");
+
+  SyncStatusCode sync_status;
+  std::string status;
+  {
+    base::RunLoop run_loop;
+    sync_engine()->RegisterOrigin(
+        origin,
+        base::Bind(&SetValueAndCallClosure<SyncStatusCode>,
+                   run_loop.QuitClosure(),
+                   &sync_status));
+    run_loop.Run();
+    EXPECT_EQ(SYNC_STATUS_OK, sync_status);
+    ASSERT_TRUE(FindOriginStatus(origin, &status));
+    EXPECT_EQ("Registered", status);
+  }
+  {
+    base::RunLoop run_loop;
+    sync_engine()->DisableOrigin(
+        origin,
+        base::Bind(&SetValueAndCallClosure<SyncStatusCode>,
+                   run_loop.QuitClosure(),
+                   &sync_status));
+    run_loop.Run();
+    EXPECT_EQ(SYNC_STATUS_OK, sync_status);
+    ASSERT_TRUE(FindOriginStatus(origin, &status));
+    EXPECT_EQ("Disabled", status);
+  }
+  {
+    base::RunLoop run_loop;
+    sync_engine()->EnableOrigin(
+        origin,
+        base::Bind(&SetValueAndCallClosure<SyncStatusCode>,
+                   run_loop.QuitClosure(),
+                   &sync_status));
+    run_loop.Run();
+    EXPECT_EQ(SYNC_STATUS_OK, sync_status);
+    ASSERT_TRUE(FindOriginStatus(origin, &status));
+    EXPECT_EQ("Enabled", status);
+  }
+  {
+    base::RunLoop run_loop;
+    sync_engine()->UninstallOrigin(
+        origin,
+        RemoteFileSyncService::UNINSTALL_AND_KEEP_REMOTE,
+        base::Bind(&SetValueAndCallClosure<SyncStatusCode>,
+                   run_loop.QuitClosure(),
+                   &sync_status));
+    run_loop.Run();
+    EXPECT_EQ(SYNC_STATUS_OK, sync_status);
+    EXPECT_FALSE(FindOriginStatus(origin, &status));
+    EXPECT_EQ("Uninstalled", status);
+  }
+}
+
+TEST_F(SyncEngineTest, GetOriginStatusMap) {
   SyncStatusCode sync_status = SYNC_STATUS_UNKNOWN;
-  GURL origin = extensions::Extension::GetBaseURLFromExtensionId(kAppID);
-
-  sync_engine()->RegisterOrigin(origin, CreateResultReceiver(&sync_status));
-  base::RunLoop().RunUntilIdle();
+
+  {
+    base::RunLoop run_loop;
+    sync_engine()->RegisterOrigin(
+        GURL("chrome-extension://app_0"),
+        base::Bind(&SetValueAndCallClosure<SyncStatusCode>,
+                   run_loop.QuitClosure(),
+                   &sync_status));
+    run_loop.Run();
+  }
   EXPECT_EQ(SYNC_STATUS_OK, sync_status);
-  ASSERT_TRUE(metadata_database()->FindAppRootTracker(kAppID, &tracker));
-  EXPECT_EQ(TRACKER_KIND_APP_ROOT, tracker.tracker_kind());
-
-  sync_engine()->DisableOrigin(origin, CreateResultReceiver(&sync_status));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
-  ASSERT_TRUE(metadata_database()->FindAppRootTracker(kAppID, &tracker));
-  EXPECT_EQ(TRACKER_KIND_DISABLED_APP_ROOT, tracker.tracker_kind());
-
-  sync_engine()->EnableOrigin(origin, CreateResultReceiver(&sync_status));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
-  ASSERT_TRUE(metadata_database()->FindAppRootTracker(kAppID, &tracker));
-  EXPECT_EQ(TRACKER_KIND_APP_ROOT, tracker.tracker_kind());
-
-  sync_engine()->UninstallOrigin(
-      origin,
-      RemoteFileSyncService::UNINSTALL_AND_KEEP_REMOTE,
-      CreateResultReceiver(&sync_status));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
-  ASSERT_FALSE(metadata_database()->FindAppRootTracker(kAppID, &tracker));
-}
-
-TEST_F(SyncEngineTest, GetOriginStatusMap) {
-  FileTracker tracker;
-  SyncStatusCode sync_status = SYNC_STATUS_UNKNOWN;
-  GURL origin = extensions::Extension::GetBaseURLFromExtensionId(kAppID);
-
-  sync_engine()->RegisterOrigin(GURL("chrome-extension://app_0"),
-                                CreateResultReceiver(&sync_status));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(SYNC_STATUS_OK, sync_status);
 
   sync_engine()->RegisterOrigin(GURL("chrome-extension://app_1"),
                                 CreateResultReceiver(&sync_status));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(SYNC_STATUS_OK, sync_status);
 
-  scoped_ptr<RemoteFileSyncService::OriginStatusMap> status_map;
-  sync_engine()->GetOriginStatusMap(CreateResultReceiver(&status_map));
-  base::RunLoop().RunUntilIdle();
+  scoped_ptr<RemoteOriginStatusMap> status_map;
+  {
+    base::RunLoop run_loop;
+    sync_engine()->GetOriginStatusMap(
+        base::Bind(&SetValueAndCallClosure<scoped_ptr<RemoteOriginStatusMap> >,
+                   run_loop.QuitClosure(),
+                   &status_map));
+    run_loop.Run();
+  }
   ASSERT_EQ(2u, status_map->size());
-  EXPECT_EQ("Enabled", (*status_map)[GURL("chrome-extension://app_0")]);
-  EXPECT_EQ("Enabled", (*status_map)[GURL("chrome-extension://app_1")]);
+  EXPECT_EQ("Registered", (*status_map)[GURL("chrome-extension://app_0")]);
+  EXPECT_EQ("Registered", (*status_map)[GURL("chrome-extension://app_1")]);
 
-  sync_engine()->DisableOrigin(GURL("chrome-extension://app_1"),
-                               CreateResultReceiver(&sync_status));
-  base::RunLoop().RunUntilIdle();
+  {
+    base::RunLoop run_loop;
+    sync_engine()->DisableOrigin(
+        GURL("chrome-extension://app_1"),
+        base::Bind(&SetValueAndCallClosure<SyncStatusCode>,
+                   run_loop.QuitClosure(),
+                   &sync_status));
+    run_loop.Run();
+  }
   EXPECT_EQ(SYNC_STATUS_OK, sync_status);
 
-  sync_engine()->GetOriginStatusMap(CreateResultReceiver(&status_map));
-  base::RunLoop().RunUntilIdle();
+  {
+    base::RunLoop run_loop;
+    sync_engine()->GetOriginStatusMap(
+        base::Bind(&SetValueAndCallClosure<scoped_ptr<RemoteOriginStatusMap> >,
+                   run_loop.QuitClosure(),
+                   &status_map));
+    run_loop.Run();
+  }
   ASSERT_EQ(2u, status_map->size());
-  EXPECT_EQ("Enabled", (*status_map)[GURL("chrome-extension://app_0")]);
+  EXPECT_EQ("Registered", (*status_map)[GURL("chrome-extension://app_0")]);
   EXPECT_EQ("Disabled", (*status_map)[GURL("chrome-extension://app_1")]);
 }
 
 TEST_F(SyncEngineTest, UpdateServiceState) {
-  EXPECT_EQ(REMOTE_SERVICE_OK, sync_engine()->GetCurrentState());
+  struct {
+    RemoteServiceState state;
+    const char* description;
+  } test_data[] = {
+    {REMOTE_SERVICE_OK, "OK"},
+    {REMOTE_SERVICE_TEMPORARY_UNAVAILABLE, "TEMPORARY_UNAVAILABLE"},
+    {REMOTE_SERVICE_AUTHENTICATION_REQUIRED, "AUTHENTICATION_REQUIRED"},
+    {REMOTE_SERVICE_DISABLED, "DISABLED"},
 
-  // Assume an user is in login state.
-  sync_engine()->OnReadyToSendRequests();
+    {REMOTE_SERVICE_STATE_MAX, "STATE_MAX"},  // Will not be tested
+  };
 
-  GetSyncTaskManager()->ScheduleTask(
-      FROM_HERE,
-      base::Bind(&EmptyTask, SYNC_STATUS_AUTHENTICATION_FAILED),
-      SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncEngineTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_STATUS_AUTHENTICATION_FAILED,
-                 REMOTE_SERVICE_AUTHENTICATION_REQUIRED));
+  for (int i = 0; test_data[i].state != REMOTE_SERVICE_STATE_MAX; ++i) {
+    PostUpdateServiceState(test_data[i].state, test_data[i].description);
+    EXPECT_EQ(test_data[i].state, sync_engine()->GetCurrentState())
+        << "Expected state: REMOTE_SERVICE_" << test_data[i].description;
+  }
+}
 
-  GetSyncTaskManager()->ScheduleTask(
-      FROM_HERE,
-      base::Bind(&EmptyTask, SYNC_STATUS_ACCESS_FORBIDDEN),
-      SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncEngineTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_STATUS_ACCESS_FORBIDDEN,
-                 REMOTE_SERVICE_AUTHENTICATION_REQUIRED));
-
-  GetSyncTaskManager()->ScheduleTask(
-      FROM_HERE,
-      base::Bind(&EmptyTask, SYNC_STATUS_SERVICE_TEMPORARILY_UNAVAILABLE),
-      SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncEngineTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_STATUS_SERVICE_TEMPORARILY_UNAVAILABLE,
-                 REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
-
-  GetSyncTaskManager()->ScheduleTask(
-      FROM_HERE,
-      base::Bind(&EmptyTask, SYNC_STATUS_NETWORK_ERROR),
-      SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncEngineTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_STATUS_NETWORK_ERROR,
-                 REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
-
-  GetSyncTaskManager()->ScheduleTask(
-      FROM_HERE,
-      base::Bind(&EmptyTask, SYNC_STATUS_ABORT),
-      SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncEngineTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_STATUS_ABORT,
-                 REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
-
-  GetSyncTaskManager()->ScheduleTask(
-      FROM_HERE,
-      base::Bind(&EmptyTask, SYNC_STATUS_FAILED),
-      SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncEngineTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_STATUS_FAILED,
-                 REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
-
-  GetSyncTaskManager()->ScheduleTask(
-      FROM_HERE,
-      base::Bind(&EmptyTask, SYNC_DATABASE_ERROR_CORRUPTION),
-      SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncEngineTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_DATABASE_ERROR_CORRUPTION,
-                 REMOTE_SERVICE_DISABLED));
-
-  GetSyncTaskManager()->ScheduleTask(
-      FROM_HERE,
-      base::Bind(&EmptyTask, SYNC_DATABASE_ERROR_IO_ERROR),
-      SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncEngineTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_DATABASE_ERROR_IO_ERROR,
-                 REMOTE_SERVICE_DISABLED));
-
-  GetSyncTaskManager()->ScheduleTask(
-      FROM_HERE,
-      base::Bind(&EmptyTask, SYNC_DATABASE_ERROR_FAILED),
-      SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncEngineTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_DATABASE_ERROR_FAILED,
-                 REMOTE_SERVICE_DISABLED));
-
-  GetSyncTaskManager()->ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new MockSyncTask(false)),
-      SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncEngineTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_STATUS_OK,
-                 REMOTE_SERVICE_DISABLED));
-
-  GetSyncTaskManager()->ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new MockSyncTask(true)),
-      SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncEngineTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_STATUS_OK,
-                 REMOTE_SERVICE_OK));
-
-  base::RunLoop().RunUntilIdle();
+TEST_F(SyncEngineTest, ProcessRemoteChange) {
+  base::RunLoop run_loop;
+  sync_engine()->ProcessRemoteChange(
+      base::Bind(&SyncStatusFileURL, run_loop.QuitClosure()));
+  run_loop.Run();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system