Mark removable Drive caches for cryptohome.

components/drive/chromeos/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 "components/drive/chromeos/file_cache.h"
 
+#include <fcntl.h>
+#include <linux/fs.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <sys/xattr.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/md5.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
+#include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/drive/chromeos/drive_test_util.h"
 #include "components/drive/chromeos/fake_free_disk_space_getter.h"
 #include "components/drive/drive.pb.h"
 #include "components/drive/file_system_core_util.h"
 #include "components/drive/resource_metadata_storage.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/drive/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace drive {
 namespace internal {
 namespace {
 
 const base::FilePath::CharType kCacheFileDirectory[] =
     FILE_PATH_LITERAL("files");
-const base::FilePath::CharType kNewCacheFileDirectory[] =
-    FILE_PATH_LITERAL("blobs");
-const base::FilePath::CharType kLinkDirectory[] = FILE_PATH_LITERAL("links");
 
 const int kTemporaryFileSizeInBytes = 10;
 
-int GetNumberOfLinks(const base::FilePath& file_path) {
-  struct stat result;
-  if (stat(file_path.AsUTF8Unsafe().c_str(), &result) != 0) {
-    return -1;
-  }
-  return result.st_nlink;
+int64_t Lsattr(const base::FilePath& file_path) {

[hashimoto, 2016/05/02 08:29:20]

Please give this function a more readable name.

BTW, instead of having this function which does the same thing as lsattr(1), how
about having a function which returns if the file has FS_NODUMP_FL or not?
I think it should make the code simpler and more readable.

[oka, 2016/05/09 14:27:41]

Done.

+  int fd = open(file_path.value().c_str(), O_RDONLY);

[hashimoto, 2016/05/02 08:29:21]

HANDLE_EINTR should be used.

[oka, 2016/05/09 14:27:41]

Removed.

+  if (fd < 0) return -1;
+  int64_t flags = 0;
+  if (ioctl(fd, FS_IOC_GETFLAGS, &flags) < 0) return -1;

[hashimoto, 2016/05/02 08:29:20]

Please use base::File.
This line leaks fd.

[oka, 2016/05/09 14:27:41]

Done.

+  close(fd);
+  return flags;
 }
 
 }  // namespace
 
 // Tests FileCache methods working with the blocking task runner.
 class FileCacheTest : public testing::Test {
  protected:
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     const base::FilePath metadata_dir = temp_dir_.path().AppendASCII("meta");
     cache_files_dir_ = temp_dir_.path().Append(kCacheFileDirectory);
 
     ASSERT_TRUE(base::CreateDirectory(metadata_dir));
     ASSERT_TRUE(base::CreateDirectory(cache_files_dir_));
 
     fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
 
     metadata_storage_.reset(new ResourceMetadataStorage(
         metadata_dir,
         base::ThreadTaskRunnerHandle::Get().get()));
     ASSERT_TRUE(metadata_storage_->Initialize());
 
     cache_.reset(new FileCache(metadata_storage_.get(), cache_files_dir_,
                                base::ThreadTaskRunnerHandle::Get().get(),
                                fake_free_disk_space_getter_.get()));
-    ASSERT_TRUE(cache_->Initialize());
   }
 
   static bool RenameCacheFilesToNewFormat(FileCache* cache) {
     return cache->RenameCacheFilesToNewFormat();
   }
 
   base::FilePath AddTestEntry(const std::string id,
                               const std::string md5,
                               const time_t last_accessed,
                               const base::FilePath& src_file) {
@@ skipping 18 matching lines @@
   base::ScopedTempDir temp_dir_;
   base::FilePath cache_files_dir_;
 
   std::unique_ptr<ResourceMetadataStorage, test_util::DestroyHelperForTests>
       metadata_storage_;
   std::unique_ptr<FileCache, test_util::DestroyHelperForTests> cache_;
   std::unique_ptr<FakeFreeDiskSpaceGetter> fake_free_disk_space_getter_;
 };
 
 TEST_F(FileCacheTest, RecoverFilesFromCacheDirectory) {
+  ASSERT_TRUE(cache_->Initialize());

[hashimoto, 2016/05/02 08:29:20]

Instead of calling Initialize() everywhere, how about resetting cache_ in the
beginning of the migration test instead?

[oka, 2016/05/09 14:27:40]

Done. Given we run migration everytime, moving this to Setup is fine.

   base::FilePath dir_source_root;
   EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &dir_source_root));
   const base::FilePath src_path =
       dir_source_root.AppendASCII("chrome/test/data/chromeos/drive/image.png");
 
   // Store files. This file should not be moved.
   ResourceEntry entry;
   entry.set_local_id("id_foo");
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store("id_foo", "md5", src_path,
@@ skipping 32 matching lines @@
         dest_directory.AppendASCII("image00000001.png")));
     EXPECT_TRUE(base::ContentsEqual(
         src_path,
         dest_directory.AppendASCII("baz00000002.png")));
   }
   EXPECT_FALSE(base::PathExists(
       dest_directory.AppendASCII("image00000003.png")));
 }
 
 TEST_F(FileCacheTest, FreeDiskSpaceIfNeededFor) {
+  ASSERT_TRUE(cache_->Initialize());
   base::FilePath src_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
 
   // Store a file as a 'temporary' file and remember the path.
   const std::string id_tmp = "id_tmp", md5_tmp = "md5_tmp";
   const time_t last_accessed_tmp = 1;
   const base::FilePath& tmp_path =
       AddTestEntry(id_tmp, md5_tmp, last_accessed_tmp, src_file);
 
   // Store a file as a pinned file and remember the path.
@@ skipping 19 matching lines @@
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_pinned, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_present());
   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, EvictDriveCacheInLRU) {
+  ASSERT_TRUE(cache_->Initialize());
   // Create temporary file.
   base::FilePath src_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
   ASSERT_EQ(kTemporaryFileSizeInBytes,
             base::WriteFile(src_file, "abcdefghij", kTemporaryFileSizeInBytes));
 
   // Add entries.
   const std::string id_a = "id_a", md5_a = "md5_a";
   const time_t last_accessed_a = 1;
   const base::FilePath& a_path =
@@ skipping 40 matching lines @@
 
   // Entry C should not be evicted.
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_c, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_present());
   EXPECT_TRUE(base::PathExists(c_path));
 }
 
 // Test case for deleting invalid cache files which don't have corresponding
 // metadata.
 TEST_F(FileCacheTest, EvictInvalidCacheFile) {
+  ASSERT_TRUE(cache_->Initialize());
   base::FilePath src_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
 
   // Add entries.
   const std::string id_a = "id_a", md5_a = "md5_a";
   const time_t last_accessed_a = 1;
   const base::FilePath& a_path =
       AddTestEntry(id_a, md5_a, last_accessed_a, src_file);
 
   const std::string id_b = "id_b", md5_b = "md5_b";
@@ skipping 18 matching lines @@
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_a, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_present());
   EXPECT_TRUE(base::PathExists(a_path));
 
   // Entry B is evicted.
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, metadata_storage_->GetEntry(id_b, &entry));
   EXPECT_FALSE(base::PathExists(b_path));
 }
 
 TEST_F(FileCacheTest, TooManyCacheFiles) {
+  ASSERT_TRUE(cache_->Initialize());
   const size_t kMaxNumOfEvictedCacheFiles = 50;
   cache_->SetMaxNumOfEvictedCacheFilesForTest(kMaxNumOfEvictedCacheFiles);
 
   // Create temporary file.
   base::FilePath src_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
   ASSERT_EQ(kTemporaryFileSizeInBytes,
             base::WriteFile(src_file, "abcdefghij", kTemporaryFileSizeInBytes));
 
   // Add kNumOfTestFiles=kMaxNumOfEvictedCacheFiles*2 entries.
@@ skipping 23 matching lines @@
       (kMaxNumOfEvictedCacheFiles * 3 / 2) * kTemporaryFileSizeInBytes;
   EXPECT_FALSE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
 
   for (uint32_t i = 0; i < kNumOfTestFiles; ++i) {
     // Assert that only first kMaxNumOfEvictedCacheFiles exist.
     ASSERT_EQ(i < kMaxNumOfEvictedCacheFiles, base::PathExists(paths[i]));
   }
 }
 
 TEST_F(FileCacheTest, GetFile) {
+  ASSERT_TRUE(cache_->Initialize());
   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("id1");
   std::string md5(base::MD5String(src_contents));
 
   const base::FilePath cache_file_directory =
       temp_dir_.path().Append(kCacheFileDirectory);
 
@@ skipping 34 matching lines @@
   EXPECT_EQ(
       cache_file_directory.AppendASCII(util::EscapeCacheFileName(id)).value(),
       cache_file_path.value());
 
   contents.clear();
   EXPECT_TRUE(base::ReadFileToString(cache_file_path, &contents));
   EXPECT_EQ(src_contents, contents);
 }
 
 TEST_F(FileCacheTest, Store) {
+  ASSERT_TRUE(cache_->Initialize());
   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));
 
   // Store a file.
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store(
       id, md5, src_file_path, FileCache::FILE_OPERATION_COPY));
 
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_present());
   EXPECT_EQ(md5, entry.file_specific_info().cache_state().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));
 
