drive: Change FileCache::GetCacheEntry's return type to FileError

chrome/browser/chromeos/drive/file_cache_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_cache.h"
 
 #include <string>
 #include <vector>
 
 #include "base/callback_helpers.h"
@@ skipping 155 matching lines @@
   ASSERT_EQ(FILE_ERROR_OK, cache_->GetFile(id_pinned, &pinned_path));
 
   // Call FreeDiskSpaceIfNeededFor().
   fake_free_disk_space_getter_->set_default_value(test_util::kLotsOfSpace);
   fake_free_disk_space_getter_->PushFakeValue(0);
   const int64 kNeededBytes = 1;
   EXPECT_TRUE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
 
   // Only 'temporary' file gets removed.
   FileCacheEntry entry;
-  EXPECT_FALSE(cache_->GetCacheEntry(id_tmp, &entry));
+  EXPECT_EQ(FILE_ERROR_NOT_FOUND, cache_->GetCacheEntry(id_tmp, &entry));
   EXPECT_FALSE(base::PathExists(tmp_path));
 
-  EXPECT_TRUE(cache_->GetCacheEntry(id_pinned, &entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id_pinned, &entry));
   EXPECT_TRUE(base::PathExists(pinned_path));
 
   // Returns false when disk space cannot be freed.
   fake_free_disk_space_getter_->set_default_value(0);
   EXPECT_FALSE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
 }
 
 TEST_F(FileCacheTest, GetFile) {
   const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
   const std::string src_contents = "test";
@@ skipping 48 matching lines @@
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         src_contents));
   std::string id("id");
   std::string md5(base::MD5String(src_contents));
 
   // Store a file.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store(
       id, md5, src_file_path, FileCache::FILE_OPERATION_COPY));
 
   FileCacheEntry cache_entry;
-  EXPECT_TRUE(cache_->GetCacheEntry(id, &cache_entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &cache_entry));
   EXPECT_TRUE(cache_entry.is_present());
   EXPECT_EQ(md5, cache_entry.md5());
 
   base::FilePath cache_file_path;
   EXPECT_EQ(FILE_ERROR_OK, cache_->GetFile(id, &cache_file_path));
   EXPECT_TRUE(base::ContentsEqual(src_file_path, cache_file_path));
 
   // Store a non-existent file.
   EXPECT_EQ(FILE_ERROR_FAILED, cache_->Store(
       id, md5, base::FilePath::FromUTF8Unsafe("non_existent_file"),
       FileCache::FILE_OPERATION_COPY));
 
   // Passing empty MD5 marks the entry as dirty.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store(
       id, std::string(), src_file_path, FileCache::FILE_OPERATION_COPY));
 
-  EXPECT_TRUE(cache_->GetCacheEntry(id, &cache_entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &cache_entry));
   EXPECT_TRUE(cache_entry.is_present());
   EXPECT_TRUE(cache_entry.md5().empty());
   EXPECT_TRUE(cache_entry.is_dirty());
 
   // No free space available.
   fake_free_disk_space_getter_->set_default_value(0);
 
   EXPECT_EQ(FILE_ERROR_NO_LOCAL_SPACE, cache_->Store(
       id, md5, src_file_path, FileCache::FILE_OPERATION_COPY));
 }
 
 TEST_F(FileCacheTest, PinAndUnpin) {
   const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
   const std::string src_contents = "test";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         src_contents));
   std::string id("id_present");
   std::string md5(base::MD5String(src_contents));
 
   // Store a file.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store(
       id, md5, src_file_path, FileCache::FILE_OPERATION_COPY));
 
   FileCacheEntry cache_entry;
-  EXPECT_TRUE(cache_->GetCacheEntry(id, &cache_entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &cache_entry));
   EXPECT_FALSE(cache_entry.is_pinned());
 
   // Pin the existing file.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Pin(id));
 
-  EXPECT_TRUE(cache_->GetCacheEntry(id, &cache_entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &cache_entry));
   EXPECT_TRUE(cache_entry.is_pinned());
 
   // Unpin the file.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Unpin(id));
 
-  EXPECT_TRUE(cache_->GetCacheEntry(id, &cache_entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &cache_entry));
   EXPECT_FALSE(cache_entry.is_pinned());
 
   // Pin a non-present file.
   std::string id_non_present = "id_non_present";
   EXPECT_EQ(FILE_ERROR_OK, cache_->Pin(id_non_present));
 
-  EXPECT_TRUE(cache_->GetCacheEntry(id_non_present, &cache_entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id_non_present, &cache_entry));
   EXPECT_TRUE(cache_entry.is_pinned());
 
   // Unpin the previously pinned non-existent file.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Unpin(id_non_present));
 
-  EXPECT_FALSE(cache_->GetCacheEntry(id_non_present, &cache_entry));
+  EXPECT_EQ(FILE_ERROR_NOT_FOUND,
+            cache_->GetCacheEntry(id_non_present, &cache_entry));
 
   // Unpin a file that doesn't exist in cache and is not pinned.
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, cache_->Unpin("id_non_existent"));
 }
 
 TEST_F(FileCacheTest, MountUnmount) {
   const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
   const std::string src_contents = "test";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         src_contents));
