[SyncFS] Replace DriveFileSyncServiceSyncTest to support combined test

Replace DriveFileSyncServiceSyncTest with new one to test both LocalSync and RemoteSync.

BUG=243612
NOTRY=true

Review URL: https://chromiumcodereview.appspot.com/17427005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@208203 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 626 insertions, 378 deletions

diff --git a/chrome/browser/sync_file_system/drive_file_sync_service_sync_unittest.cc b/chrome/browser/sync_file_system/drive_file_sync_service_sync_unittest.cc
index d4ca730..29ea793 100644
--- a/chrome/browser/sync_file_system/drive_file_sync_service_sync_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_file_sync_service_sync_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -6,541 +6,788 @@
 
 #include <algorithm>
 
-#include "base/format_macros.h"
+#include "base/file_util.h"
 #include "base/message_loop.h"
-#include "base/rand_util.h"
+#include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/sync_file_system/drive/fake_api_util.h"
-#include "chrome/browser/sync_file_system/drive/metadata_db_migration_util.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "chrome/browser/drive/drive_uploader.h"
+#include "chrome/browser/drive/fake_drive_service.h"
+#include "chrome/browser/sync_file_system/drive/api_util.h"
 #include "chrome/browser/sync_file_system/drive_file_sync_util.h"
 #include "chrome/browser/sync_file_system/drive_metadata_store.h"
 #include "chrome/browser/sync_file_system/fake_remote_change_processor.h"
-#include "chrome/browser/sync_file_system/sync_file_system.pb.h"
+#include "chrome/browser/sync_file_system/local_file_sync_service.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webkit/browser/fileapi/file_system_context.h"
+#include "webkit/browser/fileapi/syncable/canned_syncable_file_system.h"
+#include "webkit/browser/fileapi/syncable/local_file_sync_context.h"
 #include "webkit/browser/fileapi/syncable/syncable_file_system_util.h"
 