+  base::FilePath dest_file_path = cache_files_dir_.AppendASCII(id);

[hashimoto, 2016/05/02 08:29:20]

This path construction is an internal logic of FileCache, and it can change in
future.
Could you use FileCache::GetCacheFilePath()?
FileCacheTest is marked as a friend of FileCache so you can add a wrapper
function of GetCacheFilePath() to use it from tests.

The existing migration test did this because GetCacheFilePath doesn't work with
old_cache_dir.

[oka, 2016/05/09 14:27:40]

Done.

+  int64_t flags = Lsattr(dest_file_path);
+  EXPECT_GE(flags, 0);

[hashimoto, 2016/05/02 08:29:21]

What is the point of this check?
You want to see if the top bit is set or not?

[oka, 2016/05/09 14:27:40]

Done. Used ExpectIsRemovable.

+  EXPECT_EQ(flags & FS_NODUMP_FL, FS_NODUMP_FL);
+
   // 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_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_present());
   EXPECT_TRUE(entry.file_specific_info().cache_state().md5().empty());
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_dirty());
+  flags &= ~FS_NODUMP_FL;
+  EXPECT_EQ(Lsattr(dest_file_path), flags);
 
   // 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) {
+  ASSERT_TRUE(cache_->Initialize());
   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.
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store(
       id, md5, src_file_path, FileCache::FILE_OPERATION_COPY));
 
