drive: Use ResourceMetadataStorage from FileCache

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/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/fake_free_disk_space_getter.h"
 #include "chrome/browser/chromeos/drive/file_cache_metadata.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
+#include "chrome/browser/chromeos/drive/resource_metadata_storage.h"
 #include "chrome/browser/chromeos/drive/test_util.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace drive {
 namespace internal {
 namespace {
 
@@ skipping 38 matching lines @@
         temp_dir_.path().Append(util::kCacheFileDirectory)));
 
     ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(),
                                                     &dummy_file_path_));
     fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
 
     scoped_refptr<base::SequencedWorkerPool> pool =
         content::BrowserThread::GetBlockingPool();
     blocking_task_runner_ =
         pool->GetSequencedTaskRunner(pool->GetSequenceToken());
-    cache_.reset(new FileCache(
-        temp_dir_.path().Append(util::kMetadataDirectory),
-        temp_dir_.path().Append(util::kCacheFileDirectory),
-        blocking_task_runner_.get(),
-        fake_free_disk_space_getter_.get()));
+
+    metadata_storage_.reset(new ResourceMetadataStorage(
+        temp_dir_.path(), blocking_task_runner_));
 
     bool success = false;
     base::PostTaskAndReplyWithResult(
         blocking_task_runner_,
         FROM_HERE,
+        base::Bind(&ResourceMetadataStorage::Initialize,
+                   base::Unretained(metadata_storage_.get())),
+        google_apis::test_util::CreateCopyResultCallback(&success));
+    google_apis::test_util::RunBlockingPoolTask();
+    ASSERT_TRUE(success);
+
+    cache_.reset(new FileCache(
+        metadata_storage_.get(),
+        temp_dir_.path().Append(util::kCacheFileDirectory),
+        blocking_task_runner_.get(),
+        fake_free_disk_space_getter_.get()));
+
+    success = false;
+    base::PostTaskAndReplyWithResult(
+        blocking_task_runner_,
+        FROM_HERE,
         base::Bind(&FileCache::Initialize,
                    base::Unretained(cache_.get())),
         google_apis::test_util::CreateCopyResultCallback(&success));
     google_apis::test_util::RunBlockingPoolTask();
     ASSERT_TRUE(success);
   }
 
-  virtual void TearDown() OVERRIDE {
-    cache_.reset();
-  }
-
   void TestGetFileFromCacheByResourceIdAndMd5(
       const std::string& resource_id,
       const std::string& md5,
       FileError expected_error,
       const std::string& expected_file_extension) {
     FileError error = FILE_ERROR_OK;
     base::FilePath cache_file_path;
     cache_->GetFileOnUIThread(resource_id, md5,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &cache_file_path));
@@ skipping 304 matching lines @@
                 current.BaseName().value());
     }
     return num_files_found;
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   base::ScopedTempDir temp_dir_;
   base::FilePath dummy_file_path_;
 
+  scoped_ptr<ResourceMetadataStorage, test_util::DestroyHelperForTests>
+      metadata_storage_;
   scoped_ptr<FileCache, test_util::DestroyHelperForTests> cache_;
   scoped_ptr<FakeFreeDiskSpaceGetter> fake_free_disk_space_getter_;
 
   FileError expected_error_;
   int expected_cache_state_;
   std::string expected_file_extension_;
 };
 
 TEST_F(FileCacheTestOnUIThread, GetCacheFilePath) {
   // Use alphanumeric characters for resource id.
@@ skipping 414 matching lines @@
   std::string md5("abcdef0123456789");
 
   // Try to store an existing file.
   TestStoreToCache(resource_id, md5, dummy_file_path_, FILE_ERROR_NO_SPACE,
                    TEST_CACHE_STATE_NONE);
 
   // Verify that there's no files added.
   EXPECT_EQ(0U, CountCacheFiles(resource_id, md5));
 }
 
-// Don't use TEST_F, as we don't want SetUp() and TearDown() for this test.
-TEST(FileCacheExtraTest, InitializationFailure) {
-  content::TestBrowserThreadBundle thread_bundle;
-
-  // Set the cache root to a non existent path, so the initialization fails.
-  scoped_ptr<FileCache, test_util::DestroyHelperForTests> cache(new FileCache(
-      base::FilePath::FromUTF8Unsafe("/somewhere/nonexistent/blah/meta"),
-      base::FilePath::FromUTF8Unsafe("/somewhere/nonexistent/blah/files"),
-      base::MessageLoopProxy::current(),
-      NULL /* free_disk_space_getter */));
-
-  EXPECT_FALSE(cache->Initialize());
-}
-
 TEST_F(FileCacheTestOnUIThread, UpdatePinnedCache) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   std::string md5_modified("aaaaaa0000000000");
 
   // Store an existing file.
   TestStoreToCache(resource_id, md5, dummy_file_path_, FILE_ERROR_OK,
                    TEST_CACHE_STATE_PRESENT);
 
   // Pin the file.
