Get rid of DriveEntryKind.

chrome/browser/sync_file_system/drive_backend_v1/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_backend_v1/api_util.h"
 
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
@@ skipping 97 matching lines @@
                   origin_root_id,
                   title,
                   content_data,
                   &file_resource_id));
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_helper_->GetFileResource(
                   file_resource_id,
                   entry));
   }
 
-  void VerifyTitleUniqueness(const std::string& parent_resource_id,
-                             const std::string& title,
-                             const std::string& resource_id,
-                             google_apis::DriveEntryKind kind) {
+  void VerifyTitleUniqueness(
+      const std::string& parent_resource_id,
+      const std::string& title,
+      const std::string& resource_id,
+      google_apis::ResourceEntry::ResourceEntryKind kind) {
     ScopedVector<ResourceEntry> entries;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_helper_->SearchByTitle(
                   parent_resource_id, title, &entries));
     ASSERT_EQ(1u, entries.size());
     EXPECT_EQ(resource_id, entries[0]->resource_id());
     EXPECT_EQ(kind, entries[0]->kind());
   }
 
   void VerifyFileDeletion(const std::string& parent_resource_id,
@@ skipping 117 matching lines @@
   api_util()->GetDriveDirectoryForSyncRoot(
       base::Bind(&DidGetResourceID, &output));
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(google_apis::HTTP_CREATED, output.error);
   EXPECT_FALSE(output.resource_id.empty());
 
   VerifyTitleUniqueness(std::string(),  // directory_resource_id
                         APIUtil::GetSyncRootDirectoryName(),
                         output.resource_id,
-                        google_apis::ENTRY_KIND_FOLDER);
+                        google_apis::ResourceEntry::ENTRY_KIND_FOLDER);
 }
 
 void APIUtilTest::TestCreateSyncRoot_Conflict() {
   fake_drive_service()->set_make_directory_conflict(true);
 
   Output output;
   api_util()->GetDriveDirectoryForSyncRoot(
       base::Bind(&DidGetResourceID, &output));
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(google_apis::HTTP_SUCCESS, output.error);
   EXPECT_FALSE(output.resource_id.empty());
 
   // Verify that there is no duplicated directory on the remote side.
   VerifyTitleUniqueness(std::string(),  // directory_resource_id
                         APIUtil::GetSyncRootDirectoryName(),
                         output.resource_id,
-                        google_apis::ENTRY_KIND_FOLDER);
+                        google_apis::ResourceEntry::ENTRY_KIND_FOLDER);
 }
 
 void APIUtilTest::TestGetOriginDirectory() {
   const std::string sync_root_id = SetUpSyncRootDirectory();
   const std::string origin_root_id = SetUpOriginRootDirectory(sync_root_id);
 
   Output output;
   api_util()->GetDriveDirectoryForOrigin(
       sync_root_id,
       GURL(kOrigin),
@@ skipping 13 matching lines @@
       GURL(kOrigin),
       base::Bind(&DidGetResourceID, &output));
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(google_apis::HTTP_CREATED, output.error);
   EXPECT_FALSE(output.resource_id.empty());
 
   VerifyTitleUniqueness(sync_root_id,
                         kOriginDirectoryName,
                         output.resource_id,
-                        google_apis::ENTRY_KIND_FOLDER);
+                        google_apis::ResourceEntry::ENTRY_KIND_FOLDER);
 }
 
 void APIUtilTest::TestCreateOriginDirectory_Conflict() {
   fake_drive_service()->set_make_directory_conflict(true);
   const std::string sync_root_id = SetUpSyncRootDirectory();
 
   Output output;
   api_util()->GetDriveDirectoryForOrigin(
       sync_root_id,
       GURL(kOrigin),
       base::Bind(&DidGetResourceID, &output));
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(google_apis::HTTP_SUCCESS, output.error);
   EXPECT_FALSE(output.resource_id.empty());
 
   // Verify that there is no duplicated directory on the remote side.
   VerifyTitleUniqueness(sync_root_id,
                         kOriginDirectoryName,
                         output.resource_id,
-                        google_apis::ENTRY_KIND_FOLDER);
+                        google_apis::ResourceEntry::ENTRY_KIND_FOLDER);
 }
 
 void APIUtilTest::TestGetLargestChangeStamp() {
   Output output;
   api_util()->GetLargestChangeStamp(
       base::Bind(&DidGetLargestChangeStamp, &output));
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(google_apis::HTTP_SUCCESS, output.error);
   EXPECT_EQ(fake_drive_service()->about_resource().largest_change_id(),
@@ skipping 132 matching lines @@
       kFileTitle,
       base::Bind(&DidUploadFile, &output));
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(google_apis::HTTP_CREATED, output.error);
   EXPECT_TRUE(!output.resource_id.empty());
 
   VerifyTitleUniqueness(origin_root_id,
                         kFileTitle,
                         output.resource_id,
-                        google_apis::ENTRY_KIND_FILE);
+                        google_apis::ResourceEntry::ENTRY_KIND_FILE);
 }
 
 void APIUtilTest::TestUploadNewFile_ConflictWithFile() {
   const std::string kFileTitle = "test.txt";
   const base::FilePath kLocalFilePath(FPL("/tmp/dir/file"));
   const std::string sync_root_id = SetUpSyncRootDirectory();
   const std::string origin_root_id = SetUpOriginRootDirectory(sync_root_id);
 
   fake_drive_uploader()->set_make_file_conflict(true);
 
   Output output;
   api_util()->UploadNewFile(
       origin_root_id,
       kLocalFilePath,
       kFileTitle,
       base::Bind(&DidUploadFile, &output));
   base::MessageLoop::current()->RunUntilIdle();
 
   // HTTP_CONFLICT error must be returned with empty resource_id.
   EXPECT_EQ(google_apis::HTTP_CONFLICT, output.error);
   EXPECT_TRUE(!output.resource_id.empty());
 
   // Verify that there is no duplicated file on the remote side.
   VerifyTitleUniqueness(origin_root_id,
                         kFileTitle,
                         output.resource_id,
-                        google_apis::ENTRY_KIND_FILE);
+                        google_apis::ResourceEntry::ENTRY_KIND_FILE);
 }
 
 void APIUtilTest::TestUploadExistingFile() {
   const base::FilePath kLocalFilePath(FPL("/tmp/dir/file"));
   const std::string kFileContent = "test content";
   const std::string kFileTitle = "test.txt";
   const std::string sync_root_id = SetUpSyncRootDirectory();
   const std::string origin_root_id = SetUpOriginRootDirectory(sync_root_id);
 
   scoped_ptr<FileResource> file;
   SetUpFile(origin_root_id, kFileContent, kFileTitle, &file);
 
   Output output;
   api_util()->UploadExistingFile(
       file->file_id(),
       file->md5_checksum(),
       kLocalFilePath,
       base::Bind(&DidUploadFile, &output));
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(google_apis::HTTP_SUCCESS, output.error);
   EXPECT_EQ(file->file_id(), output.resource_id);
 
   VerifyTitleUniqueness(origin_root_id,
                         file->title(),
                         file->file_id(),
-                        google_apis::ENTRY_KIND_FILE);
+                        google_apis::ResourceEntry::ENTRY_KIND_FILE);
 }
 
 void APIUtilTest::TestUploadExistingFileInConflict() {
   const base::FilePath kLocalFilePath(FPL("/tmp/dir/file"));
   const std::string kFileContent = "test content";
   const std::string kFileTitle = "test.txt";
   const std::string sync_root_id = SetUpSyncRootDirectory();
   const std::string origin_root_id = SetUpOriginRootDirectory(sync_root_id);
 
   scoped_ptr<FileResource> file;
@@ skipping 11 matching lines @@
       base::Bind(&DidUploadFile, &output));
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(google_apis::HTTP_CONFLICT, output.error);
   EXPECT_TRUE(output.resource_id.empty());
 
   // Verify that there is no duplicated file on the remote side.
   VerifyTitleUniqueness(origin_root_id,
                         file->title(),
                         file->file_id(),
-                        google_apis::ENTRY_KIND_FILE);
+                        google_apis::ResourceEntry::ENTRY_KIND_FILE);
 }
 
 void APIUtilTest::TestDeleteFile() {
   const std::string kFileContent = "test content";
   const std::string kFileTitle = "test.txt";
   const std::string sync_root_id = SetUpSyncRootDirectory();
   const std::string origin_root_id = SetUpOriginRootDirectory(sync_root_id);
 
   scoped_ptr<FileResource> file;
   SetUpFile(origin_root_id, kFileContent, kFileTitle, &file);
@@ skipping 27 matching lines @@
                          kExpectedRemoteFileMD5,
                          base::Bind(&DidDeleteFile, &error));
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(google_apis::HTTP_CONFLICT, error);
 
   // Verify that the conflict file was not deleted on the remote side.
   VerifyTitleUniqueness(origin_root_id,
                         file->title(),
                         file->file_id(),
-                        google_apis::ENTRY_KIND_FILE);
+                        google_apis::ResourceEntry::ENTRY_KIND_FILE);
 }
 
 void APIUtilTest::TestCreateDirectory() {
   const std::string kDirectoryTitle("directory");
   const std::string sync_root_id = SetUpSyncRootDirectory();
   const std::string origin_root_id = SetUpOriginRootDirectory(sync_root_id);
 
   Output output;
   api_util()->CreateDirectory(
       origin_root_id,
       kDirectoryTitle,
       base::Bind(&DidGetResourceID, &output));
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(google_apis::HTTP_CREATED, output.error);
   EXPECT_FALSE(output.resource_id.empty());
 
   VerifyTitleUniqueness(origin_root_id,
                         kDirectoryTitle,
                         output.resource_id,
-                        google_apis::ENTRY_KIND_FOLDER);
+                        google_apis::ResourceEntry::ENTRY_KIND_FOLDER);
 }
 
 TEST_F(APIUtilTest, GetSyncRoot) {
   ASSERT_FALSE(IsDriveAPIDisabled());
   TestGetSyncRoot();
 }
 
 TEST_F(APIUtilTest, GetSyncRoot_WAPI) {
   ScopedDisableDriveAPI disable_drive_api;
   TestGetSyncRoot();
@@ skipping 164 matching lines @@
   TestCreateDirectory();
 }
 
 TEST_F(APIUtilTest, CreateDirectory_WAPI) {
   ScopedDisableDriveAPI disable_drive_api;
   TestCreateDirectory();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system