+  const base::FilePath dest_file_path = cache_files_dir_.AppendASCII(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_FALSE(entry.file_specific_info().cache_state().is_pinned());
+  int64_t flags = Lsattr(dest_file_path);
+  ASSERT_GE(flags, 0);
+  EXPECT_EQ(flags & FS_NODUMP_FL, FS_NODUMP_FL);
 
   // Pin the existing file.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Pin(id));
 
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_pinned());
+  flags &= ~FS_NODUMP_FL;
+  EXPECT_EQ(Lsattr(dest_file_path),flags);
 
   // Unpin the file.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Unpin(id));
 
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_FALSE(entry.file_specific_info().cache_state().is_pinned());
+  flags |= FS_NODUMP_FL;
+  EXPECT_EQ(Lsattr(dest_file_path), flags);
 
   // Pin a non-present file.
   std::string id_non_present = "id_non_present";
   entry.Clear();
   entry.set_local_id(id_non_present);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   EXPECT_EQ(FILE_ERROR_OK, cache_->Pin(id_non_present));
 
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_non_present, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_pinned());
 
   // Unpin the previously pinned non-existent file.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Unpin(id_non_present));
 
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_non_present, &entry));
   EXPECT_FALSE(entry.file_specific_info().has_cache_state());
 
   // 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) {