@@ skipping 10 matching lines @@
  protected:
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(file_util::CreateDirectory(
         temp_dir_.path().Append(util::kMetadataDirectory)));
     ASSERT_TRUE(file_util::CreateDirectory(
         temp_dir_.path().Append(util::kCacheFileDirectory)));
 
     fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
 
+    metadata_storage_.reset(new ResourceMetadataStorage(
+        temp_dir_.path().Append(util::kMetadataDirectory),
+        base::MessageLoopProxy::current()));
+    ASSERT_TRUE(metadata_storage_->Initialize());
+
     cache_.reset(new FileCache(
-        temp_dir_.path().Append(util::kMetadataDirectory),
+        metadata_storage_.get(),
         temp_dir_.path().Append(util::kCacheFileDirectory),
         base::MessageLoopProxy::current(),
         fake_free_disk_space_getter_.get()));
-
     ASSERT_TRUE(cache_->Initialize());
   }
 
   virtual void TearDown() OVERRIDE {
     cache_.reset();
   }
 
-  static void ImportOldDB(FileCache* cache, const base::FilePath& old_db_path) {
-    cache->ImportOldDB(old_db_path);
+  static bool ImportOldDB(FileCache* cache, const base::FilePath& old_db_path) {
+    return cache->ImportOldDB(old_db_path);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir temp_dir_;
 
+  scoped_ptr<ResourceMetadataStorage, test_util::DestroyHelperForTests>
+      metadata_storage_;
   scoped_ptr<FileCache, test_util::DestroyHelperForTests> cache_;
   scoped_ptr<FakeFreeDiskSpaceGetter> fake_free_disk_space_getter_;
 };
 
 TEST_F(FileCacheTest, ScanCacheFile) {
   // Set up files in the cache directory.
-  const base::FilePath directory =
+  const base::FilePath file_directory =
       temp_dir_.path().Append(util::kCacheFileDirectory);
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(
-      directory.AppendASCII("id_foo.md5foo"), "foo"));
+      file_directory.AppendASCII("id_foo.md5foo"), "foo"));
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(
-      directory.AppendASCII("id_bar.local"), "bar"));
+      file_directory.AppendASCII("id_bar.local"), "bar"));
 
   // Remove the existing DB.
-  ASSERT_TRUE(file_util::Delete(
-      temp_dir_.path().Append(util::kMetadataDirectory), true /* recursive */));
+  const base::FilePath metadata_directory =
+      temp_dir_.path().Append(util::kMetadataDirectory);
+  ASSERT_TRUE(file_util::Delete(metadata_directory, true /* recursive */));
+
+  // Put an empty file with the same name as old DB.
+  // This file cannot be opened by ImportOldDB() and will be dismissed.
+  ASSERT_TRUE(file_util::CreateDirectory(metadata_directory));
+  ASSERT_TRUE(google_apis::test_util::WriteStringToFile(
+      metadata_directory.Append(FileCache::kOldCacheMetadataDBName), ""));
 
   // Create a new cache and initialize it.
-  cache_.reset(new FileCache(temp_dir_.path().Append(util::kMetadataDirectory),
+  metadata_storage_.reset(new ResourceMetadataStorage(
+      metadata_directory, base::MessageLoopProxy::current()));
+  ASSERT_TRUE(metadata_storage_->Initialize());
+
+  cache_.reset(new FileCache(metadata_storage_.get(),
                              temp_dir_.path().Append(util::kCacheFileDirectory),
                              base::MessageLoopProxy::current(),
                              fake_free_disk_space_getter_.get()));
   ASSERT_TRUE(cache_->Initialize());
 
   // Check contents of the cache.
   FileCacheEntry cache_entry;
   EXPECT_TRUE(cache_->GetCacheEntry("id_foo", std::string(), &cache_entry));
   EXPECT_TRUE(cache_entry.is_present());
   EXPECT_EQ("md5foo", cache_entry.md5());
@@ skipping 61 matching lines @@
     FileCacheEntry entry;
     entry.set_md5(md5_1);
     old_metadata.AddOrUpdateCacheEntry(key1, entry);
 
     entry.set_md5(md5_2);
     old_metadata.AddOrUpdateCacheEntry(key2, entry);
   }
   EXPECT_TRUE(file_util::PathExists(old_db_path));
 
   // Do import.
-  ImportOldDB(cache_.get(), old_db_path);
+  EXPECT_TRUE(ImportOldDB(cache_.get(), old_db_path));
 
   // Old DB should be removed.
   EXPECT_FALSE(file_util::PathExists(old_db_path));
 
   // Data is imported correctly.
   FileCacheEntry entry;
   EXPECT_TRUE(cache_->GetCacheEntry(key1, std::string(), &entry));
   EXPECT_EQ(md5_1, entry.md5());
   EXPECT_TRUE(cache_->GetCacheEntry(key2, std::string(), &entry));
   EXPECT_EQ(md5_2, entry.md5());
 }
 
 }  // namespace internal
 }  // namespace drive