@@ skipping 23 matching lines @@
   base::FilePath src_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
 
   const std::string id = "id";
   ASSERT_EQ(FILE_ERROR_OK, cache_->Store(id, "md5", src_file,
                                          FileCache::FILE_OPERATION_COPY));
 
   // Entry is not dirty nor opened.
   EXPECT_FALSE(cache_->IsOpenedForWrite(id));
   FileCacheEntry entry;
-  EXPECT_TRUE(cache_->GetCacheEntry(id, &entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &entry));
   EXPECT_FALSE(entry.is_dirty());
 
   // Open (1).
   scoped_ptr<base::ScopedClosureRunner> file_closer1;
   EXPECT_EQ(FILE_ERROR_OK, cache_->OpenForWrite(id, &file_closer1));
   EXPECT_TRUE(cache_->IsOpenedForWrite(id));
 
   // Entry is dirty.
-  EXPECT_TRUE(cache_->GetCacheEntry(id, &entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &entry));
   EXPECT_TRUE(entry.is_dirty());
 
   // Open (2).
   scoped_ptr<base::ScopedClosureRunner> file_closer2;
   EXPECT_EQ(FILE_ERROR_OK, cache_->OpenForWrite(id, &file_closer2));
   EXPECT_TRUE(cache_->IsOpenedForWrite(id));
 
   // Close (1).
   file_closer1.reset();
   EXPECT_TRUE(cache_->IsOpenedForWrite(id));
@@ skipping 28 matching lines @@
                                                         contents_after));
 
   // Cannot update MD5 of an opend file.
   EXPECT_EQ(FILE_ERROR_IN_USE, cache_->UpdateMd5(id));
 
   // Close file.
   file_closer.reset();
 
   // MD5 was cleared by OpenForWrite().
   FileCacheEntry entry;
-  EXPECT_TRUE(cache_->GetCacheEntry(id, &entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &entry));
   EXPECT_TRUE(entry.md5().empty());
 
   // Update MD5.
   EXPECT_EQ(FILE_ERROR_OK, cache_->UpdateMd5(id));
-  EXPECT_TRUE(cache_->GetCacheEntry(id, &entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &entry));
   EXPECT_EQ(base::MD5String(contents_after), entry.md5());
 }
 
 TEST_F(FileCacheTest, ClearDirty) {
   // Prepare a file.
   base::FilePath src_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
 
   const std::string id = "id";
   ASSERT_EQ(FILE_ERROR_OK, cache_->Store(id, "md5", src_file,
                                          FileCache::FILE_OPERATION_COPY));
 
   // Open the file.
   scoped_ptr<base::ScopedClosureRunner> file_closer;
   EXPECT_EQ(FILE_ERROR_OK, cache_->OpenForWrite(id, &file_closer));
 
   // Entry is dirty.
   FileCacheEntry entry;
-  EXPECT_TRUE(cache_->GetCacheEntry(id, &entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &entry));
   EXPECT_TRUE(entry.is_dirty());
 
   // Cannot clear the dirty bit of an opened entry.
   EXPECT_EQ(FILE_ERROR_IN_USE, cache_->ClearDirty(id));
 
   // Close the file and clear the dirty bit.
   file_closer.reset();
   EXPECT_EQ(FILE_ERROR_OK, cache_->ClearDirty(id));
 
   // Entry is not dirty.
-  EXPECT_TRUE(cache_->GetCacheEntry(id, &entry));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &entry));
   EXPECT_FALSE(entry.is_dirty());
 }
 
 TEST_F(FileCacheTest, Remove) {
   const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
   const std::string src_contents = "test";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         src_contents));
   std::string id("id");
   std::string md5(base::MD5String(src_contents));
@@ skipping 56 matching lines @@
   const std::string md5("abcdef0123456789");
 
   // Store an existing file.
   base::FilePath src_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
   ASSERT_EQ(FILE_ERROR_OK,
             cache_->Store(id, md5, src_file, FileCache::FILE_OPERATION_COPY));
 
   // Verify that the cache entry is created.
   FileCacheEntry cache_entry;
-  ASSERT_TRUE(cache_->GetCacheEntry(id, &cache_entry));
+  ASSERT_EQ(FILE_ERROR_OK, cache_->GetCacheEntry(id, &cache_entry));
 
   // Clear cache.
   EXPECT_TRUE(cache_->ClearAll());
 
   // Verify that the cache is removed.
-  EXPECT_FALSE(cache_->GetCacheEntry(id, &cache_entry));
+  EXPECT_EQ(FILE_ERROR_NOT_FOUND, cache_->GetCacheEntry(id, &cache_entry));
   EXPECT_TRUE(base::IsDirectoryEmpty(cache_files_dir_));
 }
 
 }  // namespace internal
 }  // namespace drive