+  ASSERT_TRUE(cache_->Initialize());
   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.
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store(
       id, md5, src_file_path, FileCache::FILE_OPERATION_COPY));
 
   // Mark the file mounted.
   base::FilePath cache_file_path;
   EXPECT_EQ(FILE_ERROR_OK, cache_->MarkAsMounted(id, &cache_file_path));
 
   // Try to remove it.
   EXPECT_EQ(FILE_ERROR_IN_USE, cache_->Remove(id));
 
   // Clear mounted state of the file.
   EXPECT_EQ(FILE_ERROR_OK, cache_->MarkAsUnmounted(cache_file_path));
 
   // Try to remove again.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Remove(id));
 }
 
 TEST_F(FileCacheTest, OpenForWrite) {
+  ASSERT_TRUE(cache_->Initialize());
   // Prepare a file.
   base::FilePath src_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
 
   const std::string id = "id";
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   ASSERT_EQ(FILE_ERROR_OK, cache_->Store(id, "md5", src_file,
                                          FileCache::FILE_OPERATION_COPY));
   EXPECT_EQ(0, entry.file_info().last_modified());
 
   // Entry is not dirty nor opened.
   EXPECT_FALSE(cache_->IsOpenedForWrite(id));
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_FALSE(entry.file_specific_info().cache_state().is_dirty());
 
+  const base::FilePath dest_file = cache_files_dir_.AppendASCII(id);
+  int64_t flags = Lsattr(dest_file);
+  ASSERT_GE(flags, 0);
+  EXPECT_EQ(flags & FS_NODUMP_FL, FS_NODUMP_FL);
+
   // Open (1).
   std::unique_ptr<base::ScopedClosureRunner> file_closer1;
   EXPECT_EQ(FILE_ERROR_OK, cache_->OpenForWrite(id, &file_closer1));
   EXPECT_TRUE(cache_->IsOpenedForWrite(id));
 
   // Entry is dirty.
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_dirty());
+  flags &= ~FS_NODUMP_FL;
+  EXPECT_EQ(Lsattr(dest_file), flags);
 
   // Open (2).
   std::unique_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();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(cache_->IsOpenedForWrite(id));
 
   // last_modified is updated.
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_NE(0, entry.file_info().last_modified());
 
   // Close (2).
   file_closer2.reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(cache_->IsOpenedForWrite(id));
 
   // Try to open non-existent file.
   EXPECT_EQ(FILE_ERROR_NOT_FOUND,
             cache_->OpenForWrite("nonexistent_id", &file_closer1));
 }
 
 TEST_F(FileCacheTest, UpdateMd5) {
+  ASSERT_TRUE(cache_->Initialize());
   // Store test data.
   const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
   const std::string contents_before = "before";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         contents_before));
   std::string id("id1");
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store(id, base::MD5String(contents_before),
@@ skipping 21 matching lines @@
   EXPECT_TRUE(entry.file_specific_info().cache_state().md5().empty());
 
   // Update MD5.
   EXPECT_EQ(FILE_ERROR_OK, cache_->UpdateMd5(id));
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_EQ(base::MD5String(contents_after),
             entry.file_specific_info().cache_state().md5());
 }
 
 TEST_F(FileCacheTest, ClearDirty) {
+  ASSERT_TRUE(cache_->Initialize());
   // Prepare a file.
   base::FilePath src_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
 
   const std::string id = "id";
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   ASSERT_EQ(FILE_ERROR_OK, cache_->Store(id, "md5", src_file,
                                          FileCache::FILE_OPERATION_COPY));
 
+  const base::FilePath dest_file = cache_files_dir_.AppendASCII(id);
+
+  int64_t flags = Lsattr(dest_file);
+  ASSERT_GE(flags, 0);
+  EXPECT_EQ(flags & FS_NODUMP_FL, FS_NODUMP_FL);
+
   // Open the file.
   std::unique_ptr<base::ScopedClosureRunner> file_closer;
   EXPECT_EQ(FILE_ERROR_OK, cache_->OpenForWrite(id, &file_closer));
 
   // Entry is dirty.
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_dirty());
+  flags &= ~FS_NODUMP_FL;
+  EXPECT_EQ(Lsattr(dest_file), flags);
 
   // Cannot clear the dirty bit of an opened entry.
   EXPECT_EQ(FILE_ERROR_IN_USE, cache_->ClearDirty(id));
