SyncFS: Use ScopedDisableDriveAPI in APIUtilTest

chrome/browser/sync_file_system/drive/api_util_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/api_util.h"
 
 #include "base/location.h"
 #include "base/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/stringprintf.h"
@@ skipping 251 matching lines @@
     api_util_ = APIUtil::CreateForTesting(
         &profile_,
         scoped_ptr<DriveServiceInterface>(fake_drive_service_),
         scoped_ptr<DriveUploaderInterface>(fake_drive_uploader_));
 
     fake_drive_service_->LoadResourceListForWapi(
         "chromeos/sync_file_system/initialize.json");
   }
 
   virtual void TearDown() OVERRIDE {
-    SetDisableDriveAPI(false);
     api_util_.reset();
   }
 
  protected:
   void SetUpSyncRootDirectory() {
     fake_drive_service()->AddNewDirectory(
         fake_drive_service_->GetRootResourceId(),
         APIUtil::GetSyncRootDirectoryName(),
         base::Bind(&DidAddNewDirectory, &sync_root_resource_id_));
     message_loop()->RunUntilIdle();
@@ skipping 47 matching lines @@
   FakeDriveServiceWrapper* fake_drive_service() {
     return fake_drive_service_;
   }
 
   FakeDriveUploader* fake_drive_uploader() {
     return fake_drive_uploader_;
   }
 
   base::MessageLoop* message_loop() { return &message_loop_; }
 
-  void GetSyncRoot_Body();
-  void CreateSyncRoot_Body();
-  void CreateSyncRoot_Conflict_Body();
-  void GetOriginDirectory_Body();
-  void CreateOriginDirectory_Body();
-  void CreateOriginDirectory_Conflict_Body();
-  void GetLargestChangeStamp_Body();
-  void ListFiles_Body();
-  void ListChanges_Body();
-  void DownloadFile_Body();
-  void DownloadFileInNotModified_Body();
-  void UploadNewFile_Body();
-  void UploadNewFile_ConflictWithFile_Body();
-  void UploadExistingFile_Body();
-  void UploadExistingFileInConflict_Body();
-  void DeleteFile_Body();
-  void DeleteFileInConflict_Body();
-  void CreateDirectory_Body();
+  void TestGetSyncRoot();
+  void TestCreateSyncRoot();
+  void TestCreateSyncRoot_Conflict();
+  void TestGetOriginDirectory();
+  void TestCreateOriginDirectory();
+  void TestCreateOriginDirectory_Conflict();
+  void TestGetLargestChangeStamp();
+  void TestListFiles();
+  void TestListChanges();
+  void TestDownloadFile();
+  void TestDownloadFileInNotModified();
+  void TestUploadNewFile();
+  void TestUploadNewFile_ConflictWithFile();
+  void TestUploadExistingFile();
+  void TestUploadExistingFileInConflict();
+  void TestDeleteFile();
+  void TestDeleteFileInConflict();
+  void TestCreateDirectory();
 
  private:
   base::MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
 
   std::string sync_root_resource_id_;
   std::string origin_root_resource_id_;
 
   TestingProfile profile_;
   scoped_ptr<APIUtil> api_util_;
@@ skipping 64 matching lines @@
 }
 
 void DidDeleteFile(bool* done_out,
                    GDataErrorCode* error_out,
                    GDataErrorCode error) {
   EXPECT_FALSE(*done_out);
   *done_out = true;
   *error_out = error;
 }
 
