Home | History | Annotate | Download | only in drive_backend 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/sync_file_system/drive_backend/drive_file_sync_service.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/file_util.h"
     10 #include "base/message_loop/message_loop.h"
     11 #include "base/stl_util.h"
     12 #include "base/strings/stringprintf.h"
     13 #include "base/strings/utf_string_conversions.h"
     14 #include "base/threading/sequenced_worker_pool.h"
     15 #include "chrome/browser/drive/drive_uploader.h"
     16 #include "chrome/browser/drive/fake_drive_service.h"
     17 #include "chrome/browser/sync_file_system/drive_backend/api_util.h"
     18 #include "chrome/browser/sync_file_system/drive_backend/drive_file_sync_util.h"
     19 #include "chrome/browser/sync_file_system/drive_backend/drive_metadata_store.h"
     20 #include "chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.h"
     21 #include "chrome/browser/sync_file_system/fake_remote_change_processor.h"
     22 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
     23 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
     24 #include "chrome/browser/sync_file_system/local/local_file_sync_service.h"
     25 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
     26 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
     27 #include "chrome/test/base/testing_profile.h"
     28 #include "content/public/test/test_browser_thread.h"
     29 #include "content/public/test/test_browser_thread_bundle.h"
     30 #include "testing/gtest/include/gtest/gtest.h"
     31 #include "webkit/browser/fileapi/file_system_context.h"
     32 
     33 #define FPL(path) FILE_PATH_LITERAL(path)
     34 
     35 using content::BrowserThread;
     36 
     37 using google_apis::GDataErrorCode;
     38 using google_apis::ResourceEntry;
     39 
     40 namespace sync_file_system {
     41 
     42 using drive_backend::APIUtil;
     43 using drive_backend::APIUtilInterface;
     44 using drive_backend::FakeDriveServiceHelper;
     45 
     46 namespace {
     47 
     48 void SyncResultCallback(bool* done,
     49                         SyncStatusCode* status_out,
     50                         fileapi::FileSystemURL* url_out,
     51                         SyncStatusCode status,
     52                         const fileapi::FileSystemURL& url) {
     53   EXPECT_FALSE(*done);
     54   *status_out = status;
     55   *url_out = url;
     56   *done = true;
     57 }
     58 
     59 void SyncStatusResultCallback(bool* done,
     60                               SyncStatusCode* status_out,
     61                               SyncStatusCode status) {
     62   EXPECT_FALSE(*done);
     63   *status_out = status;
     64   *done = true;
     65 }
     66 
     67 void DatabaseInitResultCallback(bool* done,
     68                                 SyncStatusCode* status_out,
     69                                 bool* created_out,
     70                                 SyncStatusCode status,
     71                                 bool created) {
     72   EXPECT_FALSE(*done);
     73   *status_out = status;
     74   *created_out = created;
     75   *done = true;
     76 }
     77 
     78 }  // namespace
     79 
     80 class DriveFileSyncServiceSyncTest : public testing::Test {
     81  public:
     82   DriveFileSyncServiceSyncTest()
     83       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
     84 
     85   virtual ~DriveFileSyncServiceSyncTest() {
     86   }
     87 
     88   virtual void SetUp() OVERRIDE {
     89     // TODO(tzik): Set up TestExtensionSystem to support simulated relaunch.
     90 
     91     RegisterSyncableFileSystem();
     92     local_sync_service_.reset(new LocalFileSyncService(&profile_));
     93 
     94     fake_drive_service_ = new drive::FakeDriveService();
     95     fake_drive_service_->Initialize();
     96     ASSERT_TRUE(fake_drive_service_->LoadAccountMetadataForWapi(
     97         "sync_file_system/account_metadata.json"));
     98     ASSERT_TRUE(fake_drive_service_->LoadResourceListForWapi(
     99         "gdata/root_feed.json"));
    100 
    101     drive_uploader_ = new drive::DriveUploader(
    102         fake_drive_service_, base::MessageLoopProxy::current().get());
    103 
    104     fake_drive_helper_.reset(new FakeDriveServiceHelper(
    105         fake_drive_service_, drive_uploader_));
    106 
    107     bool done = false;
    108     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    109     bool created = false;
    110     scoped_ptr<DriveMetadataStore> metadata_store(
    111         new DriveMetadataStore(fake_drive_helper_->base_dir_path(),
    112                                base::MessageLoopProxy::current().get()));
    113     metadata_store->Initialize(
    114         base::Bind(&DatabaseInitResultCallback, &done, &status, &created));
    115     FlushMessageLoop();
    116     EXPECT_TRUE(done);
    117     EXPECT_EQ(SYNC_STATUS_OK, status);
    118     EXPECT_TRUE(created);
    119 
    120     scoped_ptr<APIUtil> api_util(APIUtil::CreateForTesting(
    121         fake_drive_helper_->base_dir_path().AppendASCII("tmp"),
    122         scoped_ptr<drive::DriveServiceInterface>(fake_drive_service_),
    123         scoped_ptr<drive::DriveUploaderInterface>(drive_uploader_)));
    124 
    125     remote_sync_service_ = DriveFileSyncService::CreateForTesting(
    126         &profile_,
    127         fake_drive_helper_->base_dir_path(),
    128         api_util.PassAs<APIUtilInterface>(),
    129         metadata_store.Pass());
    130 
    131     local_sync_service_->SetLocalChangeProcessor(remote_sync_service_.get());
    132     remote_sync_service_->SetRemoteChangeProcessor(local_sync_service_.get());
    133   }
    134 
    135   virtual void TearDown() OVERRIDE {
    136     drive_uploader_ = NULL;
    137     fake_drive_service_ = NULL;
    138     remote_sync_service_.reset();
    139     local_sync_service_.reset();
    140     FlushMessageLoop();
    141 
    142     typedef std::map<GURL, CannedSyncableFileSystem*>::iterator iterator;
    143     for (iterator itr = file_systems_.begin();
    144          itr != file_systems_.end(); ++itr) {
    145       itr->second->TearDown();
    146       delete itr->second;
    147     }
    148     file_systems_.clear();
    149 
    150     FlushMessageLoop();
    151     RevokeSyncableFileSystem();
    152   }
    153 
    154  protected:
    155   void RegisterOrigin(const GURL& origin) {
    156     if (!ContainsKey(file_systems_, origin)) {
    157       CannedSyncableFileSystem* file_system = new CannedSyncableFileSystem(
    158           origin,
    159           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get(),
    160           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)
    161               .get());
    162 
    163       bool done = false;
    164       SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    165       file_system->SetUp();
    166       local_sync_service_->MaybeInitializeFileSystemContext(
    167           origin, file_system->file_system_context(),
    168           base::Bind(&SyncStatusResultCallback, &done, &status));
    169       FlushMessageLoop();
    170       EXPECT_TRUE(done);
    171       EXPECT_EQ(SYNC_STATUS_OK, status);
    172 
    173       file_system->backend()->sync_context()->
    174           set_mock_notify_changes_duration_in_sec(0);
    175 
    176       EXPECT_EQ(base::PLATFORM_FILE_OK, file_system->OpenFileSystem());
    177       file_systems_[origin] = file_system;
    178     }
    179 
    180     bool done = false;
    181     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    182     remote_sync_service_->RegisterOriginForTrackingChanges(
    183         origin, base::Bind(&SyncStatusResultCallback, &done, &status));
    184     FlushMessageLoop();
    185     EXPECT_TRUE(done);
    186     EXPECT_EQ(SYNC_STATUS_OK, status);
    187   }
    188 
    189   void AddLocalFolder(const GURL& origin,
    190                       const base::FilePath& path) {
    191     ASSERT_TRUE(ContainsKey(file_systems_, origin));
    192     EXPECT_EQ(base::PLATFORM_FILE_OK,
    193               file_systems_[origin]->CreateDirectory(
    194                   CreateSyncableFileSystemURL(origin, path)));
    195   }
    196 
    197   void AddOrUpdateLocalFile(const GURL& origin,
    198                             const base::FilePath& path,
    199                             const std::string& content) {
    200     fileapi::FileSystemURL url(CreateSyncableFileSystemURL(origin, path));
    201     ASSERT_TRUE(ContainsKey(file_systems_, origin));
    202     EXPECT_EQ(base::PLATFORM_FILE_OK, file_systems_[origin]->CreateFile(url));
    203     int64 bytes_written = file_systems_[origin]->WriteString(url, content);
    204     EXPECT_EQ(static_cast<int64>(content.size()), bytes_written);
    205     FlushMessageLoop();
    206   }
    207 
    208   void UpdateLocalFile(const GURL& origin,
    209                        const base::FilePath& path,
    210                        const std::string& content) {
    211     ASSERT_TRUE(ContainsKey(file_systems_, origin));
    212     int64 bytes_written = file_systems_[origin]->WriteString(
    213         CreateSyncableFileSystemURL(origin, path), content);
    214     EXPECT_EQ(static_cast<int64>(content.size()), bytes_written);
    215     FlushMessageLoop();
    216   }
    217 
    218   void RemoveLocal(const GURL& origin, const base::FilePath& path) {
    219     ASSERT_TRUE(ContainsKey(file_systems_, origin));
    220     EXPECT_EQ(base::PLATFORM_FILE_OK,
    221               file_systems_[origin]->Remove(
    222                   CreateSyncableFileSystemURL(origin, path),
    223                   true /* recursive */));
    224     FlushMessageLoop();
    225   }
    226 
    227   SyncStatusCode ProcessLocalChange() {
    228     bool done = false;
    229     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    230     fileapi::FileSystemURL url;
    231     local_sync_service_->ProcessLocalChange(
    232         base::Bind(&SyncResultCallback, &done, &status, &url));
    233     FlushMessageLoop();
    234     EXPECT_TRUE(done);
    235     if (status != SYNC_STATUS_NO_CHANGE_TO_SYNC)
    236       local_sync_service_->ClearSyncFlagForURL(url);
    237     return status;
    238   }
    239 
    240   SyncStatusCode ProcessRemoteChange() {
    241     bool done = false;
    242     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
    243     fileapi::FileSystemURL url;
    244     remote_sync_service_->ProcessRemoteChange(
    245         base::Bind(&SyncResultCallback, &done, &status, &url));
    246     FlushMessageLoop();
    247     EXPECT_TRUE(done);
    248     if (status != SYNC_STATUS_NO_CHANGE_TO_SYNC)
    249       local_sync_service_->ClearSyncFlagForURL(url);
    250     return status;
    251   }
    252 
    253   SyncStatusCode ProcessChangesUntilDone() {
    254     remote_sync_service_->OnNotificationReceived();
    255     FlushMessageLoop();
    256 
    257     SyncStatusCode local_sync_status;
    258     SyncStatusCode remote_sync_status;
    259     do {
    260       local_sync_status = ProcessLocalChange();
    261       if (local_sync_status != SYNC_STATUS_OK &&
    262           local_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC)
    263         return local_sync_status;
    264 
    265       remote_sync_status = ProcessRemoteChange();
    266       if (remote_sync_status != SYNC_STATUS_OK &&
    267           remote_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC)
    268         return remote_sync_status;
    269     } while (local_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC &&
    270              remote_sync_status != SYNC_STATUS_NO_CHANGE_TO_SYNC);
    271     return SYNC_STATUS_OK;
    272   }
    273 
    274   // Verifies local and remote files/folders are consistent.
    275   // This function checks:
    276   //  - Each registered origin has corresponding remote folder.
    277   //  - Each local file/folder has corresponding remote one.
    278   //  - Each remote file/folder has corresponding local one.
    279   // TODO(tzik): Handle conflict case. i.e. allow remote file has different
    280   // file content if the corresponding local file conflicts to it.
    281   void VerifyConsistency() {
    282     std::string sync_root_folder_id;
    283     GDataErrorCode error =
    284         fake_drive_helper_->GetSyncRootFolderID(&sync_root_folder_id);
    285     if (sync_root_folder_id.empty()) {
    286       EXPECT_EQ(google_apis::HTTP_NOT_FOUND, error);
    287       EXPECT_TRUE(file_systems_.empty());
    288       return;
    289     }
    290     EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
    291 
    292     ScopedVector<ResourceEntry> remote_entries;
    293     EXPECT_EQ(google_apis::HTTP_SUCCESS,
    294               fake_drive_helper_->ListFilesInFolder(
    295                   sync_root_folder_id, &remote_entries));
    296     std::map<std::string, const ResourceEntry*> origin_root_by_title;
    297     for (ScopedVector<ResourceEntry>::iterator itr = remote_entries.begin();
    298          itr != remote_entries.end();
    299          ++itr) {
    300       const ResourceEntry& remote_entry = **itr;
    301       EXPECT_FALSE(ContainsKey(origin_root_by_title, remote_entry.title()));
    302       origin_root_by_title[remote_entry.title()] = *itr;
    303     }
    304 
    305     for (std::map<GURL, CannedSyncableFileSystem*>::const_iterator itr =
    306              file_systems_.begin();
    307          itr != file_systems_.end(); ++itr) {
    308       const GURL& origin = itr->first;
    309       SCOPED_TRACE(testing::Message() << "Verifying origin: " << origin);
    310       CannedSyncableFileSystem* file_system = itr->second;
    311       ASSERT_TRUE(ContainsKey(origin_root_by_title, origin.host()));
    312       VerifyConsistencyForFolder(
    313           origin, base::FilePath(),
    314           origin_root_by_title[origin.host()]->resource_id(),
    315           file_system);
    316     }
    317   }
    318 
    319   void VerifyConsistencyForOrigin(const GURL& origin) {
    320     std::string sync_root_folder_id;
    321     ASSERT_EQ(google_apis::HTTP_SUCCESS,
    322               fake_drive_helper_->GetSyncRootFolderID(&sync_root_folder_id));
    323     ASSERT_FALSE(sync_root_folder_id.empty());
    324 
    325     ScopedVector<ResourceEntry> origin_folder;
    326     EXPECT_EQ(google_apis::HTTP_SUCCESS,
    327               fake_drive_helper_->SearchByTitle(
    328                   sync_root_folder_id, origin.host(), &origin_folder));
    329     ASSERT_EQ(1u, origin_folder.size());
    330 
    331     ASSERT_TRUE(ContainsKey(file_systems_, origin));
    332     VerifyConsistencyForFolder(
    333         origin, base::FilePath(),
    334         origin_folder[0]->resource_id(),
    335         file_systems_[origin]);
    336   }
    337 
    338   void VerifyConsistencyForFolder(const GURL& origin,
    339                                   const base::FilePath& path,
    340                                   const std::string& folder_id,
    341                                   CannedSyncableFileSystem* file_system) {
    342     SCOPED_TRACE(testing::Message() << "Verifying path: " << path.value());
    343 
    344     ScopedVector<ResourceEntry> remote_entries;
    345     EXPECT_EQ(google_apis::HTTP_SUCCESS,
    346               fake_drive_helper_->ListFilesInFolder(
    347                   folder_id, &remote_entries));
    348     std::map<std::string, const ResourceEntry*> remote_entry_by_title;
    349     for (ScopedVector<ResourceEntry>::iterator itr = remote_entries.begin();
    350          itr != remote_entries.end();
    351          ++itr) {
    352       const ResourceEntry& remote_entry = **itr;
    353       EXPECT_FALSE(ContainsKey(remote_entry_by_title, remote_entry.title()));
    354       remote_entry_by_title[remote_entry.title()] = *itr;
    355     }
    356 
    357     fileapi::FileSystemURL url(CreateSyncableFileSystemURL(origin, path));
    358     CannedSyncableFileSystem::FileEntryList local_entries;
    359     EXPECT_EQ(base::PLATFORM_FILE_OK,
    360               file_system->ReadDirectory(url, &local_entries));
    361     for (CannedSyncableFileSystem::FileEntryList::iterator itr =
    362              local_entries.begin();
    363          itr != local_entries.end();
    364          ++itr) {
    365       const fileapi::DirectoryEntry& local_entry = *itr;
    366       fileapi::FileSystemURL entry_url(
    367           CreateSyncableFileSystemURL(origin, path.Append(local_entry.name)));
    368       std::string title = DriveFileSyncService::PathToTitle(entry_url.path());
    369       ASSERT_TRUE(ContainsKey(remote_entry_by_title, title));
    370       const ResourceEntry& remote_entry = *remote_entry_by_title[title];
    371       if (local_entry.is_directory) {
    372         ASSERT_TRUE(remote_entry.is_folder());
    373         VerifyConsistencyForFolder(origin, entry_url.path(),
    374                                    remote_entry.resource_id(),
    375                                    file_system);
    376       } else {
    377         ASSERT_TRUE(remote_entry.is_file());
    378         VerifyConsistencyForFile(origin, entry_url.path(),
    379                                  remote_entry.resource_id(),
    380                                  file_system);
    381       }
    382       remote_entry_by_title.erase(title);
    383     }
    384 
    385     EXPECT_TRUE(remote_entry_by_title.empty());
    386   }
    387 
    388   void VerifyConsistencyForFile(const GURL& origin,
    389                                 const base::FilePath& path,
    390                                 const std::string& file_id,
    391                                 CannedSyncableFileSystem* file_system) {
    392     fileapi::FileSystemURL url(CreateSyncableFileSystemURL(origin, path));
    393     std::string file_content;
    394     EXPECT_EQ(google_apis::HTTP_SUCCESS,
    395               fake_drive_helper_->ReadFile(file_id, &file_content));
    396     EXPECT_EQ(base::PLATFORM_FILE_OK,
    397               file_system->VerifyFile(url, file_content));
    398   }
    399 
    400   void FlushMessageLoop() {
    401     base::MessageLoop::current()->RunUntilIdle();
    402     BrowserThread::GetBlockingPool()->FlushForTesting();
    403     base::MessageLoop::current()->RunUntilIdle();
    404   }
    405 
    406   void TestInitialization();
    407   void TestLocalToRemoteBasic();
    408   void TestRemoteToLocalBasic();
    409   void TestLocalFileUpdate();
    410   void TestRemoteFileUpdate();
    411   void TestLocalFileDeletion();
    412   void TestRemoteFileDeletion();
    413 
    414   content::TestBrowserThreadBundle thread_bundle_;
    415 
    416   TestingProfile profile_;
    417 
    418   drive::FakeDriveService* fake_drive_service_;
    419   drive::DriveUploader* drive_uploader_;
    420   scoped_ptr<FakeDriveServiceHelper> fake_drive_helper_;
    421   std::map<GURL, CannedSyncableFileSystem*> file_systems_;
    422 
    423   scoped_ptr<DriveFileSyncService> remote_sync_service_;
    424   scoped_ptr<LocalFileSyncService> local_sync_service_;
    425 
    426  private:
    427   DISALLOW_COPY_AND_ASSIGN(DriveFileSyncServiceSyncTest);
    428 };
    429 
    430 void DriveFileSyncServiceSyncTest::TestInitialization() {
    431   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
    432   VerifyConsistency();
    433 }
    434 
    435 void DriveFileSyncServiceSyncTest::TestLocalToRemoteBasic() {
    436   const GURL kOrigin("chrome-extension://example");
    437 
    438   RegisterOrigin(kOrigin);
    439   AddOrUpdateLocalFile(kOrigin, base::FilePath(FPL("file")), "abcde");
    440 
    441   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
    442   VerifyConsistency();
    443 }
    444 
    445 void DriveFileSyncServiceSyncTest::TestRemoteToLocalBasic() {
    446   const GURL kOrigin("chrome-extension://example");
    447 
    448   std::string sync_root_folder_id;
    449   EXPECT_EQ(google_apis::HTTP_CREATED,
    450             fake_drive_helper_->AddOrphanedFolder(
    451                 APIUtil::GetSyncRootDirectoryName(),
    452                 &sync_root_folder_id));
    453 
    454   std::string origin_root_folder_id;
    455   EXPECT_EQ(google_apis::HTTP_CREATED,
    456             fake_drive_helper_->AddFolder(
    457                 sync_root_folder_id, kOrigin.host(), &origin_root_folder_id));
    458 
    459   RegisterOrigin(kOrigin);
    460 
    461   std::string file_id;
    462   EXPECT_EQ(google_apis::HTTP_SUCCESS,
    463             fake_drive_helper_->AddFile(
    464                 origin_root_folder_id, "file", "abcde", &file_id));
    465 
    466   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
    467   VerifyConsistency();
    468 }
    469 
    470 void DriveFileSyncServiceSyncTest::TestLocalFileUpdate() {
    471   const GURL kOrigin("chrome-extension://example");
    472   const base::FilePath kPath(FPL("file"));
    473 
    474   RegisterOrigin(kOrigin);
    475   AddOrUpdateLocalFile(kOrigin, kPath, "abcde");
    476 
    477   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
    478   VerifyConsistencyForOrigin(kOrigin);
    479 
    480   UpdateLocalFile(kOrigin, kPath, "1234567890");
    481 
    482   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
    483   VerifyConsistency();
    484 }
    485 
    486 void DriveFileSyncServiceSyncTest::TestRemoteFileUpdate() {
    487   const GURL kOrigin("chrome-extension://example");
    488   const base::FilePath kPath(FPL("file"));
    489   const std::string kTitle(DriveFileSyncService::PathToTitle(kPath));
    490 
    491   std::string sync_root_folder_id;
    492   EXPECT_EQ(google_apis::HTTP_CREATED,
    493             fake_drive_helper_->AddOrphanedFolder(
    494                 APIUtil::GetSyncRootDirectoryName(),
    495                 &sync_root_folder_id));
    496 
    497   std::string origin_root_folder_id;
    498   EXPECT_EQ(google_apis::HTTP_CREATED,
    499             fake_drive_helper_->AddFolder(
    500                 sync_root_folder_id, kOrigin.host(), &origin_root_folder_id));
    501 
    502   std::string remote_file_id;
    503   EXPECT_EQ(google_apis::HTTP_SUCCESS,
    504             fake_drive_helper_->AddFile(
    505                 origin_root_folder_id, kTitle, "abcde", &remote_file_id));
    506 
    507   RegisterOrigin(kOrigin);
    508   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
    509   VerifyConsistencyForOrigin(kOrigin);
    510 
    511   EXPECT_EQ(google_apis::HTTP_SUCCESS,
    512             fake_drive_helper_->UpdateFile(remote_file_id, "1234567890"));
    513 
    514   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
    515   VerifyConsistency();
    516 }
    517 
    518 void DriveFileSyncServiceSyncTest::TestLocalFileDeletion() {
    519   const GURL kOrigin("chrome-extension://example");
    520   const base::FilePath kPath(FPL("file"));
    521 
    522   RegisterOrigin(kOrigin);
    523   AddOrUpdateLocalFile(kOrigin, kPath, "abcde");
    524 
    525   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
    526   VerifyConsistencyForOrigin(kOrigin);
    527 
    528   RemoveLocal(kOrigin, kPath);
    529 
    530   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
    531   VerifyConsistency();
    532 }
    533 
    534 void DriveFileSyncServiceSyncTest::TestRemoteFileDeletion() {
    535   const GURL kOrigin("chrome-extension://example");
    536   const base::FilePath kPath(FPL("file"));
    537   const std::string kTitle(DriveFileSyncService::PathToTitle(kPath));
    538 
    539   std::string sync_root_folder_id;
    540   EXPECT_EQ(google_apis::HTTP_CREATED,
    541             fake_drive_helper_->AddOrphanedFolder(
    542                 APIUtil::GetSyncRootDirectoryName(),
    543                 &sync_root_folder_id));
    544 
    545   std::string origin_root_folder_id;
    546   EXPECT_EQ(google_apis::HTTP_CREATED,
    547             fake_drive_helper_->AddFolder(
    548                 sync_root_folder_id, kOrigin.host(), &origin_root_folder_id));
    549 
    550   std::string remote_file_id;
    551   EXPECT_EQ(google_apis::HTTP_SUCCESS,
    552             fake_drive_helper_->AddFile(
    553                 origin_root_folder_id, kTitle, "abcde", &remote_file_id));
    554 
    555   RegisterOrigin(kOrigin);
    556   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
    557   VerifyConsistencyForOrigin(kOrigin);
    558 
    559   EXPECT_EQ(google_apis::HTTP_SUCCESS,
    560             fake_drive_helper_->RemoveResource(remote_file_id));
    561 
    562   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
    563   VerifyConsistency();
    564 }
    565 
    566 TEST_F(DriveFileSyncServiceSyncTest, InitializationTest) {
    567   ASSERT_FALSE(IsDriveAPIDisabled());
    568   TestInitialization();
    569 }
    570 
    571 TEST_F(DriveFileSyncServiceSyncTest, InitializationTest_WAPI) {
    572   ScopedDisableDriveAPI disable_drive_api;
    573   TestInitialization();
    574 }
    575 
    576 TEST_F(DriveFileSyncServiceSyncTest, LocalToRemoteBasicTest) {
    577   ASSERT_FALSE(IsDriveAPIDisabled());
    578   TestLocalToRemoteBasic();
    579 }
    580 
    581 TEST_F(DriveFileSyncServiceSyncTest, LocalToRemoteBasicTest_WAPI) {
    582   ScopedDisableDriveAPI disable_drive_api;
    583   TestLocalToRemoteBasic();
    584 }
    585 
    586 TEST_F(DriveFileSyncServiceSyncTest, RemoteToLocalBasicTest) {
    587   ASSERT_FALSE(IsDriveAPIDisabled());
    588   TestRemoteToLocalBasic();
    589 }
    590 
    591 TEST_F(DriveFileSyncServiceSyncTest, RemoteToLocalBasicTest_WAPI) {
    592   ScopedDisableDriveAPI disable_drive_api;
    593   TestRemoteToLocalBasic();
    594 }
    595 
    596 TEST_F(DriveFileSyncServiceSyncTest, LocalFileUpdateTest) {
    597   ASSERT_FALSE(IsDriveAPIDisabled());
    598   TestLocalFileUpdate();
    599 }
    600 
    601 TEST_F(DriveFileSyncServiceSyncTest, LocalFileUpdateTest_WAPI) {
    602   ScopedDisableDriveAPI disable_drive_api;
    603   TestLocalFileUpdate();
    604 }
    605 
    606 TEST_F(DriveFileSyncServiceSyncTest, RemoteFileUpdateTest) {
    607   ASSERT_FALSE(IsDriveAPIDisabled());
    608   TestRemoteFileUpdate();
    609 }
    610 
    611 TEST_F(DriveFileSyncServiceSyncTest, RemoteFileUpdateTest_WAPI) {
    612   ScopedDisableDriveAPI disable_drive_api;
    613   TestRemoteFileUpdate();
    614 }
    615 
    616 TEST_F(DriveFileSyncServiceSyncTest, LocalFileDeletionTest) {
    617   ASSERT_FALSE(IsDriveAPIDisabled());
    618   TestLocalFileDeletion();
    619 }
    620 
    621 TEST_F(DriveFileSyncServiceSyncTest, LocalFileDeletionTest_WAPI) {
    622   ScopedDisableDriveAPI disable_drive_api;
    623   TestLocalFileDeletion();
    624 }
    625 
    626 TEST_F(DriveFileSyncServiceSyncTest, RemoteFileDeletionTest) {
    627   ASSERT_FALSE(IsDriveAPIDisabled());
    628   TestRemoteFileDeletion();
    629 }
    630 
    631 TEST_F(DriveFileSyncServiceSyncTest, RemoteFileDeletionTest_WAPI) {
    632   ScopedDisableDriveAPI disable_drive_api;
    633   TestRemoteFileDeletion();
    634 }
    635 
    636 }  // namespace sync_file_system
    637