+  EXPECT_EQ(Lsattr(dest_file), flags);
 
   // Close the file and clear the dirty bit.
   file_closer.reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, cache_->ClearDirty(id));
 
   // Entry is not dirty.
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_FALSE(entry.file_specific_info().cache_state().is_dirty());
+  flags |= FS_NODUMP_FL;
+  EXPECT_EQ(Lsattr(dest_file), flags);
 }
 
 TEST_F(FileCacheTest, Remove) {
+  ASSERT_TRUE(cache_->Initialize());
   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));
 
   // First store a file to cache.
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   base::FilePath src_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store(
       id, md5, src_file_path, FileCache::FILE_OPERATION_COPY));
 
   base::FilePath cache_file_path;
   EXPECT_EQ(FILE_ERROR_OK, cache_->GetFile(id, &cache_file_path));
 
   // Then try to remove existing file from cache.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Remove(id));
   EXPECT_FALSE(base::PathExists(cache_file_path));
 }
 
 TEST_F(FileCacheTest, RenameCacheFilesToNewFormat) {
+  ASSERT_TRUE(cache_->Initialize());
   const base::FilePath file_directory =
       temp_dir_.path().Append(kCacheFileDirectory);
 
   // File with an old style "<prefix>:<ID>.<MD5>" name.
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(
       file_directory.AppendASCII("file:id_koo.md5"), "koo"));
 
   // File with multiple extensions should be removed.
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(
       file_directory.AppendASCII("id_kyu.md5.mounted"), "kyu (mounted)"));
@@ skipping 18 matching lines @@
   contents.clear();
   EXPECT_TRUE(base::ReadFileToString(file_directory.AppendASCII("id_koo"),
                                      &contents));
   EXPECT_EQ("koo", contents);
   contents.clear();
   EXPECT_TRUE(base::ReadFileToString(file_directory.AppendASCII("id_kyu"),
                                      &contents));
   EXPECT_EQ("kyu", contents);
 }
 
-// Test for migrating cache files from files to blobs.
+// Test for migrating cache files resolving inconsistency in metadata.
 TEST_F(FileCacheTest, MigrateCacheFiles) {
   // Create test files and metadata.
   base::FilePath temp_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file));
 
-  const base::FilePath old_cache_dir =
-      temp_dir_.path().Append(kCacheFileDirectory);
-  const base::FilePath new_cache_dir =
-      temp_dir_.path().Append(kNewCacheFileDirectory);
-  const base::FilePath link_dir = temp_dir_.path().Append(kLinkDirectory);
-  ASSERT_TRUE(base::CreateDirectory(old_cache_dir));
-  ASSERT_TRUE(base::CreateDirectory(new_cache_dir));
-  ASSERT_TRUE(base::CreateDirectory(link_dir));
-
-  // Entry A: cache file in old cache directory with metadata.
+  // Entry A: pinned cache file.
   const std::string id_a = "id_a";
   ResourceEntry entry_a;
   entry_a.set_local_id(id_a);
-  entry_a.mutable_file_specific_info()->mutable_cache_state()->set_is_present(
-      true);
+  FileCacheEntry* file_cache_entry_a =
+      entry_a.mutable_file_specific_info()->mutable_cache_state();
+  file_cache_entry_a->set_is_present(true);
+  file_cache_entry_a->set_is_pinned(true);
+  file_cache_entry_a->set_is_dirty(false);
   ASSERT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry_a));
-  const base::FilePath old_file_path_a = old_cache_dir.AppendASCII(id_a);
-  const base::FilePath new_file_path_a = new_cache_dir.AppendASCII(id_a);
-  ASSERT_TRUE(base::CopyFile(temp_file, old_file_path_a));
+  const base::FilePath file_path_a = cache_files_dir_.AppendASCII(id_a);
+  ASSERT_TRUE(base::CopyFile(temp_file, file_path_a));
 
-  // Entry B: cache file in old cache directory without metadata.
+  // Entry B: dirty cache file.
   const std::string id_b = "id_b";