-void APIUtilTest::GetSyncRoot_Body() {
+void APIUtilTest::TestGetSyncRoot() {
   fake_drive_service()->LoadAccountMetadataForWapi(
       "chromeos/sync_file_system/account_metadata.json");
   SetUpSyncRootDirectory();
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   api_util()->GetDriveDirectoryForSyncRoot(
       base::Bind(&DidGetResourceID, &done, &error, &resource_id));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
   EXPECT_EQ(GetSyncRootResourceId(), resource_id);
 }
 
-void APIUtilTest::CreateSyncRoot_Body() {
+void APIUtilTest::TestCreateSyncRoot() {
   fake_drive_service()->LoadAccountMetadataForWapi(
       "chromeos/sync_file_system/account_metadata.json");
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   api_util()->GetDriveDirectoryForSyncRoot(
       base::Bind(&DidGetResourceID, &done, &error, &resource_id));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_CREATED, error);
   EXPECT_FALSE(resource_id.empty());
 
   fake_drive_service()->SearchByTitle(
       APIUtil::GetSyncRootDirectoryName(),
       std::string(),  // directory_resource_id
       base::Bind(&VerifyTitleUniqueness,
                  FROM_HERE,
                  resource_id,
                  google_apis::ENTRY_KIND_FOLDER));
   message_loop()->RunUntilIdle();
 }
 
-void APIUtilTest::CreateSyncRoot_Conflict_Body() {
+void APIUtilTest::TestCreateSyncRoot_Conflict() {
   fake_drive_service()->LoadAccountMetadataForWapi(
       "chromeos/sync_file_system/account_metadata.json");
   fake_drive_service()->set_make_directory_conflict(true);
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   api_util()->GetDriveDirectoryForSyncRoot(
       base::Bind(&DidGetResourceID, &done, &error, &resource_id));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
   EXPECT_FALSE(resource_id.empty());
 
   // Verify that there is no duplicated directory on the remote side.
   fake_drive_service()->SearchByTitle(
       APIUtil::GetSyncRootDirectoryName(),
       std::string(),  // directory_resource_id
       base::Bind(&VerifyTitleUniqueness,
                  FROM_HERE,
                  resource_id,
                  google_apis::ENTRY_KIND_FOLDER));
   message_loop()->RunUntilIdle();
 }
 
-void APIUtilTest::GetOriginDirectory_Body() {
+void APIUtilTest::TestGetOriginDirectory() {
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   api_util()->GetDriveDirectoryForOrigin(
       GetSyncRootResourceId(),
       GURL(kOrigin),
       base::Bind(&DidGetResourceID, &done, &error, &resource_id));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
   EXPECT_EQ(GetOriginRootResourceId(), resource_id);
 }
 
-void APIUtilTest::CreateOriginDirectory_Body() {
+void APIUtilTest::TestCreateOriginDirectory() {
   SetUpSyncRootDirectory();
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   api_util()->GetDriveDirectoryForOrigin(
       GetSyncRootResourceId(),
       GURL(kOrigin),
       base::Bind(&DidGetResourceID, &done, &error, &resource_id));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_CREATED, error);
   EXPECT_FALSE(resource_id.empty());
 
   fake_drive_service()->SearchByTitle(
       kOriginDirectoryName,
       GetSyncRootResourceId(),
       base::Bind(&VerifyTitleUniqueness,
                  FROM_HERE,
                  resource_id,
                  google_apis::ENTRY_KIND_FOLDER));
   message_loop()->RunUntilIdle();
 }
 
-void APIUtilTest::CreateOriginDirectory_Conflict_Body() {
+void APIUtilTest::TestCreateOriginDirectory_Conflict() {
   SetUpSyncRootDirectory();
   fake_drive_service()->set_make_directory_conflict(true);
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   api_util()->GetDriveDirectoryForOrigin(
       GetSyncRootResourceId(),
       GURL(kOrigin),
       base::Bind(&DidGetResourceID, &done, &error, &resource_id));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
   EXPECT_FALSE(resource_id.empty());
 
   // Verify that there is no duplicated directory on the remote side.
   fake_drive_service()->SearchByTitle(
       kOriginDirectoryName,
       GetSyncRootResourceId(),
       base::Bind(&VerifyTitleUniqueness,
                  FROM_HERE,
                  resource_id,
                  google_apis::ENTRY_KIND_FOLDER));
   message_loop()->RunUntilIdle();
 }
 
-void APIUtilTest::GetLargestChangeStamp_Body() {
+void APIUtilTest::TestGetLargestChangeStamp() {
   fake_drive_service()->LoadAccountMetadataForWapi(
       "chromeos/sync_file_system/account_metadata.json");
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   int64 largest_changestamp = -1;
   api_util()->GetLargestChangeStamp(base::Bind(
       &DidGetLargestChangeStamp, &done, &error, &largest_changestamp));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
   EXPECT_EQ(654321, largest_changestamp);
 }
 
-void APIUtilTest::ListFiles_Body() {
+void APIUtilTest::TestListFiles() {
   fake_drive_service()->set_default_max_results(3);
 
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
 
   int kNumberOfFiles = 5;
   for (int i = 0; i < kNumberOfFiles; ++i) {
     std::string file_resource_id;
     std::string file_md5;
     std::string file_content = base::StringPrintf("test content %d", i);
@@ skipping 22 matching lines @@
 
   api_util()->ContinueListing(
       feed_url, base::Bind(&DidGetResourceList, &done, &error, &document_feed));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
   EXPECT_EQ(2U, document_feed->entries().size());
 }
 
-void APIUtilTest::ListChanges_Body() {
+void APIUtilTest::TestListChanges() {
   const int64 kStartChangestamp = 6;
 
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
 
   // Files should have changestamp #4+ since creating the sync root directory is
   // #1, moving it out of 'My Drive' is #2, and creating the origin root
   // directory is #3.
   const int kNumberOfFiles = 5;
   for (int i = 0; i < kNumberOfFiles; ++i) {
@@ skipping 23 matching lines @@
       kStartChangestamp,
       base::Bind(&DidGetResourceList, &done, &error, &document_feed));
   message_loop()->RunUntilIdle();
 
   // There should be 3 files which have changestamp #6+.
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
   EXPECT_EQ(3U, document_feed->entries().size());
 }
 
-void APIUtilTest::DownloadFile_Body() {
+void APIUtilTest::TestDownloadFile() {
   const std::string kFileContent = "test content";
   const std::string kFileTitle = "test.txt";
 
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
   std::string file_resource_id;
   std::string file_md5;
   SetUpFile(kFileContent, kFileTitle, &file_resource_id, &file_md5);
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   const base::FilePath kOutputFilePath =
       temp_dir.path().AppendASCII(kFileTitle);
 
   bool done = false;
   std::string downloaded_file_md5;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   api_util()->DownloadFile(
       file_resource_id,
       "",  // local_file_md5
       kOutputFilePath,
       base::Bind(&DidDownloadFile, &done, &downloaded_file_md5, &error));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(file_md5, downloaded_file_md5);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
-void APIUtilTest::DownloadFileInNotModified_Body() {
+void APIUtilTest::TestDownloadFileInNotModified() {
   const std::string kFileContent = "test content";
   const std::string kFileTitle = "test.txt";
 
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
   std::string file_resource_id;
   std::string file_md5;
   SetUpFile(kFileContent, kFileTitle, &file_resource_id, &file_md5);
 
   base::ScopedTempDir temp_dir;
@@ skipping 13 matching lines @@
       kOutputFilePath,
       base::Bind(&DidDownloadFile, &done, &downloaded_file_md5, &error));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_NOT_MODIFIED, error);
   // TODO(nhiroki): Compare |file_md5| and |downloaded_file_md5| after making
   // FakeDriveService::AddNewEntry set the correct MD5.
 }
 
-void APIUtilTest::UploadNewFile_Body() {
+void APIUtilTest::TestUploadNewFile() {
   const std::string kFileTitle = "test.txt";
   const base::FilePath kLocalFilePath(FPL("/tmp/dir/file"));
 
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   api_util()->UploadNewFile(
@@ skipping 10 matching lines @@
   fake_drive_service()->SearchByTitle(
       kFileTitle,
       GetOriginRootResourceId(),
       base::Bind(&VerifyTitleUniqueness,
                  FROM_HERE,
                  resource_id,
                  google_apis::ENTRY_KIND_FILE));
   message_loop()->RunUntilIdle();
 }
 
-void APIUtilTest::UploadNewFile_ConflictWithFile_Body() {
+void APIUtilTest::TestUploadNewFile_ConflictWithFile() {
   const std::string kFileTitle = "test.txt";
   const base::FilePath kLocalFilePath(FPL("/tmp/dir/file"));
 
   fake_drive_uploader()->set_make_file_conflict(true);
 
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
@@ skipping 14 matching lines @@
   fake_drive_service()->SearchByTitle(
       kFileTitle,
       GetOriginRootResourceId(),
       base::Bind(&VerifyTitleUniqueness,
                  FROM_HERE,
                  resource_id,
                  google_apis::ENTRY_KIND_FILE));
   message_loop()->RunUntilIdle();
 }
 
-void APIUtilTest::UploadExistingFile_Body() {
+void APIUtilTest::TestUploadExistingFile() {
   const base::FilePath kLocalFilePath(FPL("/tmp/dir/file"));
   const std::string kFileContent = "test content";
   const std::string kFileTitle = "test.txt";
 
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
   std::string file_resource_id;
   std::string file_md5;
   SetUpFile(kFileContent, kFileTitle, &file_resource_id, &file_md5);
 
@@ skipping 14 matching lines @@
   fake_drive_service()->SearchByTitle(
       kFileTitle,
       GetOriginRootResourceId(),
       base::Bind(&VerifyTitleUniqueness,
                  FROM_HERE,
                  file_resource_id,
                  google_apis::ENTRY_KIND_FILE));
   message_loop()->RunUntilIdle();
 }
 
-void APIUtilTest::UploadExistingFileInConflict_Body() {
+void APIUtilTest::TestUploadExistingFileInConflict() {
   const base::FilePath kLocalFilePath(FPL("/tmp/dir/file"));
   const std::string kFileContent = "test content";
   const std::string kFileTitle = "test.txt";
 
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
   std::string file_resource_id;
   std::string file_md5;
   SetUpFile(kFileContent, kFileTitle, &file_resource_id, &file_md5);
 
@@ skipping 19 matching lines @@
   fake_drive_service()->SearchByTitle(
       kFileTitle,
       GetOriginRootResourceId(),
       base::Bind(&VerifyTitleUniqueness,
                  FROM_HERE,
                  file_resource_id,
                  google_apis::ENTRY_KIND_FILE));
   message_loop()->RunUntilIdle();
 }
 
-void APIUtilTest::DeleteFile_Body() {
+void APIUtilTest::TestDeleteFile() {
   const std::string kFileContent = "test content";
   const std::string kFileTitle = "test.txt";
 
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
   std::string file_resource_id;
   std::string file_md5;
   SetUpFile(kFileContent, kFileTitle, &file_resource_id, &file_md5);
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   api_util()->DeleteFile(file_resource_id,
                          file_md5,
                          base::Bind(&DidDeleteFile, &done, &error));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
 
   fake_drive_service()->SearchByTitle(
       kFileTitle,
       GetOriginRootResourceId(),
       base::Bind(&VerifyFileDeletion, FROM_HERE));
   message_loop()->RunUntilIdle();
 }
 
-void APIUtilTest::DeleteFileInConflict_Body() {
+void APIUtilTest::TestDeleteFileInConflict() {
   const std::string kFileContent = "test content";
   const std::string kFileTitle = "test.txt";
 
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
   std::string file_resource_id;
   std::string file_md5;
   SetUpFile(kFileContent, kFileTitle, &file_resource_id, &file_md5);
 
   // Since remote file's hash value is different from the expected one, it is
@@ skipping 14 matching lines @@
   fake_drive_service()->SearchByTitle(
       kFileTitle,
       GetOriginRootResourceId(),
       base::Bind(&VerifyTitleUniqueness,
                  FROM_HERE,
                  file_resource_id,
                  google_apis::ENTRY_KIND_FILE));
   message_loop()->RunUntilIdle();
 }
 
-void APIUtilTest::CreateDirectory_Body() {
+void APIUtilTest::TestCreateDirectory() {
   const std::string kDirectoryTitle("directory");
 
   SetUpSyncRootDirectory();
   SetUpOriginRootDirectory();
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   api_util()->CreateDirectory(
       GetOriginRootResourceId(),
@@ skipping 10 matching lines @@
       GetOriginRootResourceId(),
       base::Bind(&VerifyTitleUniqueness,
                  FROM_HERE,
                  resource_id,
                  google_apis::ENTRY_KIND_FOLDER));
   message_loop()->RunUntilIdle();
 }
 
 TEST_F(APIUtilTest, GetSyncRoot) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  GetSyncRoot_Body();
+  TestGetSyncRoot();
 }
 
 TEST_F(APIUtilTest, GetSyncRoot_WAPI) {
-  SetDisableDriveAPI(true);
-  GetSyncRoot_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestGetSyncRoot();
 }
 
 TEST_F(APIUtilTest, CreateSyncRoot) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  CreateSyncRoot_Body();
+  TestCreateSyncRoot();
 }
 
 TEST_F(APIUtilTest, CreateSyncRoot_WAPI) {
-  SetDisableDriveAPI(true);
-  CreateSyncRoot_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestCreateSyncRoot();
 }
 
 TEST_F(APIUtilTest, CreateSyncRoot_Conflict) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  CreateSyncRoot_Conflict_Body();
+  TestCreateSyncRoot_Conflict();
 }
 
 TEST_F(APIUtilTest, CreateSyncRoot_Conflict_WAPI) {
-  SetDisableDriveAPI(true);
-  CreateSyncRoot_Conflict_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestCreateSyncRoot_Conflict();
 }
 
 TEST_F(APIUtilTest, GetOriginDirectory) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  GetOriginDirectory_Body();
+  TestGetOriginDirectory();
 }
 
 TEST_F(APIUtilTest, GetOriginDirectory_WAPI) {
-  SetDisableDriveAPI(true);
-  GetOriginDirectory_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestGetOriginDirectory();
 }
 
 TEST_F(APIUtilTest, CreateOriginDirectory) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  CreateOriginDirectory_Body();
+  TestCreateOriginDirectory();
 }
 
 TEST_F(APIUtilTest, CreateOriginDirectory_WAPI) {
-  SetDisableDriveAPI(true);
-  CreateOriginDirectory_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestCreateOriginDirectory();
 }
 
 TEST_F(APIUtilTest, CreateOriginDirectory_Conflict) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  CreateOriginDirectory_Conflict_Body();
+  TestCreateOriginDirectory_Conflict();
 }
 
 TEST_F(APIUtilTest, CreateOriginDirectory_Conflict_WAPI) {
-  SetDisableDriveAPI(true);
-  CreateOriginDirectory_Conflict_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestCreateOriginDirectory_Conflict();
 }
 
 TEST_F(APIUtilTest, GetLargestChangeStamp) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  GetLargestChangeStamp_Body();
+  TestGetLargestChangeStamp();
 }
 
 TEST_F(APIUtilTest, GetLargestChangeStamp_WAPI) {
-  SetDisableDriveAPI(true);
-  GetLargestChangeStamp_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestGetLargestChangeStamp();
 }
 
 TEST_F(APIUtilTest, ListFiles) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  ListFiles_Body();
+  TestListFiles();
 }
 
 TEST_F(APIUtilTest, ListFiles_WAPI) {
-  SetDisableDriveAPI(true);
-  ListFiles_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestListFiles();
 }
 
 TEST_F(APIUtilTest, ListChanges) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  ListChanges_Body();
+  TestListChanges();
 }
 
 TEST_F(APIUtilTest, ListChanges_WAPI) {
-  SetDisableDriveAPI(true);
-  ListChanges_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestListChanges();
 }
 
 TEST_F(APIUtilTest, DownloadFile) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  DownloadFile_Body();
+  TestDownloadFile();
 }
 
 TEST_F(APIUtilTest, DownloadFile_WAPI) {
-  SetDisableDriveAPI(true);
-  DownloadFile_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestDownloadFile();
 }
 
 TEST_F(APIUtilTest, DownloadFileInNotModified) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  DownloadFileInNotModified_Body();
+  TestDownloadFileInNotModified();
 }
 
 TEST_F(APIUtilTest, DownloadFileInNotModified_WAPI) {
-  SetDisableDriveAPI(true);
-  DownloadFileInNotModified_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestDownloadFileInNotModified();
 }
 
 TEST_F(APIUtilTest, UploadNewFile) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  UploadNewFile_Body();
+  TestUploadNewFile();
 }
 
 TEST_F(APIUtilTest, UploadNewFile_WAPI) {
-  SetDisableDriveAPI(true);
-  UploadNewFile_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestUploadNewFile();
 }
 
 TEST_F(APIUtilTest, UploadNewFile_ConflictWithFile) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  UploadNewFile_ConflictWithFile_Body();
+  TestUploadNewFile_ConflictWithFile();
 }
 
 TEST_F(APIUtilTest, UploadNewFile_ConflictWithFile_WAPI) {
-  SetDisableDriveAPI(true);
-  UploadNewFile_ConflictWithFile_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestUploadNewFile_ConflictWithFile();
 }
 
 TEST_F(APIUtilTest, UploadExistingFile) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  UploadExistingFile_Body();
+  TestUploadExistingFile();
 }
 
 TEST_F(APIUtilTest, UploadExistingFile_WAPI) {
-  SetDisableDriveAPI(true);
-  UploadExistingFile_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestUploadExistingFile();
 }
 
 TEST_F(APIUtilTest, UploadExistingFileInConflict) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  UploadExistingFileInConflict_Body();
+  TestUploadExistingFileInConflict();
 }
 
 TEST_F(APIUtilTest, UploadExistingFileInConflict_WAPI) {
-  SetDisableDriveAPI(true);
-  UploadExistingFileInConflict_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestUploadExistingFileInConflict();
 }
 
 TEST_F(APIUtilTest, DeleteFile) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  DeleteFile_Body();
+  TestDeleteFile();
 }
 
 TEST_F(APIUtilTest, DeleteFile_WAPI) {
-  SetDisableDriveAPI(true);
-  DeleteFile_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestDeleteFile();
 }
 
 TEST_F(APIUtilTest, DeleteFileInConflict) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  DeleteFileInConflict_Body();
+  TestDeleteFileInConflict();
 }
 
 TEST_F(APIUtilTest, DeleteFileInConflict_WAPI) {
-  SetDisableDriveAPI(true);
-  DeleteFileInConflict_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestDeleteFileInConflict();
 }
 
 TEST_F(APIUtilTest, CreateDirectory) {
   ASSERT_FALSE(IsDriveAPIDisabled());
-  CreateDirectory_Body();
+  TestCreateDirectory();
 }
 
 TEST_F(APIUtilTest, CreateDirectory_WAPI) {
-  SetDisableDriveAPI(true);
-  CreateDirectory_Body();
+  ScopedDisableDriveAPI disable_drive_api;
+  TestCreateDirectory();
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace drive
 }  // namespace sync_file_system