+#define FPL(path) FILE_PATH_LITERAL(path)
+
+using content::BrowserThread;
+
 namespace sync_file_system {
 
 namespace {
 
-const char kAppId[] = "app-id";
-const char kAppOrigin[] = "chrome-extension://app-id";
+void SyncResultCallback(bool* done,
+                        SyncStatusCode* status_out,
+                        fileapi::FileSystemURL* url_out,
+                        SyncStatusCode status,
+                        const fileapi::FileSystemURL& url) {
+  EXPECT_FALSE(*done);
+  *status_out = status;
+  *url_out = url;
+  *done = true;
+}
 
-std::string GetSyncRootResourceId() {
-  const std::string kSyncRootResourceId("folder:sync_root_resource_id");
-  return IsDriveAPIDisabled() ? kSyncRootResourceId
-                              : drive::RemoveWapiIdPrefix(kSyncRootResourceId);
+void ResourceEntryResultCallback(
+    bool* done,
+    google_apis::GDataErrorCode* error_out,
+    scoped_ptr<google_apis::ResourceEntry>* entry_out,
+    google_apis::GDataErrorCode error,
+    scoped_ptr<google_apis::ResourceEntry> entry) {
+  EXPECT_FALSE(*done);
+  *error_out = error;
+  *entry_out = entry.Pass();
+  *done = true;
 }
 
-std::string GetParentResourceId() {
-  const std::string kParentResourceId("folder:parent_resource_id");
-  return IsDriveAPIDisabled() ? kParentResourceId
-                              : drive::RemoveWapiIdPrefix(kParentResourceId);
+void UploadResultCallback(bool* done,
+                          google_apis::GDataErrorCode* error_out,
+                          scoped_ptr<google_apis::ResourceEntry>* entry_out,
+                          google_apis::GDataErrorCode error,
+                          const GURL& upload_location,
+                          scoped_ptr<google_apis::ResourceEntry> entry) {
+  EXPECT_FALSE(*done);
+  *error_out = error;
+  *entry_out = entry.Pass();
+  *done = true;
 }
 
-void DidInitialize(bool* done, SyncStatusCode status, bool created) {
-  EXPECT_EQ(SYNC_STATUS_OK, status);
+void ResourceListResultCallback(bool* done,
+                                google_apis::GDataErrorCode* error_out,
+                                scoped_ptr<google_apis::ResourceList>* list_out,
+                                google_apis::GDataErrorCode error,
+                                scoped_ptr<google_apis::ResourceList> list) {
+  EXPECT_FALSE(*done);
+  *error_out = error;
+  *list_out = list.Pass();
   *done = true;
 }
 
-void DidProcessRemoteChange(bool* done,
-                            SyncStatusCode* status_out,
-                            SyncStatusCode status,
-                            const fileapi::FileSystemURL& url) {
+void SyncStatusResultCallback(bool* done,
+                              SyncStatusCode* status_out,
+                              SyncStatusCode status) {
+  EXPECT_FALSE(*done);
   *status_out = status;
   *done = true;
 }
 
+void GDataErrorResultCallback(bool* done,
+                              google_apis::GDataErrorCode* error_out,
+                              google_apis::GDataErrorCode error) {
+  EXPECT_FALSE(*done);
+  *error_out = error;
+  *done = true;
+}
+
+void DownloadResultCallback(bool* done,
+                            google_apis::GDataErrorCode* error_out,
+                            google_apis::GDataErrorCode error,
+                            const base::FilePath& local_file) {
+  EXPECT_FALSE(*done);
+  *error_out = error;
+  *done = true;
+}
+
+void DatabaseInitResultCallback(bool* done,
+                                SyncStatusCode* status_out,
+                                bool* created_out,
+                                SyncStatusCode status,
+                                bool created) {
+  EXPECT_FALSE(*done);
+  *status_out = status;
+  *created_out = created;
+  *done = true;
+}
+
 }  // namespace
 
 class DriveFileSyncServiceSyncTest : public testing::Test {
  public:
   DriveFileSyncServiceSyncTest()
-      : ui_thread_(content::BrowserThread::UI, &message_loop_),
-        file_thread_(content::BrowserThread::FILE, &message_loop_),
-        fake_api_util_(NULL),
-        metadata_store_(NULL),
-        resource_count_(0) {}
+      : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
 
   virtual ~DriveFileSyncServiceSyncTest() {
   }
 
   virtual void SetUp() OVERRIDE {
-    SetEnableSyncFSDirectoryOperation(true);
+    ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
+    temp_dir_ = base_dir_.path().Append(FPL("tmp"));
+    ASSERT_TRUE(file_util::CreateDirectory(temp_dir_));
+
+    // TODO(tzik): Set up TestExtensionSystem to support simulated relaunch.
+
     RegisterSyncableFileSystem();
+    local_sync_service_.reset(new LocalFileSyncService(&profile_));
+
+    fake_drive_service_ = new ::drive::FakeDriveService();
+    fake_drive_service_->Initialize(&profile_);
+    ASSERT_TRUE(fake_drive_service_->LoadAccountMetadataForWapi(
+        "chromeos/sync_file_system/account_metadata.json"));
+    ASSERT_TRUE(fake_drive_service_->LoadResourceListForWapi(
+        "chromeos/gdata/root_feed.json"));
+
+    drive_uploader_ = new ::drive::DriveUploader(
+        fake_drive_service_, base::MessageLoopProxy::current());
+
+    bool done = false;
+    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
+    bool created = false;
+    scoped_ptr<DriveMetadataStore> metadata_store(
+        new DriveMetadataStore(base_dir_.path(),
+                               base::MessageLoopProxy::current()));
+    metadata_store->Initialize(
+        base::Bind(&DatabaseInitResultCallback, &done, &status, &created));
+    FlushMessageLoop();
+    EXPECT_TRUE(done);
+    EXPECT_EQ(SYNC_STATUS_OK, status);
+    EXPECT_TRUE(created);
+
+    scoped_ptr<drive::APIUtil> api_util(
+        drive::APIUtil::CreateForTesting(
+            &profile_,
+            scoped_ptr< ::drive::DriveServiceInterface>(fake_drive_service_),
+            scoped_ptr< ::drive::DriveUploaderInterface>(drive_uploader_)));
+
+    remote_sync_service_ = DriveFileSyncService::CreateForTesting(
+        &profile_, base_dir_.path(),
+        api_util.PassAs<drive::APIUtilInterface>(),
+        metadata_store.Pass());
+
+    local_sync_service_->SetLocalChangeProcessor(remote_sync_service_.get());
+    remote_sync_service_->SetRemoteChangeProcessor(local_sync_service_.get());
   }
 
   virtual void TearDown() OVERRIDE {
-    SetDisableDriveAPI(false);
+    drive_uploader_ = NULL;
+    fake_drive_service_ = NULL;
+    remote_sync_service_.reset();
+    local_sync_service_.reset();
+    FlushMessageLoop();
+
+    typedef std::map<GURL, CannedSyncableFileSystem*>::iterator iterator;
+    for (iterator itr = file_systems_.begin();
+         itr != file_systems_.end(); ++itr) {
+      itr->second->TearDown();
+      delete itr->second;
+    }
+    file_systems_.clear();
+
+    FlushMessageLoop();
     RevokeSyncableFileSystem();
-    SetEnableSyncFSDirectoryOperation(false);
   }
 
  protected:
-  struct SyncEvent {
-    std::string description;
-    base::Closure callback;
-
-    SyncEvent(const std::string& description,
-              base::Closure callback)
-        : description(description),
-          callback(callback) {
+  void RegisterOrigin(const GURL& origin) {
+    if (!ContainsKey(file_systems_, origin)) {
+      CannedSyncableFileSystem* file_system = new CannedSyncableFileSystem(
+          origin,
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
+
+      bool done = false;
+      SyncStatusCode status = SYNC_STATUS_UNKNOWN;
+      file_system->SetUp();
+      local_sync_service_->MaybeInitializeFileSystemContext(
+          origin, file_system->file_system_context(),
+          base::Bind(&SyncStatusResultCallback, &done, &status));
+      FlushMessageLoop();
+      EXPECT_TRUE(done);
+      EXPECT_EQ(SYNC_STATUS_OK, status);
+
+      file_system->file_system_context()->sync_context()->
+          set_mock_notify_changes_duration_in_sec(0);
+
+      EXPECT_EQ(base::PLATFORM_FILE_OK, file_system->OpenFileSystem());
+      file_systems_[origin] = file_system;
     }
-  };
 
-  SyncEvent CreateRemoteFileAddOrUpdateEvent(const std::string& title) {
-    return SyncEvent(
-        "SyncEvent: Add or Update remote file [" + title + "]",
-        base::Bind(&DriveFileSyncServiceSyncTest::AddOrUpdateResource,
-                   base::Unretained(this), title, SYNC_FILE_TYPE_FILE));
+    bool done = false;
+    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
+    remote_sync_service_->RegisterOriginForTrackingChanges(
+        origin, base::Bind(&SyncStatusResultCallback, &done, &status));
+    FlushMessageLoop();
+    EXPECT_TRUE(done);
+    EXPECT_EQ(SYNC_STATUS_OK, status);
   }
 
-  SyncEvent CreateRemoteDirectoryAddEvent(const std::string& title) {
-    return SyncEvent(
-        "SyncEvent: Add remote directory [" + title + "]",
-        base::Bind(&DriveFileSyncServiceSyncTest::AddOrUpdateResource,
-                   base::Unretained(this), title, SYNC_FILE_TYPE_DIRECTORY));
+  void AddLocalFolder(const GURL& origin,
+                      const base::FilePath& path) {
+    ASSERT_TRUE(ContainsKey(file_systems_, origin));
+    EXPECT_EQ(base::PLATFORM_FILE_OK,
+              file_systems_[origin]->CreateDirectory(
+                  CreateSyncableFileSystemURL(origin, path)));
   }
 
-  SyncEvent CreateRemoteFileDeleteEvent(const std::string& title) {
-    return SyncEvent(
-        "SyncEvent: Delete remote file [" + title + "]",
-        base::Bind(&DriveFileSyncServiceSyncTest::DeleteResource,
-                   base::Unretained(this), title));
+  void AddOrUpdateLocalFile(const GURL& origin,
+                            const base::FilePath& path,
+                            const std::string& content) {
+    fileapi::FileSystemURL url(CreateSyncableFileSystemURL(origin, path));
+    ASSERT_TRUE(ContainsKey(file_systems_, origin));
+    EXPECT_EQ(base::PLATFORM_FILE_OK, file_systems_[origin]->CreateFile(url));
+    int64 bytes_written = file_systems_[origin]->WriteString(url, content);
+    EXPECT_EQ(static_cast<int64>(content.size()), bytes_written);
+    FlushMessageLoop();
   }
 
-  SyncEvent CreateRelaunchEvent() {
-    return SyncEvent(
-        "SyncEvent: Relaunch service",
-        base::Bind(&DriveFileSyncServiceSyncTest::RelaunchService,
-                   base::Unretained(this)));
+  void UpdateLocalFile(const GURL& origin,
+                       const base::FilePath& path,
+                       const std::string& content) {
+    ASSERT_TRUE(ContainsKey(file_systems_, origin));
+    int64 bytes_written = file_systems_[origin]->WriteString(
+        CreateSyncableFileSystemURL(origin, path), content);
+    EXPECT_EQ(static_cast<int64>(content.size()), bytes_written);
+    FlushMessageLoop();
   }
 
-  SyncEvent CreateFetchEvent() {
-    return SyncEvent(
-        "SyncEvent: Fetch remote changes",
-        base::Bind(&DriveFileSyncServiceSyncTest::FetchRemoteChange,
-                   base::Unretained(this)));
+  void RemoveLocal(const GURL& origin, const base::FilePath& path) {
+    ASSERT_TRUE(ContainsKey(file_systems_, origin));
+    EXPECT_EQ(base::PLATFORM_FILE_OK,
+              file_systems_[origin]->Remove(
+                  CreateSyncableFileSystemURL(origin, path),
+                  true /* recursive */));
+    FlushMessageLoop();
   }
 
-  SyncEvent CreateProcessRemoteChangeEvent() {
-    return SyncEvent(
-        "SyncEvent: Process remote change",
-        base::Bind(
-            base::IgnoreResult(
-                &DriveFileSyncServiceSyncTest::ProcessRemoteChange),
-            base::Unretained(this)));
+  std::string AddRemoteFolder(const std::string& parent_folder_id,
+                              const std::string& title) {
+    bool done = false;
+    google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+    scoped_ptr<google_apis::ResourceEntry> folder;
+    fake_drive_service_->AddNewDirectory(
+        parent_folder_id, title,
+        base::Bind(&ResourceEntryResultCallback, &done, &error, &folder));
+    FlushMessageLoop();
+    EXPECT_TRUE(done);
+    EXPECT_TRUE(error == google_apis::HTTP_SUCCESS ||
+                error == google_apis::HTTP_CREATED);
+    return folder->resource_id();
   }
 
-  template <size_t array_size>
-  std::vector<SyncEvent> CreateTestCase(const SyncEvent (&events)[array_size]) {
-    return std::vector<SyncEvent>(events, events + array_size);
-  }
+  std::string AddOrphanedRemoteFolder(const std::string& title) {
+    std::string root_folder_id = fake_drive_service_->GetRootResourceId();
+    std::string folder_id = AddRemoteFolder(root_folder_id, title);
 
-  void ShuffleTestCase(std::vector<SyncEvent>* events) {
-    std::random_shuffle(events->begin(), events->end(), base::RandGenerator);
+    bool done = false;
+    google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+    fake_drive_service_->RemoveResourceFromDirectory(
+        root_folder_id, folder_id,
+        base::Bind(&GDataErrorResultCallback, &done, &error));
+    FlushMessageLoop();
+    EXPECT_TRUE(done);
+    EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
+    return folder_id;
   }
 
-  void RunTest(const std::vector<SyncEvent>& events) {
-    base::ScopedTempDir scoped_base_dir_;
-    ASSERT_TRUE(scoped_base_dir_.CreateUniqueTempDir());
-    base_dir_ = scoped_base_dir_.path();
+  std::string AddRemoteFile(const std::string& parent_folder_id,
+                            const std::string& title,
+                            const std::string& content) {
+    base::FilePath temp_file = WriteToTempFile(content);
 
-    SetUpForTestCase();
+    bool done = false;
+    google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+    scoped_ptr<google_apis::ResourceEntry> file;
+    drive_uploader_->UploadNewFile(
+        parent_folder_id, temp_file, title,
+        "application/octet-stream",
+        base::Bind(&UploadResultCallback, &done, &error, &file),
+        google_apis::ProgressCallback());
+    FlushMessageLoop();
+    EXPECT_TRUE(done);
+    EXPECT_TRUE(error == google_apis::HTTP_SUCCESS ||
+                error == google_apis::HTTP_CREATED );
+    return file->resource_id();
+  }
 
-    typedef std::vector<SyncEvent>::const_iterator iterator;
-    std::ostringstream out;
-    out << '\n';
-    for (iterator itr = events.begin(); itr != events.end(); ++itr)
-      out << itr->description << '\n';
-    SCOPED_TRACE(out.str());
+  void UpdateRemoteFile(const std::string& file_id,
+                        const std::string& content) {
+    base::FilePath temp_file = WriteToTempFile(content);
 
-    for (iterator itr = events.begin(); itr != events.end(); ++itr)
-      itr->callback.Run();
+    bool done = false;
+    google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+    scoped_ptr<google_apis::ResourceEntry> file;
+    drive_uploader_->UploadExistingFile(
+        file_id, temp_file,
+        "application/octet-stream",
+        std::string(),  // etag
+        base::Bind(&UploadResultCallback, &done, &error, &file),
+        google_apis::ProgressCallback());
+
+    FlushMessageLoop();
+    EXPECT_TRUE(done);
+    EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
+  }
 
-    FetchRemoteChange();
-    while (ProcessRemoteChange()) {}
+  void RemoveRemote(const std::string& file_id) {
+    bool done = false;
+    google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+    fake_drive_service_->DeleteResource(
+        file_id,
+        std::string(), // etag
+        base::Bind(&GDataErrorResultCallback, &done, &error));
+    FlushMessageLoop();
+    EXPECT_TRUE(done);
+    EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
+  }
 
-    VerifyResult();
-    TearDownForTestCase();
+  SyncStatusCode ProcessLocalChange() {
+    bool done = false;
+    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
+    fileapi::FileSystemURL url;
+    local_sync_service_->ProcessLocalChange(
+        base::Bind(&SyncResultCallback, &done, &status, &url));
+    FlushMessageLoop();
+    EXPECT_TRUE(done);
+    if (status != SYNC_STATUS_NO_CHANGE_TO_SYNC)
+      local_sync_service_->ClearSyncFlagForURL(url);
+    return status;
+  }
 
-    base_dir_ = base::FilePath();
+  SyncStatusCode ProcessRemoteChange() {
+    bool done = false;
+    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
+    fileapi::FileSystemURL url;
+    remote_sync_service_->ProcessRemoteChange(
+        base::Bind(&SyncResultCallback, &done, &status, &url));
+    FlushMessageLoop();
+    EXPECT_TRUE(done);
+    if (status != SYNC_STATUS_NO_CHANGE_TO_SYNC)
+      local_sync_service_->ClearSyncFlagForURL(url);
+    return status;
   }
 
-  void AddFileTest_Body();
-  void UpdateFileTest_Body();
-  void DeleteFileTest_Body();
-  void RelaunchTest_Body();
-  void SquashedFileAddTest_Body();
-  void RelaunchTestWithSquashedDeletion_Body();
-  void CreateDirectoryTest_Body();
-  void DeleteDirectoryTest_Body();
+  SyncStatusCode ProcessChangesUntilDone() {
+    remote_sync_service_->OnNotificationReceived();
+    FlushMessageLoop();
+
+    SyncStatusCode local_sync_status;
+    SyncStatusCode remote_sync_status;
+    do {
+      local_sync_status = ProcessLocalChange();
+      if (local_sync_status != SYNC_STATUS_OK &&
+          local_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC)
+        return local_sync_status;
+
+      remote_sync_status = ProcessRemoteChange();
+      if (remote_sync_status != SYNC_STATUS_OK &&
+          remote_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC)
+        return remote_sync_status;
+    } while (local_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC &&
+             remote_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC);
+    return SYNC_STATUS_OK;
+  }
 
- private:
-  void SetUpForTestCase() {
-    fake_api_util_ = new drive::FakeAPIUtil;
-    fake_remote_processor_.reset(new FakeRemoteChangeProcessor);
+  void VerifyConsistency() {
+    std::string sync_root_folder_id = GetSyncRootFolderID();
+    if (sync_root_folder_id.empty()) {
+      EXPECT_TRUE(file_systems_.empty());
+      return;
+    }
 
-    metadata_store_ = new DriveMetadataStore(
-        base_dir_, base::MessageLoopProxy::current().get());
+    ScopedVector<google_apis::ResourceEntry> remote_entries =
+        ListFilesInRemoteFolder(sync_root_folder_id);
+    std::map<std::string, const google_apis::ResourceEntry*>
+        origin_root_by_title;
+    for (ScopedVector<google_apis::ResourceEntry>::iterator itr =
+             remote_entries.begin();
+         itr != remote_entries.end();
+         ++itr) {
+      const google_apis::ResourceEntry& remote_entry = **itr;
+      EXPECT_FALSE(ContainsKey(origin_root_by_title, remote_entry.title()));
+      origin_root_by_title[remote_entry.title()] = *itr;
+    }
 
-    bool done = false;
-    metadata_store_->Initialize(base::Bind(&DidInitialize, &done));
-    message_loop_.RunUntilIdle();
-    EXPECT_TRUE(done);
+    for (std::map<GURL, CannedSyncableFileSystem*>::const_iterator itr =
+             file_systems_.begin();
+         itr != file_systems_.end(); ++itr) {
+      const GURL& origin = itr->first;
+      SCOPED_TRACE(testing::Message() << "Verifying origin: " << origin);
+      CannedSyncableFileSystem* file_system = itr->second;
+      ASSERT_TRUE(ContainsKey(origin_root_by_title, origin.host()));
+      VerifyConsistencyForFolder(
+          origin, base::FilePath(),
+          origin_root_by_title[origin.host()]->resource_id(),
+          file_system);
+    }
+  }
 
-    metadata_store_->SetSyncRootDirectory(GetSyncRootResourceId());
-    metadata_store_->AddIncrementalSyncOrigin(GURL(kAppOrigin),
-                                              GetParentResourceId());
+  void VerifyConsistencyForOrigin(const GURL& origin) {
+    std::string sync_root_folder_id = GetSyncRootFolderID();
+    ASSERT_FALSE(sync_root_folder_id.empty());
 
-    sync_service_ = DriveFileSyncService::CreateForTesting(
-        &profile_,
-        base_dir_,
-        scoped_ptr<drive::APIUtilInterface>(fake_api_util_),
-        scoped_ptr<DriveMetadataStore>(metadata_store_)).Pass();
-    sync_service_->SetRemoteChangeProcessor(fake_remote_processor_.get());
-  }
+    ScopedVector<google_apis::ResourceEntry> origin_folder =
+        SearchByTitle(sync_root_folder_id, origin.host());
+    ASSERT_EQ(1u, origin_folder.size());
 
-  void TearDownForTestCase() {
-    metadata_store_ = NULL;
-    fake_api_util_ = NULL;
-    sync_service_.reset();
-    fake_remote_processor_.reset();
-    message_loop_.RunUntilIdle();
+    ASSERT_TRUE(ContainsKey(file_systems_, origin));
+    VerifyConsistencyForFolder(
+        origin, base::FilePath(),
+        origin_folder[0]->resource_id(),
+        file_systems_[origin]);
   }
 
-  void AddOrUpdateResource(const std::string& title,
-                           SyncFileType type) {
-    typedef ResourceIdByTitle::iterator iterator;
-    std::pair<iterator, bool> inserted =
-        resources_.insert(std::make_pair(title, std::string()));
-    if (inserted.second) {
-      switch (type) {
-        case SYNC_FILE_TYPE_UNKNOWN:
-          NOTREACHED();
-          break;
-        case SYNC_FILE_TYPE_FILE:
-          inserted.first->second = IsDriveAPIDisabled()
-              ? base::StringPrintf("file:%" PRId64, ++resource_count_)
-              : base::StringPrintf("%" PRId64, ++resource_count_);
-          break;
-        case SYNC_FILE_TYPE_DIRECTORY:
-          inserted.first->second = IsDriveAPIDisabled()
-              ? base::StringPrintf("folder:%" PRId64, ++resource_count_)
-              : base::StringPrintf("%" PRId64, ++resource_count_);
-          break;
+  void VerifyConsistencyForFolder(const GURL& origin,
+                                  const base::FilePath& path,
+                                  const std::string& folder_id,
+                                  CannedSyncableFileSystem* file_system) {
+    SCOPED_TRACE(testing::Message() << "Verifying path: " << path.value());
+
+    ScopedVector<google_apis::ResourceEntry> remote_entries =
+        ListFilesInRemoteFolder(folder_id);
+    std::map<std::string, const google_apis::ResourceEntry*>
+        remote_entry_by_title;
+    for (ScopedVector<google_apis::ResourceEntry>::iterator itr =
+             remote_entries.begin();
+         itr != remote_entries.end();
+         ++itr) {
+      const google_apis::ResourceEntry& remote_entry = **itr;
+      EXPECT_FALSE(ContainsKey(remote_entry_by_title, remote_entry.title()));
+      remote_entry_by_title[remote_entry.title()] = *itr;
+    }
+
+    fileapi::FileSystemURL url(CreateSyncableFileSystemURL(origin, path));
+    CannedSyncableFileSystem::FileEntryList local_entries;
+    EXPECT_EQ(base::PLATFORM_FILE_OK,
+              file_system->ReadDirectory(url, &local_entries));
+    for (CannedSyncableFileSystem::FileEntryList::iterator itr =
+             local_entries.begin();
+         itr != local_entries.end();
+         ++itr) {
+      const fileapi::DirectoryEntry& local_entry = *itr;
+      fileapi::FileSystemURL entry_url(
+          CreateSyncableFileSystemURL(origin, path.Append(local_entry.name)));
+      std::string title = DriveFileSyncService::PathToTitle(entry_url.path());
+      ASSERT_TRUE(ContainsKey(remote_entry_by_title, title));
+      const google_apis::ResourceEntry& remote_entry =
+          *remote_entry_by_title[title];
+      if (local_entry.is_directory) {
+        ASSERT_TRUE(remote_entry.is_folder());
+        VerifyConsistencyForFolder(origin, entry_url.path(),
+                                   remote_entry.resource_id(),
+                                   file_system);
+      } else {
+        ASSERT_TRUE(remote_entry.is_file());
+        VerifyConsistencyForFile(origin, entry_url.path(),
+                                 remote_entry.resource_id(),
+                                 file_system);
       }
+      remote_entry_by_title.erase(title);
     }
-    std::string resource_id = inserted.first->second;
-    std::string md5_checksum;
-    if (type == SYNC_FILE_TYPE_FILE)
-      md5_checksum = base::StringPrintf("%" PRIx64, base::RandUint64());
-
-    fake_api_util_->PushRemoteChange(GetParentResourceId(),
-                                     kAppId,
-                                     title,
-                                     resource_id,
-                                     md5_checksum,
-                                     type,
-                                     false /* deleted */);
-    message_loop_.RunUntilIdle();
-  }
 
-  void DeleteResource(const std::string& title) {
-    ResourceIdByTitle::iterator found = resources_.find(title);
-    if (found == resources_.end())
-      return;
-    std::string resource_id = found->second;
-    resources_.erase(found);
-    fake_api_util_->PushRemoteChange(GetParentResourceId(),
-                                     kAppId,
-                                     title,
-                                     resource_id,
-                                     std::string(),
-                                     SYNC_FILE_TYPE_UNKNOWN,
-                                     true /* deleted */);
-    message_loop_.RunUntilIdle();
+    EXPECT_TRUE(remote_entry_by_title.empty());
   }
 
-  void RelaunchService() {
-    metadata_store_ = NULL;
-    scoped_ptr<drive::APIUtilInterface> api_util =
-        DriveFileSyncService::DestroyAndPassAPIUtilForTesting(
-            sync_service_.Pass());
-    message_loop_.RunUntilIdle();
+  void VerifyConsistencyForFile(const GURL& origin,
+                                const base::FilePath& path,
+                                const std::string& file_id,
+                                CannedSyncableFileSystem* file_system) {
+    // TODO(tzik): Verify file content after FakeDriveService supports
+    // file contents upload.
 
-    metadata_store_ = new DriveMetadataStore(
-        base_dir_, base::MessageLoopProxy::current().get());
+    scoped_ptr<google_apis::ResourceEntry> entry = GetRemoteFile(file_id);
 
-    bool done = false;
-    metadata_store_->Initialize(base::Bind(&DidInitialize, &done));
-    message_loop_.RunUntilIdle();
-    EXPECT_TRUE(done);
+    fileapi::FileSystemURL url(CreateSyncableFileSystemURL(origin, path));
+    base::PlatformFileInfo info;
+    base::FilePath platform_path;
+    EXPECT_EQ(base::PLATFORM_FILE_OK,
+              file_system->GetMetadataAndPlatformPath(
+                  url, &info, &platform_path));
 
-    sync_service_ = DriveFileSyncService::CreateForTesting(
-        &profile_,
-        base_dir_,
-        api_util.Pass(),
-        scoped_ptr<DriveMetadataStore>(metadata_store_)).Pass();
-    sync_service_->SetRemoteChangeProcessor(fake_remote_processor_.get());
+    EXPECT_EQ(info.size, entry->file_size());
   }
 
-  void FetchRemoteChange() {
-    sync_service_->may_have_unfetched_changes_ = true;
-    sync_service_->MaybeStartFetchChanges();
-    message_loop_.RunUntilIdle();
+  std::string GetSyncRootFolderID() {
+    bool done = false;
+    google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+    scoped_ptr<google_apis::ResourceList> resource_list;
+    fake_drive_service_->SearchByTitle(
+        drive::APIUtil::GetSyncRootDirectoryName(), std::string(),
+        base::Bind(&ResourceListResultCallback, &done, &error, &resource_list));
+    FlushMessageLoop();
+    EXPECT_TRUE(done);
+    EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
+
+    const ScopedVector<google_apis::ResourceEntry>& entries =
+        resource_list->entries();
+    for (ScopedVector<google_apis::ResourceEntry>::const_iterator itr =
+             entries.begin(); itr != entries.end(); ++itr) {
+      const google_apis::ResourceEntry& entry = **itr;
+      if (!entry.GetLinkByType(google_apis::Link::LINK_PARENT))
+        return entry.resource_id();
+    }
+    return std::string();
   }
 
-  bool ProcessRemoteChange() {
+  ScopedVector<google_apis::ResourceEntry> ListFilesInRemoteFolder(
+      const std::string& folder_id) {
     bool done = false;
-    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    sync_service_->ProcessRemoteChange(
-        base::Bind(&DidProcessRemoteChange, &done, &status));
-    message_loop_.RunUntilIdle();
+    google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+    scoped_ptr<google_apis::ResourceList> list;
+    fake_drive_service_->GetResourceListInDirectory(
+        folder_id,
+        base::Bind(&ResourceListResultCallback, &done, &error, &list));
+    FlushMessageLoop();
     EXPECT_TRUE(done);
-    return status != SYNC_STATUS_NO_CHANGE_TO_SYNC;
+    EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
+
+    return CompleteListing(list.Pass());
   }
 
+  ScopedVector<google_apis::ResourceEntry> SearchByTitle(
+      const std::string& folder_id,
+      const std::string& title) {
+    bool done = false;
+    google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+    scoped_ptr<google_apis::ResourceList> list;
+    fake_drive_service_->SearchByTitle(
+        title, folder_id,
+        base::Bind(&ResourceListResultCallback, &done, &error, &list));
+    FlushMessageLoop();
+    EXPECT_TRUE(done);
+    EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
+
+    return CompleteListing(list.Pass());
+  }
 
-  void VerifyResult() {
-    typedef drive::FakeAPIUtil::RemoteResourceByResourceId RemoteResourceMap;
-    typedef drive::FakeAPIUtil::RemoteResource RemoteResource;
-    typedef FakeRemoteChangeProcessor::URLToFileChangesMap
-        AppliedRemoteChangeMap;
-
-    const RemoteResourceMap& remote_resources =
-        fake_api_util_->remote_resources();
-    const AppliedRemoteChangeMap applied_changes =
-        fake_remote_processor_->GetAppliedRemoteChanges();
-
-    std::set<std::string> local_resources;
-    for (AppliedRemoteChangeMap::const_iterator itr = applied_changes.begin();
-         itr != applied_changes.end(); ++itr) {
-      const fileapi::FileSystemURL& url = itr->first;
-      const FileChange& applied_change = itr->second.back();
-
-      DriveMetadata metadata;
-      SyncStatusCode status = metadata_store_->ReadEntry(itr->first, &metadata);
-      if (applied_change.IsDelete()) {
-        EXPECT_EQ(SYNC_DATABASE_ERROR_NOT_FOUND, status);
-        continue;
+  ScopedVector<google_apis::ResourceEntry> CompleteListing(
+      scoped_ptr<google_apis::ResourceList> list) {
+    ScopedVector<google_apis::ResourceEntry> result;
+    while (true) {
+      result.reserve(result.size() + list->entries().size());
+      for (ScopedVector<google_apis::ResourceEntry>::iterator itr =
+               list->mutable_entries()->begin();
+           itr != list->mutable_entries()->end(); ++itr) {
+        result.push_back(*itr);
+        *itr = NULL;
       }
 
-      EXPECT_EQ(SYNC_STATUS_OK, status);
-      EXPECT_FALSE(metadata.resource_id().empty());
-      EXPECT_FALSE(metadata.conflicted());
-      EXPECT_FALSE(metadata.to_be_fetched());
-      EXPECT_TRUE(metadata.type() == DriveMetadata::RESOURCE_TYPE_FOLDER ||
-                  !metadata.md5_checksum().empty());
-
-      RemoteResourceMap::const_iterator found =
-          remote_resources.find(metadata.resource_id());
-      ASSERT_TRUE(found != remote_resources.end());
-      const RemoteResource& remote_resource = found->second;
-
-      EXPECT_EQ(base::FilePath::FromUTF8Unsafe(remote_resource.title),
-                url.path());
-      EXPECT_EQ(remote_resource.md5_checksum, metadata.md5_checksum());
-      EXPECT_FALSE(remote_resource.deleted);
-
-      EXPECT_TRUE(local_resources.insert(metadata.resource_id()).second);
+      GURL next_feed;
+      if (!list->GetNextFeedURL(&next_feed))
+        return result.Pass();
+
+      bool done = false;
+      google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+      list.reset();
+      fake_drive_service_->ContinueGetResourceList(
+          next_feed,
+          base::Bind(&ResourceListResultCallback, &done, &error, &list));
+      FlushMessageLoop();
+      EXPECT_TRUE(done);
+      EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
     }
+  }
 
-    for (RemoteResourceMap::const_iterator itr = remote_resources.begin();
-         itr != remote_resources.end(); ++itr) {
-      if (!itr->second.deleted)
-        EXPECT_TRUE(ContainsKey(local_resources, itr->first));
-      else
-        EXPECT_FALSE(ContainsKey(local_resources, itr->first));
-    }
+  scoped_ptr<google_apis::ResourceEntry> GetRemoteFile(
+      const std::string& file_id) {
+    bool done = false;
+    google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
+
+    scoped_ptr<google_apis::ResourceEntry> file;
+    fake_drive_service_->GetResourceEntry(
+        file_id,
+        base::Bind(&ResourceEntryResultCallback, &done, &error, &file));
+    FlushMessageLoop();
+    return file.Pass();
   }
 
-  base::MessageLoop message_loop_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread file_thread_;
+  base::FilePath WriteToTempFile(const std::string& content) {
+    base::FilePath temp_file;
+    EXPECT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_, &temp_file));
+    EXPECT_EQ(static_cast<int>(content.size()),
+              file_util::WriteFile(temp_file, content.data(), content.size()));
+    return temp_file;
+  }
 
-  TestingProfile profile_;
-  base::FilePath base_dir_;
+  void FlushMessageLoop() {
+    base::MessageLoop::current()->RunUntilIdle();
+    BrowserThread::GetBlockingPool()->FlushForTesting();
+    base::MessageLoop::current()->RunUntilIdle();
+  }
 
-  drive::FakeAPIUtil* fake_api_util_;  // Owned by |sync_service_|.
-  scoped_ptr<FakeRemoteChangeProcessor> fake_remote_processor_;
-  DriveMetadataStore* metadata_store_;  // Owned by |sync_service_|.
+  void TestInitialization();
+  void TestLocalToRemoteBasic();
+  void TestRemoteToLocalBasic();
+  void TestLocalFileUpdate();
+  void TestRemoteFileUpdate();
+  void TestLocalFileDeletion();
+  void TestRemoteFileDeletion();
 
-  scoped_ptr<DriveFileSyncService> sync_service_;
+  content::TestBrowserThreadBundle thread_bundle_;
 
-  typedef std::map<std::string, std::string> ResourceIdByTitle;
-  ResourceIdByTitle resources_;
-  int64 resource_count_;
+  TestingProfile profile_;
+  base::ScopedTempDir base_dir_;
+  base::FilePath temp_dir_;
+
+  ::drive::FakeDriveService* fake_drive_service_;
+  ::drive::DriveUploader* drive_uploader_;
+  std::map<GURL, CannedSyncableFileSystem*> file_systems_;
+
+  scoped_ptr<DriveFileSyncService> remote_sync_service_;
+  scoped_ptr<LocalFileSyncService> local_sync_service_;
 
   DISALLOW_COPY_AND_ASSIGN(DriveFileSyncServiceSyncTest);
 };
 
-void DriveFileSyncServiceSyncTest::AddFileTest_Body() {
-  std::string kFile1 = "file title 1";
-  SyncEvent sync_event[] = {
-    CreateRemoteFileAddOrUpdateEvent(kFile1),
-  };
-
-  RunTest(CreateTestCase(sync_event));
+void DriveFileSyncServiceSyncTest::TestInitialization() {
+  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
+  VerifyConsistency();
 }
 
-void DriveFileSyncServiceSyncTest::UpdateFileTest_Body() {
-  std::string kFile1 = "file title 1";
-  SyncEvent sync_event[] = {
-    CreateRemoteFileAddOrUpdateEvent(kFile1),
-    CreateRemoteFileAddOrUpdateEvent(kFile1),
-  };
+void DriveFileSyncServiceSyncTest::TestLocalToRemoteBasic() {
+  const GURL kOrigin("chrome-extension://example");
 
-  RunTest(CreateTestCase(sync_event));
+  RegisterOrigin(kOrigin);
+  AddOrUpdateLocalFile(kOrigin, base::FilePath(FPL("file")), "abcde");
+
+  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
+  VerifyConsistency();
 }
 
-void DriveFileSyncServiceSyncTest::DeleteFileTest_Body() {
-  std::string kFile1 = "file title 1";
-  SyncEvent sync_event[] = {
-    CreateRemoteFileAddOrUpdateEvent(kFile1),
-    CreateFetchEvent(),
-    CreateProcessRemoteChangeEvent(),
-    CreateRemoteFileDeleteEvent(kFile1),
-  };
+void DriveFileSyncServiceSyncTest::TestRemoteToLocalBasic() {
+  const GURL kOrigin("chrome-extension://example");
 
-  RunTest(CreateTestCase(sync_event));
-}
+  std::string sync_root_folder_id =
+      AddOrphanedRemoteFolder(drive::APIUtil::GetSyncRootDirectoryName());
+  std::string origin_root_folder_id =
+      AddRemoteFolder(sync_root_folder_id, kOrigin.host());
 
-void DriveFileSyncServiceSyncTest::RelaunchTest_Body() {
-  SyncEvent sync_event[] = {
-    CreateRelaunchEvent(),
-  };
+  RegisterOrigin(kOrigin);
+  AddRemoteFile(origin_root_folder_id, "file", "abcde");
 
-  RunTest(CreateTestCase(sync_event));
+  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
+  VerifyConsistency();
 }
 
-void DriveFileSyncServiceSyncTest::SquashedFileAddTest_Body() {
-  std::string kFile1 = "file title 1";
-  SyncEvent sync_event[] = {
-    CreateRemoteFileAddOrUpdateEvent(kFile1),
-    CreateFetchEvent(),
-    CreateRemoteFileDeleteEvent(kFile1),
-  };
-  RunTest(CreateTestCase(sync_event));
-}
+void DriveFileSyncServiceSyncTest::TestLocalFileUpdate() {
+  const GURL kOrigin("chrome-extension://example");
+  const base::FilePath kPath(FPL("file"));
 
-void DriveFileSyncServiceSyncTest::RelaunchTestWithSquashedDeletion_Body() {
-  std::string kFile1 = "file title 1";
-  std::string kFile2 = "file title 2";
-  SyncEvent sync_event[] = {
-    CreateRemoteFileAddOrUpdateEvent(kFile1),
-    CreateFetchEvent(),
-    CreateProcessRemoteChangeEvent(),
-
-    CreateRemoteFileDeleteEvent(kFile1),
-    CreateRemoteFileAddOrUpdateEvent(kFile2),
-    CreateRemoteFileAddOrUpdateEvent(kFile1),
-
-    CreateFetchEvent(),
-    CreateProcessRemoteChangeEvent(),
-    CreateRelaunchEvent(),
-  };
-  RunTest(CreateTestCase(sync_event));
-}
+  RegisterOrigin(kOrigin);
+  AddOrUpdateLocalFile(kOrigin, kPath, "abcde");
 
-void DriveFileSyncServiceSyncTest::CreateDirectoryTest_Body() {
-  std::string kDir = "dir title";
-  SyncEvent sync_event[] = {
-    CreateRemoteDirectoryAddEvent(kDir),
-  };
-  RunTest(CreateTestCase(sync_event));
-}
+  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
+  VerifyConsistencyForOrigin(kOrigin);
 
-void DriveFileSyncServiceSyncTest::DeleteDirectoryTest_Body() {
-  std::string kDir = "dir title";
-  SyncEvent sync_event[] = {
-    CreateRemoteDirectoryAddEvent(kDir),
-    CreateRemoteFileDeleteEvent(kDir),
-  };
-  RunTest(CreateTestCase(sync_event));
-}
+  UpdateLocalFile(kOrigin, kPath, "1234567890");
 
-TEST_F(DriveFileSyncServiceSyncTest, AddFileTest) {
-  ASSERT_FALSE(IsDriveAPIDisabled());
-  AddFileTest_Body();
+  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
+  VerifyConsistency();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, AddFileTest_WAPI) {
-  SetDisableDriveAPI(true);
-  AddFileTest_Body();
-}
+void DriveFileSyncServiceSyncTest::TestRemoteFileUpdate() {
+  const GURL kOrigin("chrome-extension://example");
+  const base::FilePath kPath(FPL("file"));
+  const std::string kTitle(DriveFileSyncService::PathToTitle(kPath));
 
-TEST_F(DriveFileSyncServiceSyncTest, UpdateFileTest) {
-  ASSERT_FALSE(IsDriveAPIDisabled());
-  UpdateFileTest_Body();
+  std::string sync_root_folder_id =
+      AddOrphanedRemoteFolder(drive::APIUtil::GetSyncRootDirectoryName());
+  std::string origin_root_folder_id =
+      AddRemoteFolder(sync_root_folder_id, kOrigin.host());
+  std::string remote_file_id =
+      AddRemoteFile(origin_root_folder_id, kTitle, "abcde");
+
+  RegisterOrigin(kOrigin);
+  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
+  VerifyConsistencyForOrigin(kOrigin);
+
+  UpdateRemoteFile(remote_file_id, "1234567890");
+
+  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
+  VerifyConsistency();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, UpdateFileTest_WAPI) {
-  SetDisableDriveAPI(true);
-  UpdateFileTest_Body();
+void DriveFileSyncServiceSyncTest::TestLocalFileDeletion() {
+  const GURL kOrigin("chrome-extension://example");
+  const base::FilePath kPath(FPL("file"));
+
+  RegisterOrigin(kOrigin);
+  AddOrUpdateLocalFile(kOrigin, kPath, "abcde");
+
+  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
+  VerifyConsistencyForOrigin(kOrigin);
+
+  RemoveLocal(kOrigin, kPath);
+
+  EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
+  VerifyConsistency();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, DeleteFileTest) {
+TEST_F(DriveFileSyncServiceSyncTest, InitializationTest) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  DeleteFileTest_Body();
+  TestInitialization();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, DeleteFileTest_WAPI) {
-  SetDisableDriveAPI(true);
-  DeleteFileTest_Body();
+TEST_F(DriveFileSyncServiceSyncTest, InitializationTest_WAPI) {
+  ScopedDisableDriveAPI disable_drive_api;
+  TestInitialization();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, RelaunchTest) {
+TEST_F(DriveFileSyncServiceSyncTest, LocalToRemoteBasicTest) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  RelaunchTest_Body();
+  TestLocalToRemoteBasic();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, RelaunchTest_WAPI) {
-  SetDisableDriveAPI(true);
-  RelaunchTest_Body();
+TEST_F(DriveFileSyncServiceSyncTest, LocalToRemoteBasicTest_WAPI) {
+  ScopedDisableDriveAPI disable_drive_api;
+  TestLocalToRemoteBasic();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, SquashedFileAddTest) {
+TEST_F(DriveFileSyncServiceSyncTest, RemoteToLocalBasicTest) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  SquashedFileAddTest_Body();
+  TestRemoteToLocalBasic();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, SquashedFileAddTest_WAPI) {
-  SetDisableDriveAPI(true);
-  SquashedFileAddTest_Body();
+TEST_F(DriveFileSyncServiceSyncTest, RemoteToLocalBasicTest_WAPI) {
+  ScopedDisableDriveAPI disable_drive_api;
+  TestRemoteToLocalBasic();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, RelaunchTestWithSquashedDeletion) {
+TEST_F(DriveFileSyncServiceSyncTest, LocalFileUpdateTest) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  RelaunchTestWithSquashedDeletion_Body();
+  TestLocalFileUpdate();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, RelaunchTestWithSquashedDeletion_WAPI) {
-  SetDisableDriveAPI(true);
-  RelaunchTestWithSquashedDeletion_Body();
+TEST_F(DriveFileSyncServiceSyncTest, LocalFileUpdateTest_WAPI) {
+  ScopedDisableDriveAPI disable_drive_api;
+  TestLocalFileUpdate();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, CreateDirectoryTest) {
+TEST_F(DriveFileSyncServiceSyncTest, RemoteFileUpdateTest) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  CreateDirectoryTest_Body();
+  TestRemoteFileUpdate();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, CreateDirectoryTest_WAPI) {
-  SetDisableDriveAPI(true);
-  CreateDirectoryTest_Body();
+TEST_F(DriveFileSyncServiceSyncTest, RemoteFileUpdateTest_WAPI) {
+  ScopedDisableDriveAPI disable_drive_api;
+  TestRemoteFileUpdate();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, DeleteDirectoryTest) {
+TEST_F(DriveFileSyncServiceSyncTest, LocalFileDeletionTest) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  DeleteDirectoryTest_Body();
+  TestLocalFileDeletion();
 }
 
-TEST_F(DriveFileSyncServiceSyncTest, DeleteDirectoryTest_WAPI) {
-  SetDisableDriveAPI(true);
-  DeleteDirectoryTest_Body();
+TEST_F(DriveFileSyncServiceSyncTest, LocalFileDeletionTest_WAPI) {
+  ScopedDisableDriveAPI disable_drive_api;
+  TestLocalFileDeletion();
 }
 
 }  // namespace sync_file_system
diff --git a/chrome/chrome_tests_unit.gypi b/chrome/chrome_tests_unit.gypi
index 18f9026..502d6c7 100644
--- a/chrome/chrome_tests_unit.gypi
+++ b/chrome/chrome_tests_unit.gypi
@@ -2365,6 +2365,7 @@
             'browser/google_apis/drive_api_requests_unittest.cc',
             'browser/google_apis/gdata_wapi_requests_unittest.cc',
             'browser/google_apis/gdata_wapi_parser_unittest.cc',
+            'browser/sync_file_system/drive_file_sync_service_sync_unittest.cc',
 
             'browser/user_style_sheet_watcher_unittest.cc',