-  const base::FilePath old_file_path_b = old_cache_dir.AppendASCII(id_b);
-  ASSERT_TRUE(base::CopyFile(temp_file, old_file_path_b));
+  ResourceEntry entry_b;
+  entry_b.set_local_id(id_b);
+  FileCacheEntry* file_cache_entry_b =
+      entry_b.mutable_file_specific_info()->mutable_cache_state();
+  file_cache_entry_b->set_is_present(true);
+  file_cache_entry_b->set_is_pinned(false);
+  file_cache_entry_b->set_is_dirty(true);
+  ASSERT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry_b));
+  const base::FilePath file_path_b = cache_files_dir_.AppendASCII(id_b);
+  ASSERT_TRUE(base::CopyFile(temp_file, file_path_b));
 
-  // Entry C: already migrated cache file.
+  // Entry C: not pinned nor dirty cache file.
   const std::string id_c = "id_c";
   ResourceEntry entry_c;
   entry_c.set_local_id(id_c);
-  entry_c.mutable_file_specific_info()->mutable_cache_state()->set_is_present(
-      true);
+  FileCacheEntry* file_cache_entry_c =
+      entry_c.mutable_file_specific_info()->mutable_cache_state();
+  file_cache_entry_c->set_is_present(true);
+  file_cache_entry_c->set_is_pinned(false);
+  file_cache_entry_c->set_is_dirty(false);
   ASSERT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry_c));
-  const base::FilePath new_file_path_c = new_cache_dir.AppendASCII(id_c);
-  ASSERT_TRUE(base::CopyFile(temp_file, new_file_path_c));
+  const base::FilePath file_path_c = cache_files_dir_.AppendASCII(id_c);
+  ASSERT_TRUE(base::CopyFile(temp_file, file_path_c));
 
-  // Entry D: metadata entry without cache file.
+  // Entry D: pinned cache file somehow having removable flag.
   const std::string id_d = "id_d";
   ResourceEntry entry_d;
   entry_d.set_local_id(id_d);
-  entry_d.mutable_file_specific_info()->mutable_cache_state()->set_is_present(
-      true);
+  FileCacheEntry* file_cache_entry_d =
+      entry_d.mutable_file_specific_info()->mutable_cache_state();
+  file_cache_entry_d->set_is_present(true);
+  file_cache_entry_d->set_is_pinned(true);
+  file_cache_entry_d->set_is_dirty(false);
   ASSERT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry_d));
+  const base::FilePath file_path_d = cache_files_dir_.AppendASCII(id_d);
+  ASSERT_TRUE(base::CopyFile(temp_file, file_path_d));
 
-  // Entry E: pinned cache file.
+  // Set removable flag.

[hashimoto, 2016/05/02 08:29:21]

How about reusing the function in file_cache.cc?
(e.g. adding a new static public method to FileCache, or adding a new .cc file
which hosts utility functions like this.)

[oka, 2016/05/09 14:27:41]

This is the only usage of FS_IOC_SETFLAGS in this unit test.
I think extracting a file or making the method public is overkill for now.

+  int fd;
+  ASSERT_GE(fd = open(file_path_d.value().c_str(), O_RDONLY), 0);
+  int64_t flags;
+  ASSERT_EQ(ioctl(fd, FS_IOC_GETFLAGS, &flags), 0);

[hashimoto, 2016/05/02 08:29:20]

Why aren't you using the lsattr function above?

[oka, 2016/05/09 14:27:41]

Done.

+  flags |= FS_NODUMP_FL;
+  ASSERT_EQ(ioctl(fd, FS_IOC_SETFLAGS, &flags), 0);
+  close(fd);

[hashimoto, 2016/05/02 08:29:21]

Please use base::File (or base::ScopedFD) instead of manually calling close().

[oka, 2016/05/09 14:27:41]

Done.

+
+  // Entry E: there is no file; removed by cryptohome.
   const std::string id_e = "id_e";
   ResourceEntry entry_e;
   entry_e.set_local_id(id_e);
   FileCacheEntry* file_cache_entry_e =
       entry_e.mutable_file_specific_info()->mutable_cache_state();
   file_cache_entry_e->set_is_present(true);
-  file_cache_entry_e->set_is_pinned(true);
+  file_cache_entry_e->set_is_pinned(false);
   file_cache_entry_e->set_is_dirty(false);
   ASSERT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry_e));
