drive: Remove DriveFileType

chrome/browser/chromeos/drive/file_system_unittest.cc

 // Copyright (c) 2012 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/chromeos/drive/file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 1591 matching lines @@
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetEntryInfoByPathSync(file_in_root));
   const int64 file_size = entry->file_info().size();
 
   // Pretend we have enough space.
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       file_size + internal::kMinFreeSpace);
 
   FileError error = FILE_ERROR_FAILED;
   base::FilePath file_path;
-  std::string mime_type;
-  DriveFileType file_type;
+  entry.reset();
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &mime_type, &file_type));
+                                  &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
-  EXPECT_EQ(REGULAR_FILE, file_type);
+  ASSERT_TRUE(entry);
+  EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
 
   // Verify that readable permission is set.
   int permission = 0;
   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_path, &permission));
   EXPECT_EQ(file_util::FILE_PERMISSION_READ_BY_USER |
             file_util::FILE_PERMISSION_WRITE_BY_USER |
             file_util::FILE_PERMISSION_READ_BY_GROUP |
             file_util::FILE_PERMISSION_READ_BY_OTHERS, permission);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_NoSpaceAtAll) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
-  scoped_ptr<ResourceEntry> entry(GetEntryInfoByPathSync(file_in_root));
 
   // Pretend we have no space at all.
   fake_free_disk_space_getter_->set_fake_free_disk_space(0);
 
   FileError error = FILE_ERROR_OK;
   base::FilePath file_path;
-  std::string mime_type;
-  DriveFileType file_type;
+  scoped_ptr<ResourceEntry> entry;
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &mime_type, &file_type));
+                                  &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_NO_SPACE, error);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_NoEnoughSpaceButCanFreeUp) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
@@ skipping 25 matching lines @@
 
   FileError error = FILE_ERROR_FAILED;
   cache_->Store("<resource_id>", "<md5>", tmp_file,
                 internal::FileCache::FILE_OPERATION_COPY,
                 google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(CacheEntryExists("<resource_id>", "<md5>"));
 
   base::FilePath file_path;
-  std::string mime_type;
-  DriveFileType file_type;
+  entry.reset();
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &mime_type, &file_type));
+                                  &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
-  EXPECT_EQ(REGULAR_FILE, file_type);
+  ASSERT_TRUE(entry);
+  EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
 
   // The cache entry should be removed in order to free up space.
   ASSERT_FALSE(CacheEntryExists("<resource_id>", "<md5>"));
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_EnoughSpaceButBecomeFull) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetEntryInfoByPathSync(file_in_root));
   const int64 file_size = entry->file_info().size();
 
   // Pretend we have enough space first (checked before downloading a file),
   // but then start reporting we have not enough space. This is to emulate that
   // the disk space becomes full after the file is downloaded for some reason
   // (ex. the actual file was larger than the expected size).
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       file_size + internal::kMinFreeSpace);
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       internal::kMinFreeSpace - 1);
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       internal::kMinFreeSpace - 1);
 
   FileError error = FILE_ERROR_OK;
   base::FilePath file_path;
-  std::string mime_type;
-  DriveFileType file_type;
+  entry.reset();
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &mime_type, &file_type));
+                                  &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_NO_SPACE, error);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromCache) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetEntryInfoByPathSync(file_in_root));
 
   // Store something as cached version of this file.
   FileError error = FILE_ERROR_OK;
   cache_->Store(entry->resource_id(),
                 entry->file_specific_info().file_md5(),
                 google_apis::test_util::GetTestFilePath(
                     "chromeos/gdata/root_feed.json"),
                 internal::FileCache::FILE_OPERATION_COPY,
                 google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   base::FilePath file_path;
-  std::string mime_type;
-  DriveFileType file_type;
+  entry.reset();
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &mime_type, &file_type));
+                                  &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
-  EXPECT_EQ(REGULAR_FILE, file_type);
+  ASSERT_TRUE(entry);
+  EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_HostedDocument) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL(
       "drive/root/Document 1 excludeDir-test.gdoc"));
   scoped_ptr<ResourceEntry> src_entry =
       GetEntryInfoByPathSync(file_in_root);
   ASSERT_TRUE(src_entry);
 
   FileError error = FILE_ERROR_FAILED;
   base::FilePath file_path;
-  std::string mime_type;
-  DriveFileType file_type;
+  scoped_ptr<ResourceEntry> entry;
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &mime_type, &file_type));
+                                  &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
-  EXPECT_EQ(HOSTED_DOCUMENT, file_type);
+  EXPECT_EQ(FILE_ERROR_OK, error);
+  ASSERT_TRUE(entry);
+  EXPECT_TRUE(entry->file_specific_info().is_hosted_document());
   EXPECT_FALSE(file_path.empty());
 
   ASSERT_TRUE(src_entry);
   VerifyHostedDocumentJSONFile(*src_entry, file_path);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByResourceId) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetEntryInfoByPathSync(file_in_root));
+  std::string resource_id = entry->resource_id();
 
   FileError error = FILE_ERROR_OK;
   base::FilePath file_path;
-  std::string mime_type;
-  DriveFileType file_type;
+  entry.reset();
   file_system_->GetFileByResourceId(
-      entry->resource_id(),
+      resource_id,
       DriveClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(
-          &error, &file_path, &mime_type, &file_type),
+          &error, &file_path, &entry),
       google_apis::GetContentCallback());
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
-  EXPECT_EQ(REGULAR_FILE, file_type);
+  ASSERT_TRUE(entry);
+  EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
 }
 
 TEST_F(DriveFileSystemTest, GetFileContentByPath) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
@@ skipping 84 matching lines @@
                     "chromeos/gdata/root_feed.json"),
                 internal::FileCache::FILE_OPERATION_COPY,
                 google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // The file is obtained from the cache.
   // Hence the downloading should work even if the drive service is offline.
   fake_drive_service_->set_offline(true);
 
+  std::string resource_id = entry->resource_id();
   base::FilePath file_path;
-  std::string mime_type;
-  DriveFileType file_type;
+  entry.reset();
   file_system_->GetFileByResourceId(
-      entry->resource_id(),
+      resource_id,
       DriveClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(
-          &error, &file_path, &mime_type, &file_type),
+          &error, &file_path, &entry),
       google_apis::GetContentCallback());
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
-  EXPECT_EQ(REGULAR_FILE, file_type);
+  ASSERT_TRUE(entry);
+  EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
 }
 
 TEST_F(DriveFileSystemTest, UpdateFileByResourceId_PersistentFile) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // This is a file defined in root_feed.json.
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   const std::string kResourceId("file:2_file_resource_id");
@@ skipping 411 matching lines @@
 
   // Create fails if the parent directory does not exist.
   file_system_->CreateFile(
       kFileInNonExistingDirectory, false,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_NOT_A_DIRECTORY, error);
 }
 
 }   // namespace drive