-  const base::FilePath old_file_path_e = old_cache_dir.AppendASCII(id_e);
-  const base::FilePath new_file_path_e = new_cache_dir.AppendASCII(id_e);
-  const base::FilePath link_path_e = link_dir.AppendASCII(id_e);
-  ASSERT_TRUE(base::CopyFile(temp_file, old_file_path_e));
+  const base::FilePath file_path_e = cache_files_dir_.AppendASCII(id_e);
 
-  // Entry F: dirty cache file.
-  const std::string id_f = "id_f";
-  ResourceEntry entry_f;
-  entry_f.set_local_id(id_f);
-  FileCacheEntry* file_cache_entry_f =
-      entry_f.mutable_file_specific_info()->mutable_cache_state();
-  file_cache_entry_f->set_is_present(true);
-  file_cache_entry_f->set_is_pinned(false);
-  file_cache_entry_f->set_is_dirty(true);
-  ASSERT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry_f));
-  const base::FilePath old_file_path_f = old_cache_dir.AppendASCII(id_f);
-  const base::FilePath new_file_path_f = new_cache_dir.AppendASCII(id_f);
-  const base::FilePath link_path_f = link_dir.AppendASCII(id_f);
-  ASSERT_TRUE(base::CopyFile(temp_file, old_file_path_f));
-
-  // Entry G: partially migrated pinned cache file.
-  const std::string id_g = "id_g";
-  ResourceEntry entry_g;
-  entry_g.set_local_id(id_g);
-  FileCacheEntry* file_cache_entry_g =
-      entry_g.mutable_file_specific_info()->mutable_cache_state();
-  file_cache_entry_g->set_is_present(true);
-  file_cache_entry_g->set_is_pinned(true);
-  file_cache_entry_g->set_is_dirty(false);
-  ASSERT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry_g));
-  const base::FilePath old_file_path_g = old_cache_dir.AppendASCII(id_g);
-  const base::FilePath new_file_path_g = new_cache_dir.AppendASCII(id_g);
-  const base::FilePath link_path_g = link_dir.AppendASCII(id_g);
-  ASSERT_TRUE(base::CopyFile(temp_file, old_file_path_g));
-  ASSERT_EQ(0, link(old_file_path_g.AsUTF8Unsafe().c_str(),
-                    link_path_g.AsUTF8Unsafe().c_str()));
-
-  // Entry H: pinned entry without cache file.
-  const std::string id_h = "id_h";
-  ResourceEntry entry_h;
-  entry_h.set_local_id(id_h);
-  FileCacheEntry* file_cache_entry_h =
-      entry_h.mutable_file_specific_info()->mutable_cache_state();
-  file_cache_entry_h->set_is_present(true);
-  file_cache_entry_h->set_is_pinned(true);
-  file_cache_entry_h->set_is_dirty(false);
-  ASSERT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry_h));
-
-  // Entry I: already migrated pinned cache file.
-  const std::string id_i = "id_i";
-  ResourceEntry entry_i;
-  entry_i.set_local_id(id_i);
-  FileCacheEntry* file_cache_entry_i =
-      entry_i.mutable_file_specific_info()->mutable_cache_state();
-  file_cache_entry_i->set_is_present(true);
-  file_cache_entry_i->set_is_pinned(true);
-  file_cache_entry_i->set_is_dirty(false);
-  ASSERT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry_i));
-  const base::FilePath new_file_path_i = new_cache_dir.AppendASCII(id_i);
-  const base::FilePath link_path_i = link_dir.AppendASCII(id_i);
-  ASSERT_TRUE(base::CopyFile(temp_file, new_file_path_i));
-  ASSERT_EQ(0, link(new_file_path_i.AsUTF8Unsafe().c_str(),
-                    link_path_i.AsUTF8Unsafe().c_str()));
-
-  // Run migration.
-  ASSERT_TRUE(FileCache::MigrateCacheFiles(old_cache_dir, new_cache_dir,
-                                           link_dir, metadata_storage_.get()));
+  // Initialize resolves metadta inconsistency and invokes migration.
+  ASSERT_TRUE(cache_->Initialize());
 
   // Check result.
-  EXPECT_FALSE(base::PathExists(old_file_path_a));
-  EXPECT_TRUE(base::PathExists(new_file_path_a));
-  EXPECT_EQ(1, GetNumberOfLinks(new_file_path_a));
-  // MigrateCacheFiles doesn't delete invalid cache file.
-  EXPECT_TRUE(base::PathExists(old_file_path_b));
-  EXPECT_TRUE(base::PathExists(new_file_path_c));
-  EXPECT_EQ(1, GetNumberOfLinks(new_file_path_c));
-  EXPECT_FALSE(base::PathExists(old_file_path_e));
-  EXPECT_TRUE(base::PathExists(new_file_path_e));
-  EXPECT_TRUE(base::PathExists(link_path_e));
-  EXPECT_EQ(2, GetNumberOfLinks(new_file_path_e));
-  EXPECT_FALSE(base::PathExists(old_file_path_f));
-  EXPECT_TRUE(base::PathExists(new_file_path_f));
-  EXPECT_TRUE(base::PathExists(link_path_f));
-  EXPECT_EQ(2, GetNumberOfLinks(new_file_path_f));
-  EXPECT_FALSE(base::PathExists(old_file_path_g));
-  EXPECT_TRUE(base::PathExists(new_file_path_g));
-  EXPECT_TRUE(base::PathExists(link_path_g));
-  EXPECT_EQ(2, GetNumberOfLinks(new_file_path_g));
-  EXPECT_TRUE(base::PathExists(new_file_path_i));
-  EXPECT_TRUE(base::PathExists(link_path_i));
-  EXPECT_EQ(2, GetNumberOfLinks(new_file_path_i));
+  int64_t flags_a = Lsattr(file_path_a);
+  int64_t flags_b = Lsattr(file_path_b);
+  int64_t flags_c = Lsattr(file_path_c);
+  int64_t flags_d = Lsattr(file_path_d);
+  EXPECT_GE(flags_a, 0);

[hashimoto, 2016/05/02 08:29:20]

What is the point of these >=0 checks?

[oka, 2016/05/09 14:27:41]

Replaced with ExpectIs*.

+  EXPECT_GE(flags_b, 0);
+  EXPECT_GE(flags_c, 0);
+  EXPECT_GE(flags_d, 0);
+  EXPECT_EQ(flags_a & FS_NODUMP_FL, 0);

[hashimoto, 2016/05/02 08:29:20]

nit: Why not EXPECT_TRUE/EXPECT_FALSE?

[oka, 2016/05/09 14:27:40]

Removed.

+  EXPECT_EQ(flags_b & FS_NODUMP_FL, 0);
+  EXPECT_EQ(flags_c & FS_NODUMP_FL, FS_NODUMP_FL);
+  EXPECT_EQ(flags_d & FS_NODUMP_FL, 0);
+
+  EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_e, &entry_e));
+  EXPECT_FALSE(entry_e.file_specific_info().cache_state().is_present());
+
+  // Check the cache dir has appropriate attributes.
+  int64_t flags_cache_dir = Lsattr(cache_files_dir_);
+  EXPECT_GE(flags_cache_dir, 0);
+  EXPECT_EQ(flags_cache_dir & FS_NODUMP_FL, FS_NODUMP_FL);
+
+  std::string value = "";
+  value.resize(4);
+  char* v = string_as_array(&value);
+  ASSERT_EQ(getxattr(cache_files_dir_.value().c_str(), "user.GCacheFiles", v,
+        5), 5);
+  EXPECT_STREQ(value.c_str(), "true");
+}
+
+TEST_F(FileCacheTest, MigrationHappensOnlyOnce) {
+  ASSERT_TRUE(cache_->Initialize());
+  EXPECT_FALSE(cache_->ShouldStartDriveCacheMigration());
 }
 
 TEST_F(FileCacheTest, ClearAll) {
+  ASSERT_TRUE(cache_->Initialize());
   const std::string id("1a2b");
   const std::string md5("abcdef0123456789");
 
   // Store an existing file.
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   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));
 
   // Clear cache.
   EXPECT_TRUE(cache_->ClearAll());
 
   // Verify that the cache is removed.
   EXPECT_TRUE(base::IsDirectoryEmpty(cache_files_dir_));
 }
 
 }  // namespace internal
 }